> 1. What is mean of currentInstruction[2]? As I Understand it's holds
> information about "Int32: 6(@k1)". Am I right??
It's a register index. Usually, it means that that index times 8 plus whatever
is in the call frame register, you'll find the data for the register. But if
it's larger than 0x40000000, it means it's a constant index (i.e. subtract
0x40000000 from it and you get the index of the constant in the code block).
In this case, "k1" means that it's a constant register index, so
currentInstruction[2] has the value 0x40000001.
>
> 2. As I understand after
> emitGetVirtualRegister(currentInstruction[2].u.operand, regT0) we have
> encoded value of "Int32: 6(@k1)" in regT0.
It means we have emitted a move-immediate-to-register instruction that places
the value of constant at index 1 into regT0.
>
> 3. Cant't understad mean of move(TrustedImmPtr(globalObject), regT1).
> globalObject is a pretty big class. Can't figure out what is happening here
This is another move-immediate-to-register instruction. globalObject is not a
class, nor is it an object; it's a pointer. We're just moving a pointer
immediate (64 bits of data) into regT1.
>
> 4. loadPtr(Address(regT1, JSVariableObject::offsetOfRegisters()), regT1); //
> What the mean of JSVariableObject::offsetOfRegisters()??
We're loading from the globalObject->m_registers. This is a load instruction,
which takes an address consisting of a base (a register) and an offset (an
immediate). regT1 is the base, which contains a pointer to the globalObject.
JSVariableObject::offsetOfRegisters() is a helper that gives us the offset of
the JSVariableObject::m_registers field. This makes sense since JSGlobalData
inherits from JSVariableObject.
Think of this instruction as if we were emitting the following line of C code:
regT1 = static_cast<JSVariableObject*>(regT1)->m_registers;
>
> 5. storePtr(regT0, Address(regT1, currentInstruction[1].u.operand *
> sizeof(Register))); // As I understand currentInstruction[1].u.operand holds
> address where to put my constant, i.e "4". Am I right?
currentInstruction[1] is not an address. It's an index into the global
variable's registers. This is emitting a store instruction that places the
value of register regT0 into the address specified by the sum of regT1and the
immediate offset, currentInstuctin[1].u.operand * sizeof(Register). regT1
holds a pointer to a Register* (i.e. a pointer to an array of Registers). So
think of this code as if it were emitting the following line of C code:
static_cast<Register*>(regT1)[currentInstruction[1].u.operand] = regT0;
>
> And question about mov instruction on x86_64 platform
>
> JSC::X86Assembler::movq_i64r
>
> void movq_i64r(int64_t imm, RegisterID dst)
>
>
> {
>
>
> m_formatter.oneByteOp64(OP_MOV_EAXIv, dst);
>
>
> m_formatter.immediate64(imm);
>
> }
>
> How will look appropriate assembly for this code??
Use the code, Luke! It's just 9 bytes, with the first byte having the value of
OP_MOV_EAXIv (i.e. 0xb8), and the next 8 bytes are just whatever imm is,
encoded in little endian.
-Filip
_______________________________________________
webkit-dev mailing list
[email protected]
http://lists.webkit.org/mailman/listinfo.cgi/webkit-dev
