runtime/vm/assembler_x64.h - Issue 1268783003: Simplify constant pool usage in x64 code generator (by removing extra argument

Unified Diff: runtime/vm/assembler_x64.h

Issue 1268783003: Simplify constant pool usage in x64 code generator (by removing extra argument (Closed) Base URL: git@github.com:dart-lang/sdk.git@master

Patch Set: address comments Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: runtime/vm/assembler_x64.h

diff --git a/runtime/vm/assembler_x64.h b/runtime/vm/assembler_x64.h

index e0c68535f3d840980d0ab70b9a26ad829d5a7b51..bd082efa10b33d96441afd8e948b1635b4795942 100644

--- a/runtime/vm/assembler_x64.h

+++ b/runtime/vm/assembler_x64.h

@@ -370,7 +370,7 @@ class Assembler : public ValueObject {

void pushq(Register reg);

void pushq(const Address& address);

void pushq(const Immediate& imm);

- void PushImmediate(const Immediate& imm, Register pp);

+ void PushImmediate(const Immediate& imm);

void popq(Register reg);

void popq(const Address& address);

@@ -527,9 +527,8 @@ class Assembler : public ValueObject {

void cmpq(Register reg0, Register reg1);

void cmpq(Register reg, const Address& address);

- void CompareImmediate(Register reg, const Immediate& imm, Register pp);

- void CompareImmediate(const Address& address, const Immediate& imm,

- Register pp);

+ void CompareImmediate(Register reg, const Immediate& imm);

+ void CompareImmediate(const Address& address, const Immediate& imm);

void testl(Register reg1, Register reg2);

void testl(Register reg, const Immediate& imm);

@@ -537,7 +536,7 @@ class Assembler : public ValueObject {

void testq(Register reg1, Register reg2);

void testq(Register reg, const Immediate& imm);

- void TestImmediate(Register dst, const Immediate& imm, Register pp);

+ void TestImmediate(Register dst, const Immediate& imm);

void andl(Register dst, Register src);

void andl(Register dst, const Immediate& imm);

@@ -551,18 +550,18 @@ class Assembler : public ValueObject {

void andq(Register dst, Register src);

void andq(Register dst, const Address& address);

void andq(Register dst, const Immediate& imm);

- void AndImmediate(Register dst, const Immediate& imm, Register pp);

+ void AndImmediate(Register dst, const Immediate& imm);

void orq(Register dst, Register src);

void orq(Register dst, const Address& address);

void orq(Register dst, const Immediate& imm);

- void OrImmediate(Register dst, const Immediate& imm, Register pp);

+ void OrImmediate(Register dst, const Immediate& imm);

void xorq(Register dst, Register src);

void xorq(Register dst, const Address& address);

void xorq(const Address& dst, Register src);

void xorq(Register dst, const Immediate& imm);

- void XorImmediate(Register dst, const Immediate& imm, Register pp);

+ void XorImmediate(Register dst, const Immediate& imm);

void addl(Register dst, Register src);

void addl(Register dst, const Immediate& imm);

@@ -597,7 +596,7 @@ class Assembler : public ValueObject {

void imulq(Register dst, Register src);

void imulq(Register dst, const Address& address);

void imulq(Register dst, const Immediate& imm);

- void MulImmediate(Register reg, const Immediate& imm, Register pp);

+ void MulImmediate(Register reg, const Immediate& imm);

void mulq(Register reg);

void subl(Register dst, Register src);

@@ -739,15 +738,13 @@ class Assembler : public ValueObject {

void MoveRegister(Register to, Register from);

void PopRegister(Register r);

- // Macros accepting a pp Register argument may attempt to load values from

- // the object pool when possible. Unless you are sure that the untagged object

- // pool pointer is in another register, or that it is not available at all,

- // PP should be passed for pp.

+ // Macros for adding/subtracting an immediate value that may be loaded from

+ // the constant pool.

// TODO(koda): Assert that these are not used for heap objects.

- void AddImmediate(Register reg, const Immediate& imm, Register pp);

- void AddImmediate(const Address& address, const Immediate& imm, Register pp);

- void SubImmediate(Register reg, const Immediate& imm, Register pp);

- void SubImmediate(const Address& address, const Immediate& imm, Register pp);

+ void AddImmediate(Register reg, const Immediate& imm);

+ void AddImmediate(const Address& address, const Immediate& imm);

+ void SubImmediate(Register reg, const Immediate& imm);

+ void SubImmediate(const Address& address, const Immediate& imm);

void Drop(intptr_t stack_elements, Register tmp = TMP);

@@ -758,25 +755,26 @@ class Assembler : public ValueObject {

constant_pool_allowed_ = b;

}

- bool CanLoadImmediateFromPool(const Immediate& imm, Register pp);

- void LoadImmediate(Register reg, const Immediate& imm, Register pp);

+ void LoadImmediate(Register reg, const Immediate& imm);

void LoadIsolate(Register dst);

- void LoadObject(Register dst, const Object& obj, Register pp);

- void LoadUniqueObject(Register dst, const Object& obj, Register pp);

+ void LoadObject(Register dst, const Object& obj);

+ void LoadUniqueObject(Register dst, const Object& obj);

void LoadExternalLabel(Register dst,

const ExternalLabel* label,

- Patchability patchable,

- Register pp);

+ Patchability patchable);

+ void LoadFunctionFromCalleePool(Register dst,

+ const Function& function,

+ Register new_pp);

void JmpPatchable(const ExternalLabel* label, Register pp);

void Jmp(const ExternalLabel* label, Register pp);

void J(Condition condition, const ExternalLabel* label, Register pp);

void CallPatchable(const ExternalLabel* label);

- void Call(const ExternalLabel* label, Register pp);

+ void Call(const ExternalLabel* label);

// Unaware of write barrier (use StoreInto* methods for storing to objects).

// TODO(koda): Add StackAddress/HeapAddress types to prevent misuse.

- void StoreObject(const Address& dst, const Object& obj, Register pp);

- void PushObject(const Object& object, Register pp);

- void CompareObject(Register reg, const Object& object, Register pp);

+ void StoreObject(const Address& dst, const Object& obj);

+ void PushObject(const Object& object);

+ void CompareObject(Register reg, const Object& object);

// When storing into a heap object field, knowledge of the previous content

// is expressed through these constants.

@@ -804,13 +802,11 @@ class Assembler : public ValueObject {

void StoreIntoObjectNoBarrier(Register object,

const Address& dest,

const Object& value,

- Register pp,

FieldContent old_content = kHeapObjectOrSmi);

void InitializeFieldNoBarrier(Register object,

const Address& dest,

- const Object& value,

- Register pp) {

- return StoreIntoObjectNoBarrier(object, dest, value, pp, kEmptyOrSmiOrNull);

+ const Object& value) {

+ return StoreIntoObjectNoBarrier(object, dest, value, kEmptyOrSmiOrNull);

}

// Stores a Smi value into a heap object field that always contains a Smi.

@@ -854,9 +850,9 @@ class Assembler : public ValueObject {

void LoadClassId(Register result, Register object);

- void LoadClassById(Register result, Register class_id, Register pp);

+ void LoadClassById(Register result, Register class_id);

- void LoadClass(Register result, Register object, Register pp);

+ void LoadClass(Register result, Register object);

void CompareClassId(Register object, intptr_t class_id);

@@ -923,7 +919,7 @@ class Assembler : public ValueObject {

buffer_.FinalizeInstructions(region);

}

- void LoadPoolPointer(Register pp);

+ void LoadPoolPointer(Register pp = PP);

// Set up a Dart frame on entry with a frame pointer and PC information to

// enable easy access to the RawInstruction object of code corresponding

@@ -1007,13 +1003,10 @@ class Assembler : public ValueObject {

// calls. Jump to 'failure' if the instance cannot be allocated here.

// Allocated instance is returned in 'instance_reg'.

// Only the tags field of the object is initialized.

- // Loads large immediates from the object pool with pool pointer in PP if it

- // is not kNoRegister

void TryAllocate(const Class& cls,

Label* failure,

bool near_jump,

- Register instance_reg,

- Register pp);

+ Register instance_reg);

void TryAllocateArray(intptr_t cid,

intptr_t instance_size,

@@ -1077,11 +1070,8 @@ class Assembler : public ValueObject {

intptr_t FindImmediate(int64_t imm);

bool CanLoadFromObjectPool(const Object& object) const;

- void LoadObjectHelper(Register dst,

- const Object& obj,

- Register pp,

- bool is_unique);

- void LoadWordFromPoolOffset(Register dst, Register pp, int32_t offset);

+ void LoadObjectHelper(Register dst, const Object& obj, bool is_unique);

+ void LoadWordFromPoolOffset(Register dst, int32_t offset);

inline void EmitUint8(uint8_t value);

inline void EmitInt32(int32_t value);

@@ -1132,7 +1122,7 @@ class Assembler : public ValueObject {

FieldContent old_content);

// Unaware of write barrier (use StoreInto* methods for storing to objects).

- void MoveImmediate(const Address& dst, const Immediate& imm, Register pp);

+ void MoveImmediate(const Address& dst, const Immediate& imm);

void ComputeCounterAddressesForCid(intptr_t cid,

Heap::Space space,

« no previous file with comments | « no previous file | runtime/vm/assembler_x64.cc » ('j') | no next file with comments »