Changeset 194314 in webkit


Ignore:
Timestamp:
Dec 19, 2015 8:52:11 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

[JSC] Add EqualOrUnordered to B3
​https://bugs.webkit.org/show_bug.cgi?id=152425

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2015-12-19
Reviewed by Mark Lam.

Add EqualOrUnordered to B3 and use it to implements
FTL::Output's NotEqualAndOrdered.

  • b3/B3ConstDoubleValue.cpp:

(JSC::B3::ConstDoubleValue::equalOrUnordered):

  • b3/B3ConstDoubleValue.h:
  • b3/B3LowerToAir.cpp:

(JSC::B3::Air::LowerToAir::createGenericCompare):
(JSC::B3::Air::LowerToAir::lower):

  • b3/B3Opcode.cpp:

(WTF::printInternal):

  • b3/B3Opcode.h:
  • b3/B3ReduceDoubleToFloat.cpp:

(JSC::B3::reduceDoubleToFloat):

  • b3/B3ReduceStrength.cpp:
  • b3/B3Validate.cpp:
  • b3/B3Value.cpp:

(JSC::B3::Value::equalOrUnordered):
(JSC::B3::Value::returnsBool):
(JSC::B3::Value::effects):
(JSC::B3::Value::key):
(JSC::B3::Value::typeFor):

  • b3/B3Value.h:
  • b3/testb3.cpp:

(JSC::B3::testBranchEqualOrUnorderedArgs):
(JSC::B3::testBranchNotEqualAndOrderedArgs):
(JSC::B3::testBranchEqualOrUnorderedDoubleArgImm):
(JSC::B3::testBranchEqualOrUnorderedFloatArgImm):
(JSC::B3::testBranchEqualOrUnorderedDoubleImms):
(JSC::B3::testBranchEqualOrUnorderedFloatImms):
(JSC::B3::testBranchEqualOrUnorderedFloatWithUselessDoubleConversion):
(JSC::B3::run):

  • ftl/FTLB3Output.h:

(JSC::FTL::Output::doubleNotEqualAndOrdered):
(JSC::FTL::Output::doubleNotEqual): Deleted.

  • ftl/FTLLowerDFGToLLVM.cpp:

(JSC::FTL::DFG::LowerDFGToLLVM::boolify):

  • ftl/FTLOutput.h:

(JSC::FTL::Output::doubleNotEqualAndOrdered):
(JSC::FTL::Output::doubleNotEqual): Deleted.

Location:
trunk/Source/JavaScriptCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r194312 r194314  
     12015-12-19  Benjamin Poulain  <bpoulain@apple.com>
     2
     3        [JSC] Add EqualOrUnordered to B3
     4        https://bugs.webkit.org/show_bug.cgi?id=152425
     5
     6        Reviewed by Mark Lam.
     7
     8        Add EqualOrUnordered to B3 and use it to implements
     9        FTL::Output's NotEqualAndOrdered.
     10
     11        * b3/B3ConstDoubleValue.cpp:
     12        (JSC::B3::ConstDoubleValue::equalOrUnordered):
     13        * b3/B3ConstDoubleValue.h:
     14        * b3/B3LowerToAir.cpp:
     15        (JSC::B3::Air::LowerToAir::createGenericCompare):
     16        (JSC::B3::Air::LowerToAir::lower):
     17        * b3/B3Opcode.cpp:
     18        (WTF::printInternal):
     19        * b3/B3Opcode.h:
     20        * b3/B3ReduceDoubleToFloat.cpp:
     21        (JSC::B3::reduceDoubleToFloat):
     22        * b3/B3ReduceStrength.cpp:
     23        * b3/B3Validate.cpp:
     24        * b3/B3Value.cpp:
     25        (JSC::B3::Value::equalOrUnordered):
     26        (JSC::B3::Value::returnsBool):
     27        (JSC::B3::Value::effects):
     28        (JSC::B3::Value::key):
     29        (JSC::B3::Value::typeFor):
     30        * b3/B3Value.h:
     31        * b3/testb3.cpp:
     32        (JSC::B3::testBranchEqualOrUnorderedArgs):
     33        (JSC::B3::testBranchNotEqualAndOrderedArgs):
     34        (JSC::B3::testBranchEqualOrUnorderedDoubleArgImm):
     35        (JSC::B3::testBranchEqualOrUnorderedFloatArgImm):
     36        (JSC::B3::testBranchEqualOrUnorderedDoubleImms):
     37        (JSC::B3::testBranchEqualOrUnorderedFloatImms):
     38        (JSC::B3::testBranchEqualOrUnorderedFloatWithUselessDoubleConversion):
     39        (JSC::B3::run):
     40        * ftl/FTLB3Output.h:
     41        (JSC::FTL::Output::doubleNotEqualAndOrdered):
     42        (JSC::FTL::Output::doubleNotEqual): Deleted.
     43        * ftl/FTLLowerDFGToLLVM.cpp:
     44        (JSC::FTL::DFG::LowerDFGToLLVM::boolify):
     45        * ftl/FTLOutput.h:
     46        (JSC::FTL::Output::doubleNotEqualAndOrdered):
     47        (JSC::FTL::Output::doubleNotEqual): Deleted.
     48
    1492015-12-19  Benjamin Poulain  <bpoulain@apple.com>
    250

  • trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp

    r194062 r194314  
    159159}
    160160
     161TriState ConstDoubleValue::equalOrUnorderedConstant(const Value* other) const
     162{
     163    if (std::isnan(m_value))
     164        return TrueTriState;
     165
     166    if (!other->hasDouble())
     167        return MixedTriState;
     168    double otherValue = other->asDouble();
     169    return triState(std::isunordered(m_value, otherValue) || m_value == otherValue);
     170}
     171
    161172void ConstDoubleValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const
    162173{

  • trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h

    r194062 r194314  
    6161    TriState lessEqualConstant(const Value* other) const override;
    6262    TriState greaterEqualConstant(const Value* other) const override;
     63    TriState equalOrUnorderedConstant(const Value* other) const override;
    6364
    6465protected:

  • trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp

    r194067 r194314  
    11551155            case GreaterEqual:
    11561156                return createRelCond(MacroAssembler::GreaterThanOrEqual, MacroAssembler::DoubleGreaterThanOrEqual);
     1157            case EqualOrUnordered:
     1158                // The integer condition is never used in this case.
     1159                return createRelCond(MacroAssembler::Equal, MacroAssembler::DoubleEqualOrUnordered);
    11571160            case Above:
    11581161                // We use a bogus double condition because these integer comparisons won't got down that
    … …  
    18421845        case Below:
    18431846        case AboveEqual:
    1844         case BelowEqual: {
     1847        case BelowEqual:
     1848        case EqualOrUnordered: {
    18451849            m_insts.last().append(createCompare(m_value));
    18461850            return;

  • trunk/Source/JavaScriptCore/b3/B3Opcode.cpp

    r194062 r194314  
    216216        out.print("BelowEqual");
    217217        return;
     218    case EqualOrUnordered:
     219        out.print("EqualOrUnordered");
     220        return;
    218221    case Select:
    219222        out.print("Select");

  • trunk/Source/JavaScriptCore/b3/B3Opcode.h

    r194062 r194314  
    124124    BelowEqual,
    125125
     126    // Unordered floating point compare: values are equal or either one is NaN.
     127    EqualOrUnordered,
     128
    126129    // SSA form of conditional move. The first child is evaluated for truthiness. If true, the second child
    127130    // is returned. Otherwise, the third child is returned.

  • trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp

    r194062 r194314  
    107107            case LessEqual:
    108108            case GreaterEqual:
     109            case EqualOrUnordered:
    109110                if (value->child(0)->opcode() == FloatToDouble && value->child(1)->opcode() == FloatToDouble) {
    110111                    value->child(0) = value->child(0)->child(0);

  • trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp

    r194062 r194314  
    10111011            break;
    10121012
     1013        case EqualOrUnordered:
     1014            handleCommutativity();
     1015
     1016            // Turn this: Equal(const1, const2)
     1017            // Into this: isunordered(const1, const2) || const1 == const2.
     1018            // Turn this: Equal(value, const_NaN)
     1019            // Into this: 1.
     1020            replaceWithNewValue(
     1021                m_proc.addBoolConstant(
     1022                    m_value->origin(),
     1023                    m_value->child(1)->equalOrUnorderedConstant(m_value->child(0))));
     1024            break;
     1025
    10131026        case CheckAdd:
    10141027            if (replaceWithNewValue(m_value->child(0)->checkAddConstant(m_proc, m_value->child(1))))

  • trunk/Source/JavaScriptCore/b3/B3Validate.cpp

    r194062 r194314  
    256256                VALIDATE(value->type() == Int32, ("At ", *value));
    257257                break;
     258            case EqualOrUnordered:
     259                VALIDATE(value->numChildren() == 2, ("At ", *value));
     260                VALIDATE(value->child(0)->type() == value->child(1)->type(), ("At ", *value));
     261                VALIDATE(isFloat(value->child(0)->type()), ("At ", *value));
     262                VALIDATE(value->type() == Int32, ("At ", *value));
     263                break;
    258264            case Select:
    259265                VALIDATE(value->numChildren() == 3, ("At ", *value));

  • trunk/Source/JavaScriptCore/b3/B3Value.cpp

    r194062 r194314  
    287287}
    288288
     289TriState Value::equalOrUnorderedConstant(const Value*) const
     290{
     291    return MixedTriState;
     292}
     293
    289294Value* Value::invertedCompare(Procedure& proc) const
    290295{
    … …  
    316321    case AboveEqual:
    317322    case BelowEqual:
     323    case EqualOrUnordered:
    318324        return true;
    319325    case Phi:
    … …  
    391397    case AboveEqual:
    392398    case BelowEqual:
     399    case EqualOrUnordered:
    393400    case Select:
    394401        break;
    … …  
    485492    case AboveEqual:
    486493    case BelowEqual:
     494    case EqualOrUnordered:
    487495    case CheckAdd:
    488496    case CheckSub:
    … …  
    579587    case AboveEqual:
    580588    case BelowEqual:
     589    case EqualOrUnordered:
    581590        return Int32;
    582591    case SExt32:

  • trunk/Source/JavaScriptCore/b3/B3Value.h

    r194062 r194314  
    146146    virtual TriState aboveEqualConstant(const Value* other) const;
    147147    virtual TriState belowEqualConstant(const Value* other) const;
     148    virtual TriState equalOrUnorderedConstant(const Value* other) const;
    148149
    149150    // If the value is a comparison then this returns the inverted form of that comparison, if

  • trunk/Source/JavaScriptCore/b3/testb3.cpp

    r194312 r194314  
    50955095    CHECK(invoke<int>(*code, 42) == 1);
    50965096    CHECK(invoke<int>(*code, 0) == 0);
     5097}
     5098
     5099void testBranchEqualOrUnorderedArgs(double a, double b)
     5100{
     5101    Procedure proc;
     5102    BasicBlock* root = proc.addBlock();
     5103    BasicBlock* thenCase = proc.addBlock();
     5104    BasicBlock* elseCase = proc.addBlock();
     5105
     5106    Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
     5107    Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
     5108    root->appendNew<ControlValue>(
     5109        proc, Branch, Origin(),
     5110        root->appendNew<Value>(
     5111            proc, EqualOrUnordered, Origin(),
     5112            argumentA,
     5113            argumentB),
     5114        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5115
     5116    thenCase->appendNew<ControlValue>(
     5117        proc, Return, Origin(),
     5118        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5119
     5120    elseCase->appendNew<ControlValue>(
     5121        proc, Return, Origin(),
     5122        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5123
     5124    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5125    CHECK(compileAndRun<int64_t>(proc, a, b) == expected);
     5126}
     5127
     5128void testBranchEqualOrUnorderedArgs(float a, float b)
     5129{
     5130    Procedure proc;
     5131    BasicBlock* root = proc.addBlock();
     5132    BasicBlock* thenCase = proc.addBlock();
     5133    BasicBlock* elseCase = proc.addBlock();
     5134
     5135    Value* argumentA = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5136        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
     5137    Value* argumentB = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5138        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
     5139
     5140    root->appendNew<ControlValue>(
     5141        proc, Branch, Origin(),
     5142        root->appendNew<Value>(
     5143            proc, EqualOrUnordered, Origin(),
     5144            argumentA,
     5145            argumentB),
     5146        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5147
     5148    thenCase->appendNew<ControlValue>(
     5149        proc, Return, Origin(),
     5150        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5151
     5152    elseCase->appendNew<ControlValue>(
     5153        proc, Return, Origin(),
     5154        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5155
     5156    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5157    CHECK(compileAndRun<int64_t>(proc, &a, &b) == expected);
     5158}
     5159
     5160void testBranchNotEqualAndOrderedArgs(double a, double b)
     5161{
     5162    Procedure proc;
     5163    BasicBlock* root = proc.addBlock();
     5164    BasicBlock* thenCase = proc.addBlock();
     5165    BasicBlock* elseCase = proc.addBlock();
     5166
     5167    Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
     5168    Value* argumentB = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR1);
     5169    Value* equalOrUnordered = root->appendNew<Value>(
     5170        proc, EqualOrUnordered, Origin(),
     5171        argumentA,
     5172        argumentB);
     5173    Value* notEqualAndOrdered = root->appendNew<Value>(
     5174        proc, Equal, Origin(),
     5175        root->appendNew<Const32Value>(proc, Origin(), 0),
     5176        equalOrUnordered);
     5177    root->appendNew<ControlValue>(
     5178        proc, Branch, Origin(),
     5179        notEqualAndOrdered,
     5180        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5181
     5182    thenCase->appendNew<ControlValue>(
     5183        proc, Return, Origin(),
     5184        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5185
     5186    elseCase->appendNew<ControlValue>(
     5187        proc, Return, Origin(),
     5188        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5189
     5190    int64_t expected = (!std::isunordered(a, b) && a != b) ? 42 : -13;
     5191    CHECK(compileAndRun<int64_t>(proc, a, b) == expected);
     5192}
     5193
     5194void testBranchNotEqualAndOrderedArgs(float a, float b)
     5195{
     5196    Procedure proc;
     5197    BasicBlock* root = proc.addBlock();
     5198    BasicBlock* thenCase = proc.addBlock();
     5199    BasicBlock* elseCase = proc.addBlock();
     5200
     5201    Value* argumentA = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5202        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
     5203    Value* argumentB = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5204        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
     5205    Value* equalOrUnordered = root->appendNew<Value>(
     5206        proc, EqualOrUnordered, Origin(),
     5207        argumentA,
     5208        argumentB);
     5209    Value* notEqualAndOrdered = root->appendNew<Value>(
     5210        proc, Equal, Origin(),
     5211        root->appendNew<Const32Value>(proc, Origin(), 0),
     5212        equalOrUnordered);
     5213    root->appendNew<ControlValue>(
     5214        proc, Branch, Origin(),
     5215        notEqualAndOrdered,
     5216        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5217
     5218    thenCase->appendNew<ControlValue>(
     5219        proc, Return, Origin(),
     5220        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5221
     5222    elseCase->appendNew<ControlValue>(
     5223        proc, Return, Origin(),
     5224        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5225
     5226    int64_t expected = (!std::isunordered(a, b) && a != b) ? 42 : -13;
     5227    CHECK(compileAndRun<int64_t>(proc, &a, &b) == expected);
     5228}
     5229
     5230void testBranchEqualOrUnorderedDoubleArgImm(double a, double b)
     5231{
     5232    Procedure proc;
     5233    BasicBlock* root = proc.addBlock();
     5234    BasicBlock* thenCase = proc.addBlock();
     5235    BasicBlock* elseCase = proc.addBlock();
     5236
     5237    Value* argumentA = root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0);
     5238    Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
     5239    root->appendNew<ControlValue>(
     5240        proc, Branch, Origin(),
     5241        root->appendNew<Value>(
     5242            proc, EqualOrUnordered, Origin(),
     5243            argumentA,
     5244            argumentB),
     5245        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5246
     5247    thenCase->appendNew<ControlValue>(
     5248        proc, Return, Origin(),
     5249        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5250
     5251    elseCase->appendNew<ControlValue>(
     5252        proc, Return, Origin(),
     5253        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5254
     5255    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5256    CHECK(compileAndRun<int64_t>(proc, a) == expected);
     5257}
     5258
     5259void testBranchEqualOrUnorderedFloatArgImm(float a, float b)
     5260{
     5261    Procedure proc;
     5262    BasicBlock* root = proc.addBlock();
     5263    BasicBlock* thenCase = proc.addBlock();
     5264    BasicBlock* elseCase = proc.addBlock();
     5265
     5266    Value* argumentA = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5267        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
     5268    Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
     5269
     5270    root->appendNew<ControlValue>(
     5271        proc, Branch, Origin(),
     5272        root->appendNew<Value>(
     5273            proc, EqualOrUnordered, Origin(),
     5274            argumentA,
     5275            argumentB),
     5276        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5277
     5278    thenCase->appendNew<ControlValue>(
     5279        proc, Return, Origin(),
     5280        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5281
     5282    elseCase->appendNew<ControlValue>(
     5283        proc, Return, Origin(),
     5284        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5285
     5286    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5287    CHECK(compileAndRun<int64_t>(proc, &a) == expected);
     5288}
     5289
     5290void testBranchEqualOrUnorderedDoubleImms(double a, double b)
     5291{
     5292    Procedure proc;
     5293    BasicBlock* root = proc.addBlock();
     5294    BasicBlock* thenCase = proc.addBlock();
     5295    BasicBlock* elseCase = proc.addBlock();
     5296
     5297    Value* argumentA = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
     5298    Value* argumentB = root->appendNew<ConstDoubleValue>(proc, Origin(), b);
     5299    root->appendNew<ControlValue>(
     5300        proc, Branch, Origin(),
     5301        root->appendNew<Value>(
     5302            proc, EqualOrUnordered, Origin(),
     5303            argumentA,
     5304            argumentB),
     5305        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5306
     5307    thenCase->appendNew<ControlValue>(
     5308        proc, Return, Origin(),
     5309        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5310
     5311    elseCase->appendNew<ControlValue>(
     5312        proc, Return, Origin(),
     5313        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5314
     5315    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5316    CHECK(compileAndRun<int64_t>(proc) == expected);
     5317}
     5318
     5319void testBranchEqualOrUnorderedFloatImms(float a, float b)
     5320{
     5321    Procedure proc;
     5322    BasicBlock* root = proc.addBlock();
     5323    BasicBlock* thenCase = proc.addBlock();
     5324    BasicBlock* elseCase = proc.addBlock();
     5325
     5326    Value* argumentA = root->appendNew<ConstFloatValue>(proc, Origin(), a);
     5327    Value* argumentB = root->appendNew<ConstFloatValue>(proc, Origin(), b);
     5328
     5329    root->appendNew<ControlValue>(
     5330        proc, Branch, Origin(),
     5331        root->appendNew<Value>(
     5332            proc, EqualOrUnordered, Origin(),
     5333            argumentA,
     5334            argumentB),
     5335        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5336
     5337    thenCase->appendNew<ControlValue>(
     5338        proc, Return, Origin(),
     5339        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5340
     5341    elseCase->appendNew<ControlValue>(
     5342        proc, Return, Origin(),
     5343        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5344
     5345    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5346    CHECK(compileAndRun<int64_t>(proc) == expected);
     5347}
     5348
     5349void testBranchEqualOrUnorderedFloatWithUselessDoubleConversion(float a, float b)
     5350{
     5351    Procedure proc;
     5352    BasicBlock* root = proc.addBlock();
     5353    BasicBlock* thenCase = proc.addBlock();
     5354    BasicBlock* elseCase = proc.addBlock();
     5355
     5356    Value* argument1 = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5357        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
     5358    Value* argument2 = root->appendNew<MemoryValue>(proc, Load, Float, Origin(),
     5359        root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1));
     5360    Value* argument1AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument1);
     5361    Value* argument2AsDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), argument2);
     5362
     5363    root->appendNew<ControlValue>(
     5364        proc, Branch, Origin(),
     5365        root->appendNew<Value>(
     5366            proc, EqualOrUnordered, Origin(),
     5367            argument1AsDouble,
     5368            argument2AsDouble),
     5369        FrequentedBlock(thenCase), FrequentedBlock(elseCase));
     5370
     5371    thenCase->appendNew<ControlValue>(
     5372        proc, Return, Origin(),
     5373        thenCase->appendNew<Const32Value>(proc, Origin(), 42));
     5374
     5375    elseCase->appendNew<ControlValue>(
     5376        proc, Return, Origin(),
     5377        elseCase->appendNew<Const32Value>(proc, Origin(), -13));
     5378
     5379    int64_t expected = (std::isunordered(a, b) || a == b) ? 42 : -13;
     5380    CHECK(compileAndRun<int64_t>(proc, &a, &b) == expected);
    50975381}
    50985382
    … …  
    91239407    RUN(testBranchEqualCommute());
    91249408    RUN(testBranchEqualEqual1());
     9409    RUN_BINARY(testBranchEqualOrUnorderedArgs, floatingPointOperands<double>(), floatingPointOperands<double>());
     9410    RUN_BINARY(testBranchEqualOrUnorderedArgs, floatingPointOperands<float>(), floatingPointOperands<float>());
     9411    RUN_BINARY(testBranchNotEqualAndOrderedArgs, floatingPointOperands<double>(), floatingPointOperands<double>());
     9412    RUN_BINARY(testBranchNotEqualAndOrderedArgs, floatingPointOperands<float>(), floatingPointOperands<float>());
     9413    RUN_BINARY(testBranchEqualOrUnorderedDoubleArgImm, floatingPointOperands<double>(), floatingPointOperands<double>());
     9414    RUN_BINARY(testBranchEqualOrUnorderedFloatArgImm, floatingPointOperands<float>(), floatingPointOperands<float>());
     9415    RUN_BINARY(testBranchEqualOrUnorderedDoubleImms, floatingPointOperands<double>(), floatingPointOperands<double>());
     9416    RUN_BINARY(testBranchEqualOrUnorderedFloatImms, floatingPointOperands<float>(), floatingPointOperands<float>());
     9417    RUN_BINARY(testBranchEqualOrUnorderedFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     9418    RUN_BINARY(testBranchNotEqualAndOrderedArgs, floatingPointOperands<double>(), floatingPointOperands<double>());
     9419    RUN_BINARY(testBranchNotEqualAndOrderedArgs, floatingPointOperands<float>(), floatingPointOperands<float>());
    91259420    RUN(testBranchFold(42));
    91269421    RUN(testBranchFold(0));

  • trunk/Source/JavaScriptCore/ftl/FTLB3Output.h

    r194185 r194314  
    337337    LValue doubleGreaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); }
    338338    LValue doubleGreaterThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right); }
    339     LValue doubleNotEqual(LValue left, LValue right) { CRASH(); }
     339    LValue doubleNotEqualAndOrdered(LValue left, LValue right)
     340    {
     341        LValue equalOrUnordered = m_block->appendNew<B3::Value>(m_proc, B3::EqualOrUnordered, origin(), left, right);
     342        return bitXor(equalOrUnordered, int32One);
     343    }
    340344    LValue doubleLessThanOrUnordered(LValue left, LValue right)
    341345    {

  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp

    r194248 r194314  
    73067306            return m_out.notZero32(lowInt32(edge));
    73077307        case DoubleRepUse:
    7308             return m_out.doubleNotEqual(lowDouble(edge), m_out.doubleZero);
     7308            return m_out.doubleNotEqualAndOrdered(lowDouble(edge), m_out.doubleZero);
    73097309        case ObjectOrOtherUse:
    73107310            return m_out.bitNot(
    … …  
    74007400           
    74017401            m_out.appendTo(doubleCase, notDoubleCase);
    7402             // Note that doubleNotEqual() really means not-equal-and-ordered. It will return false
    7403             // if value is NaN.
    7404             LValue doubleIsTruthy = m_out.doubleNotEqual(
     7402            LValue doubleIsTruthy = m_out.doubleNotEqualAndOrdered(
    74057403                unboxDouble(value), m_out.constDouble(0));
    74067404            results.append(m_out.anchor(doubleIsTruthy));

  • trunk/Source/JavaScriptCore/ftl/FTLOutput.h

    r194073 r194314  
    377377    LValue doubleGreaterThan(LValue left, LValue right) { return fcmp(LLVMRealOGT, left, right); }
    378378    LValue doubleGreaterThanOrEqual(LValue left, LValue right) { return fcmp(LLVMRealOGE, left, right); }
    379     LValue doubleNotEqual(LValue left, LValue right) { return fcmp(LLVMRealONE, left, right); }
     379    LValue doubleNotEqualAndOrdered(LValue left, LValue right) { return fcmp(LLVMRealONE, left, right); }
    380380    LValue doubleLessThanOrUnordered(LValue left, LValue right) { return fcmp(LLVMRealULT, left, right); }
    381381    LValue doubleLessThanOrEqualOrUnordered(LValue left, LValue right) { return fcmp(LLVMRealULE, left, right); }
Note: See TracChangeset for help on using the changeset viewer.