v8::internal::compiler::OperandGenerator Class Reference

#include <instruction-selector-impl.h>

Inheritance diagram for v8::internal::compiler::OperandGenerator:

Collaboration diagram for v8::internal::compiler::OperandGenerator:

Public Member Functions
	OperandGenerator (InstructionSelector *selector)
InstructionOperand *	DefineAsRegister (Node *node)
InstructionOperand *	DefineSameAsFirst (Node *result)
InstructionOperand *	DefineAsFixed (Node *node, Register reg)
InstructionOperand *	DefineAsFixed (Node *node, DoubleRegister reg)
InstructionOperand *	DefineAsConstant (Node *node)
InstructionOperand *	DefineAsLocation (Node *node, LinkageLocation location, MachineType type)
InstructionOperand *	Use (Node *node)
InstructionOperand *	UseRegister (Node *node)
InstructionOperand *	UseUnique (Node *node)
InstructionOperand *	UseUniqueRegister (Node *node)
InstructionOperand *	UseFixed (Node *node, Register reg)
InstructionOperand *	UseFixed (Node *node, DoubleRegister reg)
InstructionOperand *	UseImmediate (Node *node)
InstructionOperand *	UseLocation (Node *node, LinkageLocation location, MachineType type)
InstructionOperand *	TempRegister ()
InstructionOperand *	TempDoubleRegister ()
InstructionOperand *	TempRegister (Register reg)
InstructionOperand *	TempImmediate (int32_t imm)
InstructionOperand *	Label (BasicBlock *block)

Protected Member Functions
Graph *	graph () const
InstructionSelector *	selector () const
InstructionSequence *	sequence () const
Isolate *	isolate () const
Zone *	zone () const

Private Member Functions
UnallocatedOperand *	Define (Node *node, UnallocatedOperand *operand)
UnallocatedOperand *	Use (Node *node, UnallocatedOperand *operand)
UnallocatedOperand *	ToUnallocatedOperand (LinkageLocation location, MachineType type)

Static Private Member Functions
static Constant	ToConstant (const Node *node)

Private Attributes
InstructionSelector *	selector_

Detailed Description

Definition at line 18 of file instruction-selector-impl.h.

Constructor & Destructor Documentation

OperandGenerator()

v8::internal::compiler::OperandGenerator::OperandGenerator ( InstructionSelector *  selector )

inlineexplicit

Definition at line 20 of file instruction-selector-impl.h.

      : selector_(selector) {}

Member Function Documentation

Define()

UnallocatedOperand* v8::internal::compiler::OperandGenerator::Define ( Node *  node, UnallocatedOperand *  operand  )

inlineprivate

Definition at line 165 of file instruction-selector-impl.h.

                                                                      {
    DCHECK_NOT_NULL(node);
    DCHECK_NOT_NULL(operand);
    operand->set_virtual_register(node->id());
    selector()->MarkAsDefined(node);
    return operand;
  }

References DCHECK_NOT_NULL, selector(), and v8::internal::compiler::UnallocatedOperand::set_virtual_register().

Referenced by DefineAsFixed(), DefineAsLocation(), DefineAsRegister(), and DefineSameAsFirst().

Here is the call graph for this function:

Here is the caller graph for this function:

DefineAsConstant()

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineAsConstant ( Node *  node )

inline

Definition at line 45 of file instruction-selector-impl.h.

                                                   {
    selector()->MarkAsDefined(node);
    sequence()->AddConstant(node->id(), ToConstant(node));
    return ConstantOperand::Create(node->id(), zone());
  }

References selector(), sequence(), ToConstant(), and zone().

Here is the call graph for this function:

DefineAsFixed() [1/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineAsFixed ( Node *  node, DoubleRegister  reg  )

inline

Definition at line 39 of file instruction-selector-impl.h.

                                                                    {
    return Define(node, new (zone())
                  UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                     DoubleRegister::ToAllocationIndex(reg)));
  }

References Define(), v8::internal::compiler::UnallocatedOperand::FIXED_DOUBLE_REGISTER, v8::internal::DwVfpRegister::ToAllocationIndex(), and zone().

Here is the call graph for this function:

DefineAsFixed() [2/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineAsFixed ( Node *  node, Register  reg  )

inline

Definition at line 33 of file instruction-selector-impl.h.

                                                              {
    return Define(node, new (zone())
                  UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                     Register::ToAllocationIndex(reg)));
  }

References Define(), v8::internal::compiler::UnallocatedOperand::FIXED_REGISTER, v8::internal::Register::ToAllocationIndex(), and zone().

Here is the call graph for this function:

DefineAsLocation()

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineAsLocation ( Node *  node, LinkageLocation  location, MachineType  type  )

inline

Definition at line 51 of file instruction-selector-impl.h.

                                                         {
    return Define(node, ToUnallocatedOperand(location, type));
  }

References Define(), and ToUnallocatedOperand().

Here is the call graph for this function:

DefineAsRegister()

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineAsRegister ( Node *  node )

inline

Definition at line 23 of file instruction-selector-impl.h.

                                                   {
    return Define(node, new (zone())
                  UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
  }

References Define(), v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, and zone().

Referenced by v8::internal::compiler::EmitBic(), v8::internal::compiler::VisitBinop(), v8::internal::compiler::VisitDiv(), v8::internal::compiler::VisitMod(), v8::internal::compiler::VisitRRRFloat64(), v8::internal::compiler::VisitShift(), and v8::internal::compiler::VisitWordCompare().

Here is the call graph for this function:

Here is the caller graph for this function:

DefineSameAsFirst()

InstructionOperand* v8::internal::compiler::OperandGenerator::DefineSameAsFirst ( Node *  result )

inline

Definition at line 28 of file instruction-selector-impl.h.

                                                      {
    return Define(result, new (zone())
                  UnallocatedOperand(UnallocatedOperand::SAME_AS_FIRST_INPUT));
  }

References Define(), v8::internal::compiler::UnallocatedOperand::SAME_AS_FIRST_INPUT, and zone().

Here is the call graph for this function:

graph()

Graph* v8::internal::compiler::OperandGenerator::graph ( ) const

inlineprotected

Definition at line 136 of file instruction-selector-impl.h.

{ return selector()->graph(); }

References selector().

Here is the call graph for this function:

isolate()

Isolate* v8::internal::compiler::OperandGenerator::isolate ( ) const

inlineprotected

Definition at line 139 of file instruction-selector-impl.h.

{ return zone()->isolate(); }

References v8::internal::Zone::isolate(), and zone().

Here is the call graph for this function:

Label()

InstructionOperand* v8::internal::compiler::OperandGenerator::Label ( BasicBlock *  block )

inline

Definition at line 130 of file instruction-selector-impl.h.

                                               {
    // TODO(bmeurer): We misuse ImmediateOperand here.
    return TempImmediate(block->id());
  }

References TempImmediate().

Referenced by v8::internal::compiler::VisitBinop(), v8::internal::compiler::VisitShift(), and v8::internal::compiler::VisitWordCompare().

Here is the call graph for this function:

Here is the caller graph for this function:

selector()

InstructionSelector* v8::internal::compiler::OperandGenerator::selector ( ) const

inlineprotected

Definition at line 137 of file instruction-selector-impl.h.

{ return selector_; }

References selector_.

Referenced by Define(), DefineAsConstant(), graph(), sequence(), Use(), and zone().

Here is the caller graph for this function:

sequence()

InstructionSequence* v8::internal::compiler::OperandGenerator::sequence ( ) const

inlineprotected

Definition at line 138 of file instruction-selector-impl.h.

{ return selector()->sequence(); }

References selector().

Referenced by DefineAsConstant(), TempDoubleRegister(), TempImmediate(), TempRegister(), and UseImmediate().

Here is the call graph for this function:

Here is the caller graph for this function:

TempDoubleRegister()

InstructionOperand* v8::internal::compiler::OperandGenerator::TempDoubleRegister ( )

inline

Definition at line 111 of file instruction-selector-impl.h.

                                           {
    UnallocatedOperand* op =
        new (zone()) UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                                        UnallocatedOperand::USED_AT_START);
    op->set_virtual_register(sequence()->NextVirtualRegister());
    sequence()->MarkAsDouble(op->virtual_register());
    return op;
  }

References v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, sequence(), v8::internal::compiler::UnallocatedOperand::set_virtual_register(), v8::internal::compiler::UnallocatedOperand::USED_AT_START, v8::internal::compiler::UnallocatedOperand::virtual_register(), and zone().

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

Here is the call graph for this function:

Here is the caller graph for this function:

TempImmediate()

InstructionOperand* v8::internal::compiler::OperandGenerator::TempImmediate ( int32_t  imm )

inline

Definition at line 125 of file instruction-selector-impl.h.

                                                 {
    int index = sequence()->AddImmediate(Constant(imm));
    return ImmediateOperand::Create(index, zone());
  }

References sequence(), and zone().

Referenced by Label().

Here is the call graph for this function:

Here is the caller graph for this function:

TempRegister() [1/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::TempRegister ( )

inline

Definition at line 103 of file instruction-selector-impl.h.

                                     {
    UnallocatedOperand* op =
        new (zone()) UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                                        UnallocatedOperand::USED_AT_START);
    op->set_virtual_register(sequence()->NextVirtualRegister());
    return op;
  }

References v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, sequence(), v8::internal::compiler::UnallocatedOperand::set_virtual_register(), v8::internal::compiler::UnallocatedOperand::USED_AT_START, and zone().

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

Here is the call graph for this function:

Here is the caller graph for this function:

TempRegister() [2/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::TempRegister ( Register  reg )

inline

Definition at line 120 of file instruction-selector-impl.h.

                                                 {
    return new (zone()) UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                           Register::ToAllocationIndex(reg));
  }

References v8::internal::compiler::UnallocatedOperand::FIXED_REGISTER, v8::internal::Register::ToAllocationIndex(), and zone().

Here is the call graph for this function:

ToConstant()

static Constant v8::internal::compiler::OperandGenerator::ToConstant ( const Node *  node )

inlinestaticprivate

Definition at line 143 of file instruction-selector-impl.h.

                                               {
    switch (node->opcode()) {
      case IrOpcode::kInt32Constant:
        return Constant(OpParameter<int32_t>(node));
      case IrOpcode::kInt64Constant:
        return Constant(OpParameter<int64_t>(node));
      case IrOpcode::kFloat32Constant:
        return Constant(OpParameter<float>(node));
      case IrOpcode::kFloat64Constant:
      case IrOpcode::kNumberConstant:
        return Constant(OpParameter<double>(node));
      case IrOpcode::kExternalConstant:
        return Constant(OpParameter<ExternalReference>(node));
      case IrOpcode::kHeapConstant:
        return Constant(OpParameter<Unique<HeapObject> >(node).handle());
      default:
        break;
    }
    UNREACHABLE();
    return Constant(static_cast<int32_t>(0));
  }

References v8::internal::handle(), v8::internal::compiler::OpParameter(), and UNREACHABLE.

Referenced by DefineAsConstant(), and UseImmediate().

Here is the call graph for this function:

Here is the caller graph for this function:

ToUnallocatedOperand()

UnallocatedOperand* v8::internal::compiler::OperandGenerator::ToUnallocatedOperand ( LinkageLocation  location, MachineType  type  )

inlineprivate

Definition at line 181 of file instruction-selector-impl.h.

                                                             {
    if (location.location_ == LinkageLocation::ANY_REGISTER) {
      return new (zone())
          UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER);
    }
    if (location.location_ < 0) {
      return new (zone()) UnallocatedOperand(UnallocatedOperand::FIXED_SLOT,
                                             location.location_);
    }
    if (RepresentationOf(type) == kRepFloat64) {
      return new (zone()) UnallocatedOperand(
          UnallocatedOperand::FIXED_DOUBLE_REGISTER, location.location_);
    }
    return new (zone()) UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                           location.location_);
  }

References v8::internal::compiler::LinkageLocation::ANY_REGISTER, v8::internal::compiler::UnallocatedOperand::FIXED_DOUBLE_REGISTER, v8::internal::compiler::UnallocatedOperand::FIXED_REGISTER, v8::internal::compiler::UnallocatedOperand::FIXED_SLOT, v8::internal::compiler::kRepFloat64, v8::internal::compiler::LinkageLocation::location_, v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, v8::internal::compiler::RepresentationOf(), and zone().

Referenced by DefineAsLocation(), and UseLocation().

Here is the call graph for this function:

Here is the caller graph for this function:

Use() [1/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::Use ( Node *  node )

inline

Definition at line 56 of file instruction-selector-impl.h.

                                      {
    return Use(node,
               new (zone()) UnallocatedOperand(
                   UnallocatedOperand::ANY, UnallocatedOperand::USED_AT_START));
  }

References v8::internal::compiler::UnallocatedOperand::ANY, v8::internal::compiler::UnallocatedOperand::USED_AT_START, and zone().

Referenced by UseFixed(), UseLocation(), UseRegister(), UseUnique(), and UseUniqueRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

Use() [2/2]

UnallocatedOperand* v8::internal::compiler::OperandGenerator::Use ( Node *  node, UnallocatedOperand *  operand  )

inlineprivate

Definition at line 173 of file instruction-selector-impl.h.

                                                                   {
    DCHECK_NOT_NULL(node);
    DCHECK_NOT_NULL(operand);
    operand->set_virtual_register(node->id());
    selector()->MarkAsUsed(node);
    return operand;
  }

References DCHECK_NOT_NULL, selector(), and v8::internal::compiler::UnallocatedOperand::set_virtual_register().

Here is the call graph for this function:

UseFixed() [1/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::UseFixed ( Node *  node, DoubleRegister  reg  )

inline

Definition at line 87 of file instruction-selector-impl.h.

                                                               {
    return Use(node, new (zone())
               UnallocatedOperand(UnallocatedOperand::FIXED_DOUBLE_REGISTER,
                                  DoubleRegister::ToAllocationIndex(reg)));
  }

References v8::internal::compiler::UnallocatedOperand::FIXED_DOUBLE_REGISTER, v8::internal::DwVfpRegister::ToAllocationIndex(), Use(), and zone().

Here is the call graph for this function:

UseFixed() [2/2]

InstructionOperand* v8::internal::compiler::OperandGenerator::UseFixed ( Node *  node, Register  reg  )

inline

Definition at line 81 of file instruction-selector-impl.h.

                                                         {
    return Use(node, new (zone())
               UnallocatedOperand(UnallocatedOperand::FIXED_REGISTER,
                                  Register::ToAllocationIndex(reg)));
  }

References v8::internal::compiler::UnallocatedOperand::FIXED_REGISTER, v8::internal::Register::ToAllocationIndex(), Use(), and zone().

Here is the call graph for this function:

UseImmediate()

InstructionOperand* v8::internal::compiler::OperandGenerator::UseImmediate ( Node *  node )

inline

Definition at line 93 of file instruction-selector-impl.h.

                                               {
    int index = sequence()->AddImmediate(ToConstant(node));
    return ImmediateOperand::Create(index, zone());
  }

References sequence(), ToConstant(), and zone().

Referenced by v8::internal::compiler::TryMatchASR(), v8::internal::compiler::TryMatchImmediateOrShift(), v8::internal::compiler::TryMatchLSL(), v8::internal::compiler::TryMatchLSR(), v8::internal::compiler::TryMatchROR(), v8::internal::compiler::ArmOperandGenerator::UseOperand(), and v8::internal::compiler::UseOrImmediate().

Here is the call graph for this function:

Here is the caller graph for this function:

UseLocation()

InstructionOperand* v8::internal::compiler::OperandGenerator::UseLocation ( Node *  node, LinkageLocation  location, MachineType  type  )

inline

Definition at line 98 of file instruction-selector-impl.h.

                                                    {
    return Use(node, ToUnallocatedOperand(location, type));
  }

References ToUnallocatedOperand(), and Use().

Here is the call graph for this function:

UseRegister()

InstructionOperand* v8::internal::compiler::OperandGenerator::UseRegister ( Node *  node )

inline

Definition at line 62 of file instruction-selector-impl.h.

                                              {
    return Use(node, new (zone())
               UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER,
                                  UnallocatedOperand::USED_AT_START));
  }

References v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, Use(), v8::internal::compiler::UnallocatedOperand::USED_AT_START, and zone().

Referenced by v8::internal::compiler::EmitBic(), v8::internal::compiler::TryMatchASR(), v8::internal::compiler::TryMatchLSL(), v8::internal::compiler::TryMatchLSR(), v8::internal::compiler::TryMatchROR(), v8::internal::compiler::ArmOperandGenerator::UseOperand(), v8::internal::compiler::VisitBinop(), v8::internal::compiler::VisitDiv(), v8::internal::compiler::VisitMod(), v8::internal::compiler::VisitRRRFloat64(), and v8::internal::compiler::VisitWordCompare().

Here is the call graph for this function:

Here is the caller graph for this function:

UseUnique()

InstructionOperand* v8::internal::compiler::OperandGenerator::UseUnique ( Node *  node )

inline

Definition at line 70 of file instruction-selector-impl.h.

                                            {
    return Use(node, new (zone()) UnallocatedOperand(UnallocatedOperand::ANY));
  }

References v8::internal::compiler::UnallocatedOperand::ANY, Use(), and zone().

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

Here is the call graph for this function:

Here is the caller graph for this function:

UseUniqueRegister()

InstructionOperand* v8::internal::compiler::OperandGenerator::UseUniqueRegister ( Node *  node )

inline

Definition at line 76 of file instruction-selector-impl.h.

                                                    {
    return Use(node, new (zone())
               UnallocatedOperand(UnallocatedOperand::MUST_HAVE_REGISTER));
  }

References v8::internal::compiler::UnallocatedOperand::MUST_HAVE_REGISTER, Use(), and zone().

Here is the call graph for this function:

zone()

Zone* v8::internal::compiler::OperandGenerator::zone ( ) const

inlineprotected

Definition at line 140 of file instruction-selector-impl.h.

{ return selector()->instruction_zone(); }

References selector().

Referenced by DefineAsConstant(), DefineAsFixed(), DefineAsRegister(), DefineSameAsFirst(), isolate(), TempDoubleRegister(), TempImmediate(), TempRegister(), ToUnallocatedOperand(), Use(), UseFixed(), UseImmediate(), UseRegister(), UseUnique(), and UseUniqueRegister().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

selector_

InstructionSelector* v8::internal::compiler::OperandGenerator::selector_

private

Definition at line 199 of file instruction-selector-impl.h.

Referenced by selector().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/compiler/instruction-selector-impl.h