Changeset 194314 in webkit
- Timestamp:
- Dec 19, 2015 8:52:11 AM (8 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 15 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r194312 r194314 1 2015-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 1 49 2015-12-19 Benjamin Poulain <bpoulain@apple.com> 2 50 -
trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp
r194062 r194314 159 159 } 160 160 161 TriState 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 161 172 void ConstDoubleValue::dumpMeta(CommaPrinter& comma, PrintStream& out) const 162 173 { -
trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h
r194062 r194314 61 61 TriState lessEqualConstant(const Value* other) const override; 62 62 TriState greaterEqualConstant(const Value* other) const override; 63 TriState equalOrUnorderedConstant(const Value* other) const override; 63 64 64 65 protected: -
trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp
r194067 r194314 1155 1155 case GreaterEqual: 1156 1156 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); 1157 1160 case Above: 1158 1161 // We use a bogus double condition because these integer comparisons won't got down that … … 1842 1845 case Below: 1843 1846 case AboveEqual: 1844 case BelowEqual: { 1847 case BelowEqual: 1848 case EqualOrUnordered: { 1845 1849 m_insts.last().append(createCompare(m_value)); 1846 1850 return; -
trunk/Source/JavaScriptCore/b3/B3Opcode.cpp
r194062 r194314 216 216 out.print("BelowEqual"); 217 217 return; 218 case EqualOrUnordered: 219 out.print("EqualOrUnordered"); 220 return; 218 221 case Select: 219 222 out.print("Select"); -
trunk/Source/JavaScriptCore/b3/B3Opcode.h
r194062 r194314 124 124 BelowEqual, 125 125 126 // Unordered floating point compare: values are equal or either one is NaN. 127 EqualOrUnordered, 128 126 129 // SSA form of conditional move. The first child is evaluated for truthiness. If true, the second child 127 130 // is returned. Otherwise, the third child is returned. -
trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp
r194062 r194314 107 107 case LessEqual: 108 108 case GreaterEqual: 109 case EqualOrUnordered: 109 110 if (value->child(0)->opcode() == FloatToDouble && value->child(1)->opcode() == FloatToDouble) { 110 111 value->child(0) = value->child(0)->child(0); -
trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp
r194062 r194314 1011 1011 break; 1012 1012 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 1013 1026 case CheckAdd: 1014 1027 if (replaceWithNewValue(m_value->child(0)->checkAddConstant(m_proc, m_value->child(1)))) -
trunk/Source/JavaScriptCore/b3/B3Validate.cpp
r194062 r194314 256 256 VALIDATE(value->type() == Int32, ("At ", *value)); 257 257 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; 258 264 case Select: 259 265 VALIDATE(value->numChildren() == 3, ("At ", *value)); -
trunk/Source/JavaScriptCore/b3/B3Value.cpp
r194062 r194314 287 287 } 288 288 289 TriState Value::equalOrUnorderedConstant(const Value*) const 290 { 291 return MixedTriState; 292 } 293 289 294 Value* Value::invertedCompare(Procedure& proc) const 290 295 { … … 316 321 case AboveEqual: 317 322 case BelowEqual: 323 case EqualOrUnordered: 318 324 return true; 319 325 case Phi: … … 391 397 case AboveEqual: 392 398 case BelowEqual: 399 case EqualOrUnordered: 393 400 case Select: 394 401 break; … … 485 492 case AboveEqual: 486 493 case BelowEqual: 494 case EqualOrUnordered: 487 495 case CheckAdd: 488 496 case CheckSub: … … 579 587 case AboveEqual: 580 588 case BelowEqual: 589 case EqualOrUnordered: 581 590 return Int32; 582 591 case SExt32: -
trunk/Source/JavaScriptCore/b3/B3Value.h
r194062 r194314 146 146 virtual TriState aboveEqualConstant(const Value* other) const; 147 147 virtual TriState belowEqualConstant(const Value* other) const; 148 virtual TriState equalOrUnorderedConstant(const Value* other) const; 148 149 149 150 // If the value is a comparison then this returns the inverted form of that comparison, if -
trunk/Source/JavaScriptCore/b3/testb3.cpp
r194312 r194314 5095 5095 CHECK(invoke<int>(*code, 42) == 1); 5096 5096 CHECK(invoke<int>(*code, 0) == 0); 5097 } 5098 5099 void 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 5128 void 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 5160 void 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 5194 void 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 5230 void 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 5259 void 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 5290 void 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 5319 void 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 5349 void 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); 5097 5381 } 5098 5382 … … 9123 9407 RUN(testBranchEqualCommute()); 9124 9408 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>()); 9125 9420 RUN(testBranchFold(42)); 9126 9421 RUN(testBranchFold(0)); -
trunk/Source/JavaScriptCore/ftl/FTLB3Output.h
r194185 r194314 337 337 LValue doubleGreaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); } 338 338 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 } 340 344 LValue doubleLessThanOrUnordered(LValue left, LValue right) 341 345 { -
trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp
r194248 r194314 7306 7306 return m_out.notZero32(lowInt32(edge)); 7307 7307 case DoubleRepUse: 7308 return m_out.doubleNotEqual (lowDouble(edge), m_out.doubleZero);7308 return m_out.doubleNotEqualAndOrdered(lowDouble(edge), m_out.doubleZero); 7309 7309 case ObjectOrOtherUse: 7310 7310 return m_out.bitNot( … … 7400 7400 7401 7401 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( 7405 7403 unboxDouble(value), m_out.constDouble(0)); 7406 7404 results.append(m_out.anchor(doubleIsTruthy)); -
trunk/Source/JavaScriptCore/ftl/FTLOutput.h
r194073 r194314 377 377 LValue doubleGreaterThan(LValue left, LValue right) { return fcmp(LLVMRealOGT, left, right); } 378 378 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); } 380 380 LValue doubleLessThanOrUnordered(LValue left, LValue right) { return fcmp(LLVMRealULT, left, right); } 381 381 LValue doubleLessThanOrEqualOrUnordered(LValue left, LValue right) { return fcmp(LLVMRealULE, left, right); }
Note: See TracChangeset
for help on using the changeset viewer.