v8::internal::compiler::IA32OperandConverter Class Reference

Inheritance diagram for v8::internal::compiler::IA32OperandConverter:

Collaboration diagram for v8::internal::compiler::IA32OperandConverter:

Public Member Functions
	IA32OperandConverter (CodeGenerator *gen, Instruction *instr)
Operand	InputOperand (int index)
Immediate	InputImmediate (int index)
Operand	OutputOperand ()
Operand	TempOperand (int index)
Operand	ToOperand (InstructionOperand *op, int extra=0)
Operand	HighOperand (InstructionOperand *op)
Immediate	ToImmediate (InstructionOperand *operand)
Operand	MemoryOperand (int *offset)
Operand	MemoryOperand ()
Public Member Functions inherited from v8::internal::compiler::InstructionOperandConverter
	InstructionOperandConverter (CodeGenerator *gen, Instruction *instr)
Register	InputRegister (int index)
DoubleRegister	InputDoubleRegister (int index)
double	InputDouble (int index)
int32_t	InputInt32 (int index)
int8_t	InputInt8 (int index)
int16_t	InputInt16 (int index)
uint8_t	InputInt5 (int index)
uint8_t	InputInt6 (int index)
Handle< HeapObject >	InputHeapObject (int index)
Label *	InputLabel (int index)
BasicBlock *	InputBlock (int index)
Register	OutputRegister (int index=0)
DoubleRegister	OutputDoubleRegister ()
Register	TempRegister (int index)
Register	ToRegister (InstructionOperand *op)
DoubleRegister	ToDoubleRegister (InstructionOperand *op)
Constant	ToConstant (InstructionOperand *operand)
double	ToDouble (InstructionOperand *operand)
Handle< HeapObject >	ToHeapObject (InstructionOperand *operand)
Frame *	frame () const
Isolate *	isolate () const
Linkage *	linkage () const

Static Public Member Functions
static int	NextOffset (int *offset)
static ScaleFactor	ScaleFor (AddressingMode one, AddressingMode mode)

Additional Inherited Members
Protected Attributes inherited from v8::internal::compiler::InstructionOperandConverter
CodeGenerator *	gen_
Instruction *	instr_

Detailed Description

Definition at line 23 of file code-generator-ia32.cc.

Constructor & Destructor Documentation

IA32OperandConverter()

v8::internal::compiler::IA32OperandConverter::IA32OperandConverter ( CodeGenerator *  gen, Instruction *  instr  )

inline

Definition at line 25 of file code-generator-ia32.cc.

      : InstructionOperandConverter(gen, instr) {}

Member Function Documentation

HighOperand()

Operand v8::internal::compiler::IA32OperandConverter::HighOperand ( InstructionOperand *  op )

inline

Definition at line 52 of file code-generator-ia32.cc.

                                              {
    DCHECK(op->IsDoubleStackSlot());
    return ToOperand(op, kPointerSize);
  }

References DCHECK, v8::internal::kPointerSize, and ToOperand().

Here is the call graph for this function:

InputImmediate()

Immediate v8::internal::compiler::IA32OperandConverter::InputImmediate ( int  index )

inline

Definition at line 30 of file code-generator-ia32.cc.

                                      {
    return ToImmediate(instr_->InputAt(index));
  }

References v8::internal::compiler::Instruction::InputAt(), v8::internal::compiler::InstructionOperandConverter::instr_, and ToImmediate().

Here is the call graph for this function:

InputOperand()

Operand v8::internal::compiler::IA32OperandConverter::InputOperand ( int  index )

inline

Definition at line 28 of file code-generator-ia32.cc.

{ return ToOperand(instr_->InputAt(index)); }

References v8::internal::compiler::Instruction::InputAt(), v8::internal::compiler::InstructionOperandConverter::instr_, and ToOperand().

Here is the call graph for this function:

MemoryOperand() [1/2]

Operand v8::internal::compiler::IA32OperandConverter::MemoryOperand ( )

inline

Definition at line 158 of file code-generator-ia32.cc.

                          {
    int first_input = 0;
    return MemoryOperand(&first_input);
  }

MemoryOperand() [2/2]

Operand v8::internal::compiler::IA32OperandConverter::MemoryOperand ( int *  offset )

inline

Definition at line 95 of file code-generator-ia32.cc.

                                     {
    AddressingMode mode = AddressingModeField::decode(instr_->opcode());
    switch (mode) {
      case kMode_MR: {
        Register base = InputRegister(NextOffset(offset));
        int32_t disp = 0;
        return Operand(base, disp);
      }
      case kMode_MRI: {
        Register base = InputRegister(NextOffset(offset));
        int32_t disp = InputInt32(NextOffset(offset));
        return Operand(base, disp);
      }
      case kMode_MR1:
      case kMode_MR2:
      case kMode_MR4:
      case kMode_MR8: {
        Register base = InputRegister(NextOffset(offset));
        Register index = InputRegister(NextOffset(offset));
        ScaleFactor scale = ScaleFor(kMode_MR1, mode);
        int32_t disp = 0;
        return Operand(base, index, scale, disp);
      }
      case kMode_MR1I:
      case kMode_MR2I:
      case kMode_MR4I:
      case kMode_MR8I: {
        Register base = InputRegister(NextOffset(offset));
        Register index = InputRegister(NextOffset(offset));
        ScaleFactor scale = ScaleFor(kMode_MR1I, mode);
        int32_t disp = InputInt32(NextOffset(offset));
        return Operand(base, index, scale, disp);
      }
      case kMode_M1:
      case kMode_M2:
      case kMode_M4:
      case kMode_M8: {
        Register index = InputRegister(NextOffset(offset));
        ScaleFactor scale = ScaleFor(kMode_M1, mode);
        int32_t disp = 0;
        return Operand(index, scale, disp);
      }
      case kMode_M1I:
      case kMode_M2I:
      case kMode_M4I:
      case kMode_M8I: {
        Register index = InputRegister(NextOffset(offset));
        ScaleFactor scale = ScaleFor(kMode_M1I, mode);
        int32_t disp = InputInt32(NextOffset(offset));
        return Operand(index, scale, disp);
      }
      case kMode_MI: {
        int32_t disp = InputInt32(NextOffset(offset));
        return Operand(Immediate(disp));
      }
      case kMode_None:
        UNREACHABLE();
        return Operand(no_reg, 0);
    }
    UNREACHABLE();
    return Operand(no_reg, 0);
  }

References v8::internal::BitFieldBase< T, shift, size, uint32_t >::decode(), v8::internal::compiler::InstructionOperandConverter::InputInt32(), v8::internal::compiler::InstructionOperandConverter::InputRegister(), v8::internal::compiler::InstructionOperandConverter::instr_, mode(), NextOffset(), v8::internal::no_reg, v8::internal::compiler::Instruction::opcode(), ScaleFor(), and UNREACHABLE.

Here is the call graph for this function:

NextOffset()

static int v8::internal::compiler::IA32OperandConverter::NextOffset ( int *  offset )

inlinestatic

Definition at line 79 of file code-generator-ia32.cc.

                                     {
    int i = *offset;
    (*offset)++;
    return i;
  }

Referenced by MemoryOperand().

Here is the caller graph for this function:

OutputOperand()

Operand v8::internal::compiler::IA32OperandConverter::OutputOperand ( )

inline

Definition at line 34 of file code-generator-ia32.cc.

{ return ToOperand(instr_->Output()); }

References v8::internal::compiler::InstructionOperandConverter::instr_, v8::internal::compiler::Instruction::Output(), and ToOperand().

Here is the call graph for this function:

ScaleFor()

static ScaleFactor v8::internal::compiler::IA32OperandConverter::ScaleFor ( AddressingMode  one, AddressingMode  mode  )

inlinestatic

Definition at line 85 of file code-generator-ia32.cc.

                                                                       {
    STATIC_ASSERT(0 == static_cast<int>(times_1));
    STATIC_ASSERT(1 == static_cast<int>(times_2));
    STATIC_ASSERT(2 == static_cast<int>(times_4));
    STATIC_ASSERT(3 == static_cast<int>(times_8));
    int scale = static_cast<int>(mode - one);
    DCHECK(scale >= 0 && scale < 4);
    return static_cast<ScaleFactor>(scale);
  }

References DCHECK, mode(), v8::internal::compiler::STATIC_ASSERT(), v8::internal::times_1, v8::internal::times_2, v8::internal::times_4, and v8::internal::times_8.

Referenced by MemoryOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

TempOperand()

Operand v8::internal::compiler::IA32OperandConverter::TempOperand ( int  index )

inline

Definition at line 36 of file code-generator-ia32.cc.

{ return ToOperand(instr_->TempAt(index)); }

References v8::internal::compiler::InstructionOperandConverter::instr_, v8::internal::compiler::Instruction::TempAt(), and ToOperand().

Here is the call graph for this function:

ToImmediate()

Immediate v8::internal::compiler::IA32OperandConverter::ToImmediate ( InstructionOperand *  operand )

inline

Definition at line 57 of file code-generator-ia32.cc.

                                                     {
    Constant constant = ToConstant(operand);
    switch (constant.type()) {
      case Constant::kInt32:
        return Immediate(constant.ToInt32());
      case Constant::kFloat32:
        return Immediate(
            isolate()->factory()->NewNumber(constant.ToFloat32(), TENURED));
      case Constant::kFloat64:
        return Immediate(
            isolate()->factory()->NewNumber(constant.ToFloat64(), TENURED));
      case Constant::kExternalReference:
        return Immediate(constant.ToExternalReference());
      case Constant::kHeapObject:
        return Immediate(constant.ToHeapObject());
      case Constant::kInt64:
        break;
    }
    UNREACHABLE();
    return Immediate(-1);
  }

References v8::internal::compiler::InstructionOperandConverter::isolate(), v8::internal::TENURED, v8::internal::compiler::InstructionOperandConverter::ToConstant(), and UNREACHABLE.

Referenced by InputImmediate().

Here is the call graph for this function:

Here is the caller graph for this function:

ToOperand()

Operand v8::internal::compiler::IA32OperandConverter::ToOperand ( InstructionOperand *  op, int  extra = 0  )

inline

Definition at line 38 of file code-generator-ia32.cc.

                                                           {
    if (op->IsRegister()) {
      DCHECK(extra == 0);
      return Operand(ToRegister(op));
    } else if (op->IsDoubleRegister()) {
      DCHECK(extra == 0);
      return Operand(ToDoubleRegister(op));
    }
    DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
    // The linkage computes where all spill slots are located.
    FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), extra);
    return Operand(offset.from_stack_pointer() ? esp : ebp, offset.offset());
  }

References DCHECK, v8::internal::ebp, v8::internal::esp, v8::internal::compiler::InstructionOperandConverter::frame(), v8::internal::compiler::FrameOffset::from_stack_pointer(), v8::internal::compiler::Linkage::GetFrameOffset(), v8::internal::compiler::InstructionOperand::index(), v8::internal::compiler::InstructionOperandConverter::linkage(), v8::internal::compiler::FrameOffset::offset(), v8::internal::compiler::InstructionOperandConverter::ToDoubleRegister(), and v8::internal::compiler::InstructionOperandConverter::ToRegister().

Referenced by HighOperand(), InputOperand(), OutputOperand(), and TempOperand().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• /mnt/V8SourceCode/src/compiler/ia32/code-generator-ia32.cc