1 // Copyright 2013 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_COMPILER_MACHINE_OPERATOR_H_ 6 #define V8_COMPILER_MACHINE_OPERATOR_H_ 7 8 #include "src/base/flags.h" 9 #include "src/machine-type.h" 10 11 namespace v8 { 12 namespace internal { 13 namespace compiler { 14 15 // Forward declarations. 16 struct MachineOperatorGlobalCache; 17 class Operator; 18 19 20 // For operators that are not supported on all platforms. 21 class OptionalOperator final { 22 public: 23 explicit OptionalOperator(const Operator* op) : op_(op) {} 24 25 bool IsSupported() const { return op_ != nullptr; } 26 const Operator* op() const { 27 DCHECK_NOT_NULL(op_); 28 return op_; 29 } 30 31 private: 32 const Operator* const op_; 33 }; 34 35 36 // A Load needs a MachineType. 37 typedef MachineType LoadRepresentation; 38 39 LoadRepresentation LoadRepresentationOf(Operator const*); 40 41 // A Store needs a MachineType and a WriteBarrierKind in order to emit the 42 // correct write barrier. 43 class StoreRepresentation final { 44 public: 45 StoreRepresentation(MachineRepresentation representation, 46 WriteBarrierKind write_barrier_kind) 47 : representation_(representation), 48 write_barrier_kind_(write_barrier_kind) {} 49 50 MachineRepresentation representation() const { return representation_; } 51 WriteBarrierKind write_barrier_kind() const { return write_barrier_kind_; } 52 53 private: 54 MachineRepresentation representation_; 55 WriteBarrierKind write_barrier_kind_; 56 }; 57 58 bool operator==(StoreRepresentation, StoreRepresentation); 59 bool operator!=(StoreRepresentation, StoreRepresentation); 60 61 size_t hash_value(StoreRepresentation); 62 63 std::ostream& operator<<(std::ostream&, StoreRepresentation); 64 65 StoreRepresentation const& StoreRepresentationOf(Operator const*); 66 67 68 // A CheckedLoad needs a MachineType. 69 typedef MachineType CheckedLoadRepresentation; 70 71 CheckedLoadRepresentation CheckedLoadRepresentationOf(Operator const*); 72 73 74 // A CheckedStore needs a MachineType. 75 typedef MachineRepresentation CheckedStoreRepresentation; 76 77 CheckedStoreRepresentation CheckedStoreRepresentationOf(Operator const*); 78 79 MachineRepresentation StackSlotRepresentationOf(Operator const* op); 80 81 MachineRepresentation AtomicStoreRepresentationOf(Operator const* op); 82 83 // Interface for building machine-level operators. These operators are 84 // machine-level but machine-independent and thus define a language suitable 85 // for generating code to run on architectures such as ia32, x64, arm, etc. 86 class MachineOperatorBuilder final : public ZoneObject { 87 public: 88 // Flags that specify which operations are available. This is useful 89 // for operations that are unsupported by some back-ends. 90 enum Flag { 91 kNoFlags = 0u, 92 // Note that Float*Max behaves like `(b < a) ? a : b`, not like Math.max(). 93 // Note that Float*Min behaves like `(a < b) ? a : b`, not like Math.min(). 94 kFloat32Max = 1u << 0, 95 kFloat32Min = 1u << 1, 96 kFloat64Max = 1u << 2, 97 kFloat64Min = 1u << 3, 98 kFloat32RoundDown = 1u << 4, 99 kFloat64RoundDown = 1u << 5, 100 kFloat32RoundUp = 1u << 6, 101 kFloat64RoundUp = 1u << 7, 102 kFloat32RoundTruncate = 1u << 8, 103 kFloat64RoundTruncate = 1u << 9, 104 kFloat32RoundTiesEven = 1u << 10, 105 kFloat64RoundTiesEven = 1u << 11, 106 kFloat64RoundTiesAway = 1u << 12, 107 kInt32DivIsSafe = 1u << 13, 108 kUint32DivIsSafe = 1u << 14, 109 kWord32ShiftIsSafe = 1u << 15, 110 kWord32Ctz = 1u << 16, 111 kWord64Ctz = 1u << 17, 112 kWord32Popcnt = 1u << 18, 113 kWord64Popcnt = 1u << 19, 114 kWord32ReverseBits = 1u << 20, 115 kWord64ReverseBits = 1u << 21, 116 kFloat32Neg = 1u << 22, 117 kFloat64Neg = 1u << 23, 118 kAllOptionalOps = 119 kFloat32Max | kFloat32Min | kFloat64Max | kFloat64Min | 120 kFloat32RoundDown | kFloat64RoundDown | kFloat32RoundUp | 121 kFloat64RoundUp | kFloat32RoundTruncate | kFloat64RoundTruncate | 122 kFloat64RoundTiesAway | kFloat32RoundTiesEven | kFloat64RoundTiesEven | 123 kWord32Ctz | kWord64Ctz | kWord32Popcnt | kWord64Popcnt | 124 kWord32ReverseBits | kWord64ReverseBits | kFloat32Neg | kFloat64Neg 125 }; 126 typedef base::Flags<Flag, unsigned> Flags; 127 128 class AlignmentRequirements { 129 public: 130 enum UnalignedAccessSupport { kNoSupport, kSomeSupport, kFullSupport }; 131 132 bool IsUnalignedLoadSupported(const MachineType& machineType, 133 uint8_t alignment) const { 134 return IsUnalignedSupported(unalignedLoadSupportedTypes_, machineType, 135 alignment); 136 } 137 138 bool IsUnalignedStoreSupported(const MachineType& machineType, 139 uint8_t alignment) const { 140 return IsUnalignedSupported(unalignedStoreSupportedTypes_, machineType, 141 alignment); 142 } 143 144 static AlignmentRequirements FullUnalignedAccessSupport() { 145 return AlignmentRequirements(kFullSupport); 146 } 147 static AlignmentRequirements NoUnalignedAccessSupport() { 148 return AlignmentRequirements(kNoSupport); 149 } 150 static AlignmentRequirements SomeUnalignedAccessSupport( 151 const Vector<MachineType>& unalignedLoadSupportedTypes, 152 const Vector<MachineType>& unalignedStoreSupportedTypes) { 153 return AlignmentRequirements(kSomeSupport, unalignedLoadSupportedTypes, 154 unalignedStoreSupportedTypes); 155 } 156 157 private: 158 explicit AlignmentRequirements( 159 AlignmentRequirements::UnalignedAccessSupport unalignedAccessSupport, 160 Vector<MachineType> unalignedLoadSupportedTypes = 161 Vector<MachineType>(NULL, 0), 162 Vector<MachineType> unalignedStoreSupportedTypes = 163 Vector<MachineType>(NULL, 0)) 164 : unalignedSupport_(unalignedAccessSupport), 165 unalignedLoadSupportedTypes_(unalignedLoadSupportedTypes), 166 unalignedStoreSupportedTypes_(unalignedStoreSupportedTypes) {} 167 168 bool IsUnalignedSupported(const Vector<MachineType>& supported, 169 const MachineType& machineType, 170 uint8_t alignment) const { 171 if (unalignedSupport_ == kFullSupport) { 172 return true; 173 } else if (unalignedSupport_ == kNoSupport) { 174 return false; 175 } else { 176 for (MachineType m : supported) { 177 if (m == machineType) { 178 return true; 179 } 180 } 181 return false; 182 } 183 } 184 185 const AlignmentRequirements::UnalignedAccessSupport unalignedSupport_; 186 const Vector<MachineType> unalignedLoadSupportedTypes_; 187 const Vector<MachineType> unalignedStoreSupportedTypes_; 188 }; 189 190 explicit MachineOperatorBuilder( 191 Zone* zone, 192 MachineRepresentation word = MachineType::PointerRepresentation(), 193 Flags supportedOperators = kNoFlags, 194 AlignmentRequirements alignmentRequirements = 195 AlignmentRequirements::NoUnalignedAccessSupport()); 196 197 const Operator* Comment(const char* msg); 198 const Operator* DebugBreak(); 199 200 const Operator* Word32And(); 201 const Operator* Word32Or(); 202 const Operator* Word32Xor(); 203 const Operator* Word32Shl(); 204 const Operator* Word32Shr(); 205 const Operator* Word32Sar(); 206 const Operator* Word32Ror(); 207 const Operator* Word32Equal(); 208 const Operator* Word32Clz(); 209 const OptionalOperator Word32Ctz(); 210 const OptionalOperator Word32Popcnt(); 211 const OptionalOperator Word64Popcnt(); 212 const Operator* Word64PopcntPlaceholder(); 213 const OptionalOperator Word32ReverseBits(); 214 const OptionalOperator Word64ReverseBits(); 215 bool Word32ShiftIsSafe() const { return flags_ & kWord32ShiftIsSafe; } 216 217 const Operator* Word64And(); 218 const Operator* Word64Or(); 219 const Operator* Word64Xor(); 220 const Operator* Word64Shl(); 221 const Operator* Word64Shr(); 222 const Operator* Word64Sar(); 223 const Operator* Word64Ror(); 224 const Operator* Word64Clz(); 225 const OptionalOperator Word64Ctz(); 226 const Operator* Word64CtzPlaceholder(); 227 const Operator* Word64Equal(); 228 229 const Operator* Int32PairAdd(); 230 const Operator* Int32PairSub(); 231 const Operator* Int32PairMul(); 232 const Operator* Word32PairShl(); 233 const Operator* Word32PairShr(); 234 const Operator* Word32PairSar(); 235 236 const Operator* Int32Add(); 237 const Operator* Int32AddWithOverflow(); 238 const Operator* Int32Sub(); 239 const Operator* Int32SubWithOverflow(); 240 const Operator* Int32Mul(); 241 const Operator* Int32MulHigh(); 242 const Operator* Int32Div(); 243 const Operator* Int32Mod(); 244 const Operator* Int32LessThan(); 245 const Operator* Int32LessThanOrEqual(); 246 const Operator* Uint32Div(); 247 const Operator* Uint32LessThan(); 248 const Operator* Uint32LessThanOrEqual(); 249 const Operator* Uint32Mod(); 250 const Operator* Uint32MulHigh(); 251 bool Int32DivIsSafe() const { return flags_ & kInt32DivIsSafe; } 252 bool Uint32DivIsSafe() const { return flags_ & kUint32DivIsSafe; } 253 254 const Operator* Int64Add(); 255 const Operator* Int64AddWithOverflow(); 256 const Operator* Int64Sub(); 257 const Operator* Int64SubWithOverflow(); 258 const Operator* Int64Mul(); 259 const Operator* Int64Div(); 260 const Operator* Int64Mod(); 261 const Operator* Int64LessThan(); 262 const Operator* Int64LessThanOrEqual(); 263 const Operator* Uint64Div(); 264 const Operator* Uint64LessThan(); 265 const Operator* Uint64LessThanOrEqual(); 266 const Operator* Uint64Mod(); 267 268 // This operator reinterprets the bits of a word as tagged pointer. 269 const Operator* BitcastWordToTagged(); 270 271 // JavaScript float64 to int32/uint32 truncation. 272 const Operator* TruncateFloat64ToWord32(); 273 274 // These operators change the representation of numbers while preserving the 275 // value of the number. Narrowing operators assume the input is representable 276 // in the target type and are *not* defined for other inputs. 277 // Use narrowing change operators only when there is a static guarantee that 278 // the input value is representable in the target value. 279 const Operator* ChangeFloat32ToFloat64(); 280 const Operator* ChangeFloat64ToInt32(); // narrowing 281 const Operator* ChangeFloat64ToUint32(); // narrowing 282 const Operator* TruncateFloat64ToUint32(); 283 const Operator* TruncateFloat32ToInt32(); 284 const Operator* TruncateFloat32ToUint32(); 285 const Operator* TryTruncateFloat32ToInt64(); 286 const Operator* TryTruncateFloat64ToInt64(); 287 const Operator* TryTruncateFloat32ToUint64(); 288 const Operator* TryTruncateFloat64ToUint64(); 289 const Operator* ChangeInt32ToFloat64(); 290 const Operator* ChangeInt32ToInt64(); 291 const Operator* ChangeUint32ToFloat64(); 292 const Operator* ChangeUint32ToUint64(); 293 294 // These operators truncate or round numbers, both changing the representation 295 // of the number and mapping multiple input values onto the same output value. 296 const Operator* TruncateFloat64ToFloat32(); 297 const Operator* TruncateInt64ToInt32(); 298 const Operator* RoundFloat64ToInt32(); 299 const Operator* RoundInt32ToFloat32(); 300 const Operator* RoundInt64ToFloat32(); 301 const Operator* RoundInt64ToFloat64(); 302 const Operator* RoundUint32ToFloat32(); 303 const Operator* RoundUint64ToFloat32(); 304 const Operator* RoundUint64ToFloat64(); 305 306 // These operators reinterpret the bits of a floating point number as an 307 // integer and vice versa. 308 const Operator* BitcastFloat32ToInt32(); 309 const Operator* BitcastFloat64ToInt64(); 310 const Operator* BitcastInt32ToFloat32(); 311 const Operator* BitcastInt64ToFloat64(); 312 313 // Floating point operators always operate with IEEE 754 round-to-nearest 314 // (single-precision). 315 const Operator* Float32Add(); 316 const Operator* Float32Sub(); 317 const Operator* Float32SubPreserveNan(); 318 const Operator* Float32Mul(); 319 const Operator* Float32Div(); 320 const Operator* Float32Sqrt(); 321 322 // Floating point operators always operate with IEEE 754 round-to-nearest 323 // (double-precision). 324 const Operator* Float64Add(); 325 const Operator* Float64Sub(); 326 const Operator* Float64SubPreserveNan(); 327 const Operator* Float64Mul(); 328 const Operator* Float64Div(); 329 const Operator* Float64Mod(); 330 const Operator* Float64Sqrt(); 331 332 // Floating point comparisons complying to IEEE 754 (single-precision). 333 const Operator* Float32Equal(); 334 const Operator* Float32LessThan(); 335 const Operator* Float32LessThanOrEqual(); 336 337 // Floating point comparisons complying to IEEE 754 (double-precision). 338 const Operator* Float64Equal(); 339 const Operator* Float64LessThan(); 340 const Operator* Float64LessThanOrEqual(); 341 342 // Floating point min/max complying to IEEE 754 (single-precision). 343 const OptionalOperator Float32Max(); 344 const OptionalOperator Float32Min(); 345 346 // Floating point min/max complying to IEEE 754 (double-precision). 347 const OptionalOperator Float64Max(); 348 const OptionalOperator Float64Min(); 349 350 // Floating point abs complying to IEEE 754 (single-precision). 351 const Operator* Float32Abs(); 352 353 // Floating point abs complying to IEEE 754 (double-precision). 354 const Operator* Float64Abs(); 355 356 // Floating point rounding. 357 const OptionalOperator Float32RoundDown(); 358 const OptionalOperator Float64RoundDown(); 359 const OptionalOperator Float32RoundUp(); 360 const OptionalOperator Float64RoundUp(); 361 const OptionalOperator Float32RoundTruncate(); 362 const OptionalOperator Float64RoundTruncate(); 363 const OptionalOperator Float64RoundTiesAway(); 364 const OptionalOperator Float32RoundTiesEven(); 365 const OptionalOperator Float64RoundTiesEven(); 366 367 // Floating point neg. 368 const OptionalOperator Float32Neg(); 369 const OptionalOperator Float64Neg(); 370 371 // Floating point trigonometric functions (double-precision). 372 const Operator* Float64Atan(); 373 const Operator* Float64Atan2(); 374 const Operator* Float64Atanh(); 375 376 // Floating point trigonometric functions (double-precision). 377 const Operator* Float64Cos(); 378 const Operator* Float64Sin(); 379 const Operator* Float64Tan(); 380 381 // Floating point exponential functions (double-precision). 382 const Operator* Float64Exp(); 383 384 // Floating point logarithm (double-precision). 385 const Operator* Float64Log(); 386 const Operator* Float64Log1p(); 387 const Operator* Float64Log2(); 388 const Operator* Float64Log10(); 389 390 const Operator* Float64Cbrt(); 391 const Operator* Float64Expm1(); 392 393 // Floating point bit representation. 394 const Operator* Float64ExtractLowWord32(); 395 const Operator* Float64ExtractHighWord32(); 396 const Operator* Float64InsertLowWord32(); 397 const Operator* Float64InsertHighWord32(); 398 399 // Change signalling NaN to quiet NaN. 400 // Identity for any input that is not signalling NaN. 401 const Operator* Float64SilenceNaN(); 402 403 // SIMD operators. 404 const Operator* CreateFloat32x4(); 405 const Operator* Float32x4ExtractLane(); 406 const Operator* Float32x4ReplaceLane(); 407 const Operator* Float32x4Abs(); 408 const Operator* Float32x4Neg(); 409 const Operator* Float32x4Sqrt(); 410 const Operator* Float32x4RecipApprox(); 411 const Operator* Float32x4RecipSqrtApprox(); 412 const Operator* Float32x4Add(); 413 const Operator* Float32x4Sub(); 414 const Operator* Float32x4Mul(); 415 const Operator* Float32x4Div(); 416 const Operator* Float32x4Min(); 417 const Operator* Float32x4Max(); 418 const Operator* Float32x4MinNum(); 419 const Operator* Float32x4MaxNum(); 420 const Operator* Float32x4Equal(); 421 const Operator* Float32x4NotEqual(); 422 const Operator* Float32x4LessThan(); 423 const Operator* Float32x4LessThanOrEqual(); 424 const Operator* Float32x4GreaterThan(); 425 const Operator* Float32x4GreaterThanOrEqual(); 426 const Operator* Float32x4Select(); 427 const Operator* Float32x4Swizzle(); 428 const Operator* Float32x4Shuffle(); 429 const Operator* Float32x4FromInt32x4(); 430 const Operator* Float32x4FromUint32x4(); 431 432 const Operator* CreateInt32x4(); 433 const Operator* Int32x4ExtractLane(); 434 const Operator* Int32x4ReplaceLane(); 435 const Operator* Int32x4Neg(); 436 const Operator* Int32x4Add(); 437 const Operator* Int32x4Sub(); 438 const Operator* Int32x4Mul(); 439 const Operator* Int32x4Min(); 440 const Operator* Int32x4Max(); 441 const Operator* Int32x4ShiftLeftByScalar(); 442 const Operator* Int32x4ShiftRightByScalar(); 443 const Operator* Int32x4Equal(); 444 const Operator* Int32x4NotEqual(); 445 const Operator* Int32x4LessThan(); 446 const Operator* Int32x4LessThanOrEqual(); 447 const Operator* Int32x4GreaterThan(); 448 const Operator* Int32x4GreaterThanOrEqual(); 449 const Operator* Int32x4Select(); 450 const Operator* Int32x4Swizzle(); 451 const Operator* Int32x4Shuffle(); 452 const Operator* Int32x4FromFloat32x4(); 453 454 const Operator* Uint32x4Min(); 455 const Operator* Uint32x4Max(); 456 const Operator* Uint32x4ShiftLeftByScalar(); 457 const Operator* Uint32x4ShiftRightByScalar(); 458 const Operator* Uint32x4LessThan(); 459 const Operator* Uint32x4LessThanOrEqual(); 460 const Operator* Uint32x4GreaterThan(); 461 const Operator* Uint32x4GreaterThanOrEqual(); 462 const Operator* Uint32x4FromFloat32x4(); 463 464 const Operator* CreateBool32x4(); 465 const Operator* Bool32x4ExtractLane(); 466 const Operator* Bool32x4ReplaceLane(); 467 const Operator* Bool32x4And(); 468 const Operator* Bool32x4Or(); 469 const Operator* Bool32x4Xor(); 470 const Operator* Bool32x4Not(); 471 const Operator* Bool32x4AnyTrue(); 472 const Operator* Bool32x4AllTrue(); 473 const Operator* Bool32x4Swizzle(); 474 const Operator* Bool32x4Shuffle(); 475 const Operator* Bool32x4Equal(); 476 const Operator* Bool32x4NotEqual(); 477 478 const Operator* CreateInt16x8(); 479 const Operator* Int16x8ExtractLane(); 480 const Operator* Int16x8ReplaceLane(); 481 const Operator* Int16x8Neg(); 482 const Operator* Int16x8Add(); 483 const Operator* Int16x8AddSaturate(); 484 const Operator* Int16x8Sub(); 485 const Operator* Int16x8SubSaturate(); 486 const Operator* Int16x8Mul(); 487 const Operator* Int16x8Min(); 488 const Operator* Int16x8Max(); 489 const Operator* Int16x8ShiftLeftByScalar(); 490 const Operator* Int16x8ShiftRightByScalar(); 491 const Operator* Int16x8Equal(); 492 const Operator* Int16x8NotEqual(); 493 const Operator* Int16x8LessThan(); 494 const Operator* Int16x8LessThanOrEqual(); 495 const Operator* Int16x8GreaterThan(); 496 const Operator* Int16x8GreaterThanOrEqual(); 497 const Operator* Int16x8Select(); 498 const Operator* Int16x8Swizzle(); 499 const Operator* Int16x8Shuffle(); 500 501 const Operator* Uint16x8AddSaturate(); 502 const Operator* Uint16x8SubSaturate(); 503 const Operator* Uint16x8Min(); 504 const Operator* Uint16x8Max(); 505 const Operator* Uint16x8ShiftLeftByScalar(); 506 const Operator* Uint16x8ShiftRightByScalar(); 507 const Operator* Uint16x8LessThan(); 508 const Operator* Uint16x8LessThanOrEqual(); 509 const Operator* Uint16x8GreaterThan(); 510 const Operator* Uint16x8GreaterThanOrEqual(); 511 512 const Operator* CreateBool16x8(); 513 const Operator* Bool16x8ExtractLane(); 514 const Operator* Bool16x8ReplaceLane(); 515 const Operator* Bool16x8And(); 516 const Operator* Bool16x8Or(); 517 const Operator* Bool16x8Xor(); 518 const Operator* Bool16x8Not(); 519 const Operator* Bool16x8AnyTrue(); 520 const Operator* Bool16x8AllTrue(); 521 const Operator* Bool16x8Swizzle(); 522 const Operator* Bool16x8Shuffle(); 523 const Operator* Bool16x8Equal(); 524 const Operator* Bool16x8NotEqual(); 525 526 const Operator* CreateInt8x16(); 527 const Operator* Int8x16ExtractLane(); 528 const Operator* Int8x16ReplaceLane(); 529 const Operator* Int8x16Neg(); 530 const Operator* Int8x16Add(); 531 const Operator* Int8x16AddSaturate(); 532 const Operator* Int8x16Sub(); 533 const Operator* Int8x16SubSaturate(); 534 const Operator* Int8x16Mul(); 535 const Operator* Int8x16Min(); 536 const Operator* Int8x16Max(); 537 const Operator* Int8x16ShiftLeftByScalar(); 538 const Operator* Int8x16ShiftRightByScalar(); 539 const Operator* Int8x16Equal(); 540 const Operator* Int8x16NotEqual(); 541 const Operator* Int8x16LessThan(); 542 const Operator* Int8x16LessThanOrEqual(); 543 const Operator* Int8x16GreaterThan(); 544 const Operator* Int8x16GreaterThanOrEqual(); 545 const Operator* Int8x16Select(); 546 const Operator* Int8x16Swizzle(); 547 const Operator* Int8x16Shuffle(); 548 549 const Operator* Uint8x16AddSaturate(); 550 const Operator* Uint8x16SubSaturate(); 551 const Operator* Uint8x16Min(); 552 const Operator* Uint8x16Max(); 553 const Operator* Uint8x16ShiftLeftByScalar(); 554 const Operator* Uint8x16ShiftRightByScalar(); 555 const Operator* Uint8x16LessThan(); 556 const Operator* Uint8x16LessThanOrEqual(); 557 const Operator* Uint8x16GreaterThan(); 558 const Operator* Uint8x16GreaterThanOrEqual(); 559 560 const Operator* CreateBool8x16(); 561 const Operator* Bool8x16ExtractLane(); 562 const Operator* Bool8x16ReplaceLane(); 563 const Operator* Bool8x16And(); 564 const Operator* Bool8x16Or(); 565 const Operator* Bool8x16Xor(); 566 const Operator* Bool8x16Not(); 567 const Operator* Bool8x16AnyTrue(); 568 const Operator* Bool8x16AllTrue(); 569 const Operator* Bool8x16Swizzle(); 570 const Operator* Bool8x16Shuffle(); 571 const Operator* Bool8x16Equal(); 572 const Operator* Bool8x16NotEqual(); 573 574 const Operator* Simd128Load(); 575 const Operator* Simd128Load1(); 576 const Operator* Simd128Load2(); 577 const Operator* Simd128Load3(); 578 const Operator* Simd128Store(); 579 const Operator* Simd128Store1(); 580 const Operator* Simd128Store2(); 581 const Operator* Simd128Store3(); 582 const Operator* Simd128And(); 583 const Operator* Simd128Or(); 584 const Operator* Simd128Xor(); 585 const Operator* Simd128Not(); 586 587 // load [base + index] 588 const Operator* Load(LoadRepresentation rep); 589 590 // store [base + index], value 591 const Operator* Store(StoreRepresentation rep); 592 593 const Operator* StackSlot(MachineRepresentation rep); 594 595 // Access to the machine stack. 596 const Operator* LoadStackPointer(); 597 const Operator* LoadFramePointer(); 598 const Operator* LoadParentFramePointer(); 599 600 // checked-load heap, index, length 601 const Operator* CheckedLoad(CheckedLoadRepresentation); 602 // checked-store heap, index, length, value 603 const Operator* CheckedStore(CheckedStoreRepresentation); 604 605 // atomic-load [base + index] 606 const Operator* AtomicLoad(LoadRepresentation rep); 607 // atomic-store [base + index], value 608 const Operator* AtomicStore(MachineRepresentation rep); 609 610 // Target machine word-size assumed by this builder. 611 bool Is32() const { return word() == MachineRepresentation::kWord32; } 612 bool Is64() const { return word() == MachineRepresentation::kWord64; } 613 MachineRepresentation word() const { return word_; } 614 615 bool UnalignedLoadSupported(const MachineType& machineType, 616 uint8_t alignment) { 617 return alignment_requirements_.IsUnalignedLoadSupported(machineType, 618 alignment); 619 } 620 621 bool UnalignedStoreSupported(const MachineType& machineType, 622 uint8_t alignment) { 623 return alignment_requirements_.IsUnalignedStoreSupported(machineType, 624 alignment); 625 } 626 627 // Pseudo operators that translate to 32/64-bit operators depending on the 628 // word-size of the target machine assumed by this builder. 629 #define PSEUDO_OP_LIST(V) \ 630 V(Word, And) \ 631 V(Word, Or) \ 632 V(Word, Xor) \ 633 V(Word, Shl) \ 634 V(Word, Shr) \ 635 V(Word, Sar) \ 636 V(Word, Ror) \ 637 V(Word, Clz) \ 638 V(Word, Equal) \ 639 V(Int, Add) \ 640 V(Int, Sub) \ 641 V(Int, Mul) \ 642 V(Int, Div) \ 643 V(Int, Mod) \ 644 V(Int, LessThan) \ 645 V(Int, LessThanOrEqual) \ 646 V(Uint, Div) \ 647 V(Uint, LessThan) \ 648 V(Uint, Mod) 649 #define PSEUDO_OP(Prefix, Suffix) \ 650 const Operator* Prefix##Suffix() { \ 651 return Is32() ? Prefix##32##Suffix() : Prefix##64##Suffix(); \ 652 } 653 PSEUDO_OP_LIST(PSEUDO_OP) 654 #undef PSEUDO_OP 655 #undef PSEUDO_OP_LIST 656 657 private: 658 Zone* zone_; 659 MachineOperatorGlobalCache const& cache_; 660 MachineRepresentation const word_; 661 Flags const flags_; 662 AlignmentRequirements const alignment_requirements_; 663 664 DISALLOW_COPY_AND_ASSIGN(MachineOperatorBuilder); 665 }; 666 667 668 DEFINE_OPERATORS_FOR_FLAGS(MachineOperatorBuilder::Flags) 669 670 } // namespace compiler 671 } // namespace internal 672 } // namespace v8 673 674 #endif // V8_COMPILER_MACHINE_OPERATOR_H_ 675