V8 Project
Classes | Typedefs | Functions | Variables
v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc} Namespace Reference

Classes

struct  MachInst
 
struct  FPCmp
 
struct  Conversion
 
struct  MulDPInst
 
struct  MemoryAccess
 

Typedefs

typedef RawMachineAssembler::Label MLabel
 
typedef MachInst< Node *(RawMachineAssembler::*)(Node *)> MachInst1
 
typedef MachInst< Node *(RawMachineAssembler::*)(Node *, Node *)> MachInst2
 

Functions

template<typename T >
std::ostream & operator<< (std::ostream &os, const MachInst< T > &mi)
 
Node * BuildConstant (InstructionSelectorTest::StreamBuilder &m, MachineType type, int64_t value)
 
std::ostream & operator<< (std::ostream &os, const FPCmp &cmp)
 
std::ostream & operator<< (std::ostream &os, const Conversion &conv)
 
std::ostream & operator<< (std::ostream &os, const MulDPInst &inst)
 
std::ostream & operator<< (std::ostream &os, const MemoryAccess &memacc)
 

Variables

static const MachInst2 kLogicalInstructions []
 
static const uint32_t kLogicalImmediates []
 
static const MachInst2 kAddSubInstructions []
 
static const int32_t kAddSubImmediates []
 
static const MachInst2 kDPFlagSetInstructions []
 
static const MachInst2 kOvfAddSubInstructions []
 
static const MachInst2 kShiftInstructions []
 
static const MachInst2 kMulDivInstructions []
 
static const MachInst2 kFPArithInstructions []
 
static const FPCmp kFPCmpInstructions []
 
static const Conversion kConversionInstructions []
 

Typedef Documentation

◆ MachInst1

typedef MachInst<Node* (RawMachineAssembler::*)(Node*)> v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::MachInst1

Definition at line 25 of file instruction-selector-arm64-unittest.cc.

◆ MachInst2

typedef MachInst<Node* (RawMachineAssembler::*)(Node*, Node*)> v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::MachInst2

Definition at line 26 of file instruction-selector-arm64-unittest.cc.

◆ MLabel

typedef RawMachineAssembler::Label v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::MLabel

Definition at line 15 of file instruction-selector-arm64-unittest.cc.

Function Documentation

◆ BuildConstant()

Node* v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::BuildConstant ( InstructionSelectorTest::StreamBuilder &  m,
MachineType  type,
int64_t  value 
)

Definition at line 37 of file instruction-selector-arm64-unittest.cc.

38  {
39  switch (type) {
40  case kMachInt32:
41  return m.Int32Constant(value);
42  break;
43 
44  case kMachInt64:
45  return m.Int64Constant(value);
46  break;
47 
48  default:
49  UNIMPLEMENTED();
50  }
51  return NULL;
52 }
NULL
enable harmony numeric enable harmony object literal extensions Optimize object Array DOM strings and string trace pretenuring decisions of HAllocate instructions Enables optimizations which favor memory size over execution speed maximum source size in bytes considered for a single inlining maximum cumulative number of AST nodes considered for inlining trace the tracking of allocation sites deoptimize every n garbage collections perform array bounds checks elimination analyze liveness of environment slots and zap dead values flushes the cache of optimized code for closures on every GC allow uint32 values on optimize frames if they are used only in safe operations track concurrent recompilation artificial compilation delay in ms do not emit check maps for constant values that have a leaf deoptimize the optimized code if the layout of the maps changes enable context specialization in TurboFan execution budget before interrupt is triggered max percentage of megamorphic generic ICs to allow optimization enable use of SAHF instruction if enable use of VFP3 instructions if available enable use of NEON instructions if enable use of SDIV and UDIV instructions if enable use of MLS instructions if enable loading bit constant by means of movw movt instruction enable unaligned accesses for enable use of d16 d31 registers on ARM this requires VFP3 force all emitted branches to be in long enable alignment of csp to bytes on platforms which prefer the register to always be NULL
Definition: flag-definitions.h:407
UNIMPLEMENTED
#define UNIMPLEMENTED()
Definition: logging.h:28

References v8::internal::compiler::kMachInt32, v8::internal::compiler::kMachInt64, NULL, and UNIMPLEMENTED.

Referenced by v8::internal::compiler::TEST_P().

+ Here is the caller graph for this function:

◆ operator<<() [1/5]

std::ostream& v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::operator<< ( std::ostream &  os,
const Conversion &  conv 
)

Definition at line 193 of file instruction-selector-arm64-unittest.cc.

193  {
194  return os << conv.mi;
195 }

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::Conversion::mi.

◆ operator<<() [2/5]

std::ostream& v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::operator<< ( std::ostream &  os,
const FPCmp &  cmp 
)

Definition at line 168 of file instruction-selector-arm64-unittest.cc.

168  {
169  return os << cmp.mi;
170 }

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::FPCmp::mi.

◆ operator<<() [3/5]

template<typename T >
std::ostream& v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::operator<< ( std::ostream &  os,
const MachInst< T > &  mi 
)

Definition at line 30 of file instruction-selector-arm64-unittest.cc.

30  {
31  return os << mi.constructor_name;
32 }

References v8::internal::mi.

◆ operator<<() [4/5]

std::ostream& v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::operator<< ( std::ostream &  os,
const MemoryAccess &  memacc 
)

Definition at line 998 of file instruction-selector-arm64-unittest.cc.

998  {
999  OStringStream ost;
1000  ost << memacc.type;
1001  return os << ost.c_str();
1002 }

References v8::internal::OStringStream::c_str(), and v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::MemoryAccess::type.

+ Here is the call graph for this function:

◆ operator<<() [5/5]

std::ostream& v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::operator<< ( std::ostream &  os,
const MulDPInst &  inst 
)

Definition at line 821 of file instruction-selector-arm64-unittest.cc.

821  {
822  return os << inst.mul_constructor_name;
823 }

References v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::MulDPInst::mul_constructor_name.

Variable Documentation

◆ kAddSubImmediates

const int32_t v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubImmediates[]
static
Initial value:
= {
0, 1, 69, 493, 599, 701, 719,
768, 818, 842, 945, 1246, 1286, 1429,
1669, 2171, 2179, 2182, 2254, 2334, 2338,
2343, 2396, 2449, 2610, 2732, 2855, 2876,
2944, 3377, 3458, 3475, 3476, 3540, 3574,
3601, 3813, 3871, 3917, 4095, 4096, 16384,
364544, 462848, 970752, 1523712, 1863680, 2363392, 3219456,
3280896, 4247552, 4526080, 4575232, 4960256, 5505024, 5894144,
6004736, 6193152, 6385664, 6795264, 7114752, 7233536, 7348224,
7499776, 7573504, 7729152, 8634368, 8937472, 9465856, 10354688,
10682368, 11059200, 11460608, 13168640, 13176832, 14336000, 15028224,
15597568, 15892480, 16773120}

Definition at line 98 of file instruction-selector-arm64-unittest.cc.

Referenced by v8::internal::compiler::TEST_F(), and v8::internal::compiler::TEST_P().

◆ kAddSubInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kAddSubInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Int32Add, "Int32Add", kArm64Add32, kMachInt32},
{&RawMachineAssembler::Int64Add, "Int64Add", kArm64Add, kMachInt64},
{&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Sub32, kMachInt32},
{&RawMachineAssembler::Int64Sub, "Int64Sub", kArm64Sub, kMachInt64}}

Definition at line 89 of file instruction-selector-arm64-unittest.cc.

◆ kConversionInstructions

const Conversion v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kConversionInstructions[]
static
Initial value:
= {
{{&RawMachineAssembler::ChangeFloat32ToFloat64, "ChangeFloat32ToFloat64",
kArm64Float32ToFloat64, kMachFloat64},
kMachFloat32},
{{&RawMachineAssembler::TruncateFloat64ToFloat32,
"TruncateFloat64ToFloat32", kArm64Float64ToFloat32, kMachFloat32},
kMachFloat64},
{{&RawMachineAssembler::ChangeInt32ToInt64, "ChangeInt32ToInt64",
kArm64Sxtw, kMachInt64},
kMachInt32},
{{&RawMachineAssembler::ChangeUint32ToUint64, "ChangeUint32ToUint64",
kArm64Mov32, kMachUint64},
kMachUint32},
{{&RawMachineAssembler::TruncateInt64ToInt32, "TruncateInt64ToInt32",
kArm64Mov32, kMachInt32},
kMachInt64},
{{&RawMachineAssembler::ChangeInt32ToFloat64, "ChangeInt32ToFloat64",
kArm64Int32ToFloat64, kMachFloat64},
kMachInt32},
{{&RawMachineAssembler::ChangeUint32ToFloat64, "ChangeUint32ToFloat64",
kArm64Uint32ToFloat64, kMachFloat64},
kMachUint32},
{{&RawMachineAssembler::ChangeFloat64ToInt32, "ChangeFloat64ToInt32",
kArm64Float64ToInt32, kMachInt32},
kMachFloat64},
{{&RawMachineAssembler::ChangeFloat64ToUint32, "ChangeFloat64ToUint32",
kArm64Float64ToUint32, kMachUint32},
kMachFloat64}}

Definition at line 199 of file instruction-selector-arm64-unittest.cc.

◆ kDPFlagSetInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kDPFlagSetInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Word32And, "Word32And", kArm64Tst32, kMachInt32},
{&RawMachineAssembler::Int32Add, "Int32Add", kArm64Cmn32, kMachInt32},
{&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Cmp32, kMachInt32}}

Definition at line 114 of file instruction-selector-arm64-unittest.cc.

◆ kFPArithInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kFPArithInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Float64Add, "Float64Add", kArm64Float64Add,
kMachFloat64},
{&RawMachineAssembler::Float64Sub, "Float64Sub", kArm64Float64Sub,
kMachFloat64},
{&RawMachineAssembler::Float64Mul, "Float64Mul", kArm64Float64Mul,
kMachFloat64},
{&RawMachineAssembler::Float64Div, "Float64Div", kArm64Float64Div,
kMachFloat64}}

Definition at line 151 of file instruction-selector-arm64-unittest.cc.

◆ kFPCmpInstructions

const FPCmp v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kFPCmpInstructions[]
static
Initial value:
= {
{{&RawMachineAssembler::Float64Equal, "Float64Equal", kArm64Float64Cmp,
kMachFloat64},
kUnorderedEqual},
{{&RawMachineAssembler::Float64LessThan, "Float64LessThan",
kArm64Float64Cmp, kMachFloat64},
kUnorderedLessThan},
{{&RawMachineAssembler::Float64LessThanOrEqual, "Float64LessThanOrEqual",
kArm64Float64Cmp, kMachFloat64},
kUnorderedLessThanOrEqual}}

Definition at line 174 of file instruction-selector-arm64-unittest.cc.

◆ kLogicalImmediates

const uint32_t v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kLogicalImmediates[]
static
Initial value:
= {
0x00000002, 0x00000003, 0x00000070, 0x00000080, 0x00000100, 0x000001c0,
0x00000300, 0x000007e0, 0x00003ffc, 0x00007fc0, 0x0003c000, 0x0003f000,
0x0003ffc0, 0x0003fff8, 0x0007ff00, 0x0007ffe0, 0x000e0000, 0x001e0000,
0x001ffffc, 0x003f0000, 0x003f8000, 0x00780000, 0x007fc000, 0x00ff0000,
0x01800000, 0x01800180, 0x01f801f8, 0x03fe0000, 0x03ffffc0, 0x03fffffc,
0x06000000, 0x07fc0000, 0x07ffc000, 0x07ffffc0, 0x07ffffe0, 0x0ffe0ffe,
0x0ffff800, 0x0ffffff0, 0x0fffffff, 0x18001800, 0x1f001f00, 0x1f801f80,
0x30303030, 0x3ff03ff0, 0x3ff83ff8, 0x3fff0000, 0x3fff8000, 0x3fffffc0,
0x70007000, 0x7f7f7f7f, 0x7fc00000, 0x7fffffc0, 0x8000001f, 0x800001ff,
0x81818181, 0x9fff9fff, 0xc00007ff, 0xc0ffffff, 0xdddddddd, 0xe00001ff,
0xe00003ff, 0xe007ffff, 0xefffefff, 0xf000003f, 0xf001f001, 0xf3fff3ff,
0xf800001f, 0xf80fffff, 0xf87ff87f, 0xfbfbfbfb, 0xfc00001f, 0xfc0000ff,
0xfc0001ff, 0xfc03fc03, 0xfe0001ff, 0xff000001, 0xff03ff03, 0xff800000,
0xff800fff, 0xff801fff, 0xff87ffff, 0xffc0003f, 0xffc007ff, 0xffcfffcf,
0xffe00003, 0xffe1ffff, 0xfff0001f, 0xfff07fff, 0xfff80007, 0xfff87fff,
0xfffc00ff, 0xfffe07ff, 0xffff00ff, 0xffffc001, 0xfffff007, 0xfffff3ff,
0xfffff807, 0xfffff9ff, 0xfffffc0f, 0xfffffeff}

Definition at line 68 of file instruction-selector-arm64-unittest.cc.

Referenced by v8::internal::compiler::TEST_F(), and v8::internal::compiler::TEST_P().

◆ kLogicalInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kLogicalInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Word32And, "Word32And", kArm64And32, kMachInt32},
{&RawMachineAssembler::Word64And, "Word64And", kArm64And, kMachInt64},
{&RawMachineAssembler::Word32Or, "Word32Or", kArm64Or32, kMachInt32},
{&RawMachineAssembler::Word64Or, "Word64Or", kArm64Or, kMachInt64},
{&RawMachineAssembler::Word32Xor, "Word32Xor", kArm64Eor32, kMachInt32},
{&RawMachineAssembler::Word64Xor, "Word64Xor", kArm64Eor, kMachInt64}}

Definition at line 56 of file instruction-selector-arm64-unittest.cc.

◆ kMulDivInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kMulDivInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Int32Mul, "Int32Mul", kArm64Mul32, kMachInt32},
{&RawMachineAssembler::Int64Mul, "Int64Mul", kArm64Mul, kMachInt64},
{&RawMachineAssembler::Int32Div, "Int32Div", kArm64Idiv32, kMachInt32},
{&RawMachineAssembler::Int64Div, "Int64Div", kArm64Idiv, kMachInt64},
{&RawMachineAssembler::Int32UDiv, "Int32UDiv", kArm64Udiv32, kMachInt32},
{&RawMachineAssembler::Int64UDiv, "Int64UDiv", kArm64Udiv, kMachInt64}}

Definition at line 141 of file instruction-selector-arm64-unittest.cc.

◆ kOvfAddSubInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kOvfAddSubInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Int32AddWithOverflow, "Int32AddWithOverflow",
kArm64Add32, kMachInt32},
{&RawMachineAssembler::Int32SubWithOverflow, "Int32SubWithOverflow",
kArm64Sub32, kMachInt32}}

Definition at line 121 of file instruction-selector-arm64-unittest.cc.

◆ kShiftInstructions

const MachInst2 v8::internal::compiler::anonymous_namespace{instruction-selector-arm64-unittest.cc}::kShiftInstructions[]
static
Initial value:
= {
{&RawMachineAssembler::Word32Shl, "Word32Shl", kArm64Shl32, kMachInt32},
{&RawMachineAssembler::Word64Shl, "Word64Shl", kArm64Shl, kMachInt64},
{&RawMachineAssembler::Word32Shr, "Word32Shr", kArm64Shr32, kMachInt32},
{&RawMachineAssembler::Word64Shr, "Word64Shr", kArm64Shr, kMachInt64},
{&RawMachineAssembler::Word32Sar, "Word32Sar", kArm64Sar32, kMachInt32},
{&RawMachineAssembler::Word64Sar, "Word64Sar", kArm64Sar, kMachInt64},
{&RawMachineAssembler::Word32Ror, "Word32Ror", kArm64Ror32, kMachInt32},
{&RawMachineAssembler::Word64Ror, "Word64Ror", kArm64Ror, kMachInt64}}

Definition at line 129 of file instruction-selector-arm64-unittest.cc.