Combine InstanceField and StaticField and Field.
This gives us full consistency with the java.lang.reflect.Field type.
Change-Id: Ib17c7fca4fe2c912fa9f5e37da2be0aebb8def9c
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 3f9f7ab..9053d57 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -68,8 +68,8 @@
Class* java_lang_reflect_Field = AllocClass(java_lang_Class);
CHECK(java_lang_reflect_Field != NULL);
java_lang_reflect_Field->descriptor_ = "Ljava/lang/reflect/Field;";
- CHECK_LT(java_lang_reflect_Field->object_size_, std::max(sizeof(StaticField), sizeof(InstanceField)));
- java_lang_reflect_Field->object_size_ = std::max(sizeof(StaticField), sizeof(InstanceField));
+ CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
+ java_lang_reflect_Field->object_size_ = sizeof(Field);
Class* java_lang_reflect_Method = AllocClass(java_lang_Class);
java_lang_reflect_Method->descriptor_ = "Ljava/lang/reflect/Method;";
CHECK(java_lang_reflect_Method != NULL);
@@ -108,8 +108,8 @@
java_lang_Class->object_size_ = sizeof(Class);
Class* Field_class = FindSystemClass(java_lang_reflect_Field->GetDescriptor());
CHECK_EQ(java_lang_reflect_Field, Field_class);
- CHECK_LT(java_lang_reflect_Field->object_size_, std::max(sizeof(StaticField), sizeof(InstanceField)));
- java_lang_reflect_Field->object_size_ = std::max(sizeof(StaticField), sizeof(InstanceField));
+ CHECK_LT(java_lang_reflect_Field->object_size_, sizeof(Field));
+ java_lang_reflect_Field->object_size_ = sizeof(Field);
Class* Method_class = FindSystemClass(java_lang_reflect_Method->GetDescriptor());
CHECK_EQ(java_lang_reflect_Method, Method_class);
CHECK_LT(java_lang_reflect_Method->object_size_, sizeof(Method));
@@ -227,12 +227,8 @@
return AllocClass(GetClassRoot(kJavaLangClass));
}
-StaticField* ClassLinker::AllocStaticField() {
- return down_cast<StaticField*>(GetClassRoot(kJavaLangReflectField)->NewInstance());
-}
-
-InstanceField* ClassLinker::AllocInstanceField() {
- return down_cast<InstanceField*>(GetClassRoot(kJavaLangReflectField)->NewInstance());
+Field* ClassLinker::AllocField() {
+ return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->NewInstance());
}
Method* ClassLinker::AllocMethod() {
@@ -392,12 +388,12 @@
// Load static fields.
DCHECK(klass->sfields_ == NULL);
if (num_static_fields != 0) {
- klass->sfields_ = AllocObjectArray<StaticField>(num_static_fields);
+ klass->sfields_ = AllocObjectArray<Field>(num_static_fields);
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
DexFile::Field dex_field;
dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
- StaticField* sfield = AllocStaticField();
+ Field* sfield = AllocField();
klass->SetStaticField(i, sfield);
LoadField(dex_file, dex_field, klass, sfield);
}
@@ -407,12 +403,12 @@
DCHECK(klass->ifields_ == NULL);
if (num_instance_fields != 0) {
// TODO: allocate on the object heap.
- klass->ifields_ = AllocObjectArray<InstanceField>(num_instance_fields);
+ klass->ifields_ = AllocObjectArray<Field>(num_instance_fields);
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
DexFile::Field dex_field;
dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
- InstanceField* ifield = AllocInstanceField();
+ Field* ifield = AllocField();
klass->SetInstanceField(i, ifield);
LoadField(dex_file, dex_field, klass, ifield);
}
@@ -472,10 +468,10 @@
Class* klass,
Field* dst) {
const DexFile::FieldId& field_id = dex_file.GetFieldId(src.field_idx_);
- dst->java_declaring_class_ = klass;
dst->declaring_class_ = klass;
dst->name_ = ResolveString(klass, field_id.name_idx_, dex_file);
dst->descriptor_.set(dex_file.dexStringByTypeIdx(field_id.type_idx_));
+ // TODO: Assign dst->type_.
dst->access_flags_ = src.access_flags_;
}
@@ -484,7 +480,6 @@
Class* klass,
Method* dst) {
const DexFile::MethodId& method_id = dex_file.GetMethodId(src.method_idx_);
- dst->java_declaring_class_ = klass;
dst->declaring_class_ = klass;
dst->name_ = ResolveString(klass, method_id.name_idx_, dex_file);
{
@@ -1013,7 +1008,7 @@
const byte* addr = dex_file.GetEncodedArray(*dex_class_def);
size_t array_size = DecodeUnsignedLeb128(&addr);
for (size_t i = 0; i < array_size; ++i) {
- StaticField* field = klass->GetStaticField(i);
+ Field* field = klass->GetStaticField(i);
JValue value;
DexFile::ValueType type = dex_file.ReadEncodedValue(&addr, &value);
switch (type) {
@@ -1359,14 +1354,14 @@
size_t next_64bit_primitive_slot = 0;
for (size_t i = 0; i < klass->NumStaticFields(); i++) {
- StaticField* field = klass->GetStaticField(i);
+ Field* field = klass->GetStaticField(i);
char type = field->GetType();
if (type == '[' || type == 'L') {
- field->java_slot_ = next_reference_slot++;
+ field->offset_ = next_reference_slot++;
} else if (type == 'J' || type == 'D') {
- field->java_slot_ = next_64bit_primitive_slot++;
+ field->offset_ = next_64bit_primitive_slot++;
} else {
- field->java_slot_ = next_32bit_primitive_slot++;
+ field->offset_ = next_32bit_primitive_slot++;
}
}
@@ -1397,11 +1392,11 @@
klass->num_reference_instance_fields_ = 0;
size_t i = 0;
for ( ; i < klass->NumInstanceFields(); i++) {
- InstanceField* pField = klass->GetInstanceField(i);
+ Field* pField = klass->GetInstanceField(i);
char c = pField->GetType();
if (c != '[' && c != 'L') {
for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
- InstanceField* refField = klass->GetInstanceField(j);
+ Field* refField = klass->GetInstanceField(j);
char rc = refField->GetType();
if (rc == '[' || rc == 'L') {
klass->SetInstanceField(i, refField);
@@ -1426,7 +1421,7 @@
// we're not aligned, though, we want to shuffle one 32-bit field
// into place. If we can't find one, we'll have to pad it.
if (i != klass->NumInstanceFields() && (field_offset & 0x04) != 0) {
- InstanceField* pField = klass->GetInstanceField(i);
+ Field* pField = klass->GetInstanceField(i);
char c = pField->GetType();
if (c != 'J' && c != 'D') {
@@ -1441,7 +1436,7 @@
// swap into it.
bool found = false;
for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
- InstanceField* singleField = klass->GetInstanceField(j);
+ Field* singleField = klass->GetInstanceField(j);
char rc = singleField->GetType();
if (rc != 'J' && rc != 'D') {
klass->SetInstanceField(i, singleField);
@@ -1464,11 +1459,11 @@
// finish assigning field offsets to all fields.
DCHECK(i == klass->NumInstanceFields() || (field_offset & 0x04) == 0);
for ( ; i < klass->NumInstanceFields(); i++) {
- InstanceField* pField = klass->GetInstanceField(i);
+ Field* pField = klass->GetInstanceField(i);
char c = pField->GetType();
if (c != 'D' && c != 'J') {
for (size_t j = klass->NumInstanceFields() - 1; j > i; j--) {
- InstanceField* doubleField = klass->GetInstanceField(j);
+ Field* doubleField = klass->GetInstanceField(j);
char rc = doubleField->GetType();
if (rc == 'D' || rc == 'J') {
klass->SetInstanceField(i, doubleField);
@@ -1493,7 +1488,7 @@
// non-reference fields, and all double-wide fields are aligned.
bool seen_non_ref = false;
for (i = 0; i < klass->NumInstanceFields(); i++) {
- InstanceField *pField = klass->GetInstanceField(i);
+ Field *pField = klass->GetInstanceField(i);
char c = pField->GetType();
if (c == 'D' || c == 'J') {
@@ -1532,7 +1527,7 @@
// Note that, per the comment on struct InstField, f->byteOffset
// is the offset from the beginning of obj, not the offset into
// obj->instanceData.
- const InstanceField* field = klass->GetInstanceField(i);
+ const Field* field = klass->GetInstanceField(i);
size_t byte_offset = field->GetOffset();
CHECK_GE(byte_offset, CLASS_SMALLEST_OFFSET);
CHECK_EQ(byte_offset & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
diff --git a/src/class_linker.h b/src/class_linker.h
index 4720f46..edd48eb 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -56,8 +56,7 @@
// kObjectArrayClass and kJavaLangString etc.
Class* AllocClass();
DexCache* AllocDexCache();
- StaticField* AllocStaticField();
- InstanceField* AllocInstanceField();
+ Field* AllocField();
Method* AllocMethod();
template <class T>
ObjectArray<T>* AllocObjectArray(size_t length) {
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 03b6dfb..25b03b2 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -142,14 +142,14 @@
}
for (size_t i = 0; i < klass->NumInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
+ Field* field = klass->GetInstanceField(i);
EXPECT_TRUE(field != NULL);
EXPECT_FALSE(field->IsStatic());
EXPECT_EQ(klass, field->GetDeclaringClass());
}
for (size_t i = 0; i < klass->NumStaticFields(); i++) {
- StaticField* field = klass->GetStaticField(i);
+ Field* field = klass->GetStaticField(i);
EXPECT_TRUE(field != NULL);
EXPECT_TRUE(field->IsStatic());
EXPECT_EQ(klass, field->GetDeclaringClass());
@@ -158,7 +158,7 @@
// Confirm that all instances fields are packed together at the start
EXPECT_GE(klass->NumInstanceFields(), klass->NumReferenceInstanceFields());
for (size_t i = 0; i < klass->NumReferenceInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
+ Field* field = klass->GetInstanceField(i);
ASSERT_TRUE(field != NULL);
ASSERT_TRUE(field->GetDescriptor() != NULL);
Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
@@ -166,7 +166,7 @@
EXPECT_FALSE(field_type->IsPrimitive());
}
for (size_t i = klass->NumReferenceInstanceFields(); i < klass->NumInstanceFields(); i++) {
- InstanceField* field = klass->GetInstanceField(i);
+ Field* field = klass->GetInstanceField(i);
ASSERT_TRUE(field != NULL);
ASSERT_TRUE(field->GetDescriptor() != NULL);
Class* field_type = class_linker_->FindClass(field->GetDescriptor(), class_loader);
@@ -400,53 +400,53 @@
EXPECT_EQ(10U, statics->NumStaticFields());
- StaticField* s0 = statics->GetStaticField(0);
+ Field* s0 = statics->GetStaticField(0);
EXPECT_EQ("Ljava/lang/reflect/Field;", s0->GetClass()->descriptor_);
EXPECT_EQ('Z', s0->GetType());
// EXPECT_EQ(true, s0->GetBoolean()); // TODO uncomment this
s0->SetBoolean(false);
- StaticField* s1 = statics->GetStaticField(1);
+ Field* s1 = statics->GetStaticField(1);
EXPECT_EQ('B', s1->GetType());
// EXPECT_EQ(5, s1->GetByte()); // TODO uncomment this
s1->SetByte(6);
- StaticField* s2 = statics->GetStaticField(2);
+ Field* s2 = statics->GetStaticField(2);
EXPECT_EQ('C', s2->GetType());
// EXPECT_EQ('a', s2->GetChar()); // TODO uncomment this
s2->SetChar('b');
- StaticField* s3 = statics->GetStaticField(3);
+ Field* s3 = statics->GetStaticField(3);
EXPECT_EQ('S', s3->GetType());
// EXPECT_EQ(65000, s3->GetShort()); // TODO uncomment this
s3->SetShort(65001);
- StaticField* s4 = statics->GetStaticField(4);
+ Field* s4 = statics->GetStaticField(4);
EXPECT_EQ('I', s4->GetType());
// EXPECT_EQ(2000000000, s4->GetInt()); // TODO uncomment this
s4->SetInt(2000000001);
- StaticField* s5 = statics->GetStaticField(5);
+ Field* s5 = statics->GetStaticField(5);
EXPECT_EQ('J', s5->GetType());
// EXPECT_EQ(0x1234567890abcdefLL, s5->GetLong()); // TODO uncomment this
s5->SetLong(0x34567890abcdef12LL);
- StaticField* s6 = statics->GetStaticField(6);
+ Field* s6 = statics->GetStaticField(6);
EXPECT_EQ('F', s6->GetType());
// EXPECT_EQ(0.5, s6->GetFloat()); // TODO uncomment this
s6->SetFloat(0.75);
- StaticField* s7 = statics->GetStaticField(7);
+ Field* s7 = statics->GetStaticField(7);
EXPECT_EQ('D', s7->GetType());
// EXPECT_EQ(16777217, s7->GetDouble()); // TODO uncomment this
s7->SetDouble(16777219);
- StaticField* s8 = statics->GetStaticField(8);
+ Field* s8 = statics->GetStaticField(8);
EXPECT_EQ('L', s8->GetType());
// EXPECT_TRUE(down_cast<String*>(s8->GetObject())->Equals("android")); // TODO uncomment this
s8->SetObject(String::AllocFromAscii("robot"));
- StaticField* s9 = statics->GetStaticField(9);
+ Field* s9 = statics->GetStaticField(9);
EXPECT_EQ('[', s9->GetType());
// EXPECT_EQ(NULL, s9->GetObject()); // TODO uncomment this
s9->SetObject(NULL);
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 2cfb0c6..aefd502 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -160,7 +160,7 @@
void MarkSweep::ScanStaticFields(const Class* klass) {
DCHECK(klass != NULL);
for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
- const StaticField* static_field = klass->GetStaticField(i);
+ const Field* static_field = klass->GetStaticField(i);
char ch = static_field->GetType();
if (ch == '[' || ch == 'L') {
const Object* obj = static_field->GetObject();
diff --git a/src/object.cc b/src/object.cc
index 409ff61..2297eca 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -153,105 +153,125 @@
return IsInSamePackage(klass1->descriptor_, klass2->descriptor_);
}
-bool StaticField::GetBoolean() {
+bool Field::GetBoolean() {
CHECK_EQ(GetType(), 'Z');
- return declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_32bit_primitives_->Get(offset_);
}
-void StaticField::SetBoolean(bool z) {
+void Field::SetBoolean(bool z) {
CHECK_EQ(GetType(), 'Z');
- declaring_class_->static_32bit_primitives_->Set(java_slot_, z);
+ CHECK(IsStatic());
+ declaring_class_->static_32bit_primitives_->Set(offset_, z);
}
-int8_t StaticField::GetByte() {
+int8_t Field::GetByte() {
CHECK_EQ(GetType(), 'B');
- return declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_32bit_primitives_->Get(offset_);
}
-void StaticField::SetByte(int8_t b) {
+void Field::SetByte(int8_t b) {
CHECK_EQ(GetType(), 'B');
- declaring_class_->static_32bit_primitives_->Set(java_slot_, b);
+ CHECK(IsStatic());
+ declaring_class_->static_32bit_primitives_->Set(offset_, b);
}
-uint16_t StaticField::GetChar() {
+uint16_t Field::GetChar() {
CHECK_EQ(GetType(), 'C');
- return declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_32bit_primitives_->Get(offset_);
}
-void StaticField::SetChar(uint16_t c) {
+void Field::SetChar(uint16_t c) {
CHECK_EQ(GetType(), 'C');
- declaring_class_->static_32bit_primitives_->Set(java_slot_, c);
+ CHECK(IsStatic());
+ declaring_class_->static_32bit_primitives_->Set(offset_, c);
}
-uint16_t StaticField::GetShort() {
+uint16_t Field::GetShort() {
CHECK_EQ(GetType(), 'S');
- return declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_32bit_primitives_->Get(offset_);
}
-void StaticField::SetShort(uint16_t s) {
+void Field::SetShort(uint16_t s) {
CHECK_EQ(GetType(), 'S');
- declaring_class_->static_32bit_primitives_->Set(java_slot_, s);
+ CHECK(IsStatic());
+ declaring_class_->static_32bit_primitives_->Set(offset_, s);
}
-int32_t StaticField::GetInt() {
+int32_t Field::GetInt() {
CHECK_EQ(GetType(), 'I');
- return declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_32bit_primitives_->Get(offset_);
}
-void StaticField::SetInt(int32_t i) {
+void Field::SetInt(int32_t i) {
CHECK_EQ(GetType(), 'I');
- declaring_class_->static_32bit_primitives_->Set(java_slot_, i);
+ CHECK(IsStatic());
+ declaring_class_->static_32bit_primitives_->Set(offset_, i);
}
-int64_t StaticField::GetLong() {
+int64_t Field::GetLong() {
CHECK_EQ(GetType(), 'J');
- return declaring_class_->static_64bit_primitives_->Get(java_slot_);
+ CHECK(IsStatic());
+ return declaring_class_->static_64bit_primitives_->Get(offset_);
}
-void StaticField::SetLong(int64_t j) {
+void Field::SetLong(int64_t j) {
CHECK_EQ(GetType(), 'J');
- declaring_class_->static_64bit_primitives_->Set(java_slot_, j);
+ CHECK(IsStatic());
+ declaring_class_->static_64bit_primitives_->Set(offset_, j);
}
-float StaticField::GetFloat() {
+float Field::GetFloat() {
CHECK_EQ(GetType(), 'F');
+ CHECK(IsStatic());
JValue float_bits;
- float_bits.i = declaring_class_->static_32bit_primitives_->Get(java_slot_);
+ float_bits.i = declaring_class_->static_32bit_primitives_->Get(offset_);
return float_bits.f;
}
-void StaticField::SetFloat(float f) {
+void Field::SetFloat(float f) {
CHECK_EQ(GetType(), 'F');
+ CHECK(IsStatic());
JValue float_bits;
float_bits.f = f;
- declaring_class_->static_32bit_primitives_->Set(java_slot_, float_bits.i);
+ declaring_class_->static_32bit_primitives_->Set(offset_, float_bits.i);
}
-double StaticField::GetDouble() {
+double Field::GetDouble() {
CHECK_EQ(GetType(), 'D');
+ CHECK(IsStatic());
JValue double_bits;
- double_bits.j = declaring_class_->static_64bit_primitives_->Get(java_slot_);
+ double_bits.j = declaring_class_->static_64bit_primitives_->Get(offset_);
return double_bits.d;
}
-void StaticField::SetDouble(double d) {
+void Field::SetDouble(double d) {
CHECK_EQ(GetType(), 'D');
+ CHECK(IsStatic());
JValue double_bits;
double_bits.d = d;
- declaring_class_->static_64bit_primitives_->Set(java_slot_, double_bits.j);
+ declaring_class_->static_64bit_primitives_->Set(offset_, double_bits.j);
}
-Object* StaticField::GetObject() {
- return declaring_class_->static_references_->Get(java_slot_);
-}
-
-const Object* StaticField::GetObject() const {
- return declaring_class_->static_references_->Get(java_slot_);
-}
-
-void StaticField::SetObject(Object* l) {
+Object* Field::GetObject() {
CHECK(GetType() == 'L' || GetType() == '[');
- declaring_class_->static_references_->Set(java_slot_, l); // TODO: write barrier
+ CHECK(IsStatic());
+ return declaring_class_->static_references_->Get(offset_);
+}
+
+const Object* Field::GetObject() const {
+ CHECK(GetType() == 'L' || GetType() == '[');
+ CHECK(IsStatic());
+ return declaring_class_->static_references_->Get(offset_);
+}
+
+void Field::SetObject(Object* l) {
+ CHECK(GetType() == 'L' || GetType() == '[');
+ declaring_class_->static_references_->Set(offset_, l); // TODO: write barrier
}
uint32_t Method::NumArgRegisters() {
diff --git a/src/object.h b/src/object.h
index 5cb884c..e071b97 100644
--- a/src/object.h
+++ b/src/object.h
@@ -18,7 +18,7 @@
class Array;
class Class;
class DexCache;
-class InstanceField;
+class Field;
class InterfaceEntry;
class Monitor;
class Method;
@@ -26,7 +26,6 @@
class String;
template<class T> class ObjectArray;
template<class T> class PrimitiveArray;
-class StaticField;
typedef PrimitiveArray<uint16_t> CharArray;
typedef PrimitiveArray<uint32_t> IntArray;
typedef PrimitiveArray<uint64_t> LongArray;
@@ -284,30 +283,6 @@
return descriptor_;
}
- public: // TODO: private
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- Class* java_declaring_class_;
- Object* java_generic_type_;
- uint32_t java_generic_types_are_initialized_;
- String* name_;
- uint32_t java_slot_;
- Class* java_type_;
-
- // The class in which this field is declared.
- Class* declaring_class_;
-
- // e.g. "I", "[C", "Landroid/os/Debug;"
- StringPiece descriptor_;
-
- uint32_t access_flags_;
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(Field);
-};
-
-// Instance fields.
-class InstanceField : public Field {
- public:
uint32_t GetOffset() const {
return offset_;
}
@@ -316,55 +291,44 @@
offset_ = num_bytes;
}
- private:
- size_t offset_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(InstanceField);
-};
-
-// Static fields.
-class StaticField : public Field {
- public:
+ // static field access
bool GetBoolean();
-
void SetBoolean(bool z);
-
int8_t GetByte();
-
void SetByte(int8_t b);
-
uint16_t GetChar();
-
void SetChar(uint16_t c);
-
uint16_t GetShort();
-
void SetShort(uint16_t s);
-
int32_t GetInt();
-
void SetInt(int32_t i);
-
int64_t GetLong();
-
void SetLong(int64_t j);
-
float GetFloat();
-
void SetFloat(float f);
-
double GetDouble();
-
void SetDouble(double d);
-
Object* GetObject();
-
const Object* GetObject() const;
-
void SetObject(Object* l);
+ public: // TODO: private
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ // The class in which this field is declared.
+ Class* declaring_class_;
+ Object* generic_type_;
+ uint32_t generic_types_are_initialized_;
+ String* name_;
+ uint32_t offset_;
+ Class* type_;
+
+ // e.g. "I", "[C", "Landroid/os/Debug;"
+ StringPiece descriptor_;
+
+ uint32_t access_flags_;
+
private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(StaticField);
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Field);
};
class Method : public AccessibleObject {
@@ -431,7 +395,8 @@
public: // TODO: private
// Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- Class* java_declaring_class_;
+ // the class we are a part of
+ Class* declaring_class_;
ObjectArray<Class>* java_exception_types_;
Object* java_formal_type_parameters_;
Object* java_generic_exception_types_;
@@ -514,9 +479,6 @@
bool HasSameNameAndDescriptor(const Method* that) const;
public: // TODO: private/const
- // the class we are a part of
- Class* declaring_class_;
-
// access flags; low 16 bits are defined by spec (could be uint16_t?)
uint32_t access_flags_;
@@ -900,12 +862,12 @@
return num_reference_instance_fields_;
}
- InstanceField* GetInstanceField(uint32_t i) const { // TODO: uint16_t
+ Field* GetInstanceField(uint32_t i) const { // TODO: uint16_t
DCHECK_NE(NumInstanceFields(), 0U);
return ifields_->Get(i);
}
- void SetInstanceField(uint32_t i, InstanceField* f) { // TODO: uint16_t
+ void SetInstanceField(uint32_t i, Field* f) { // TODO: uint16_t
DCHECK_NE(NumInstanceFields(), 0U);
ifields_->Set(i, f);
}
@@ -914,12 +876,12 @@
return (sfields_ != NULL) ? sfields_->GetLength() : 0;
}
- StaticField* GetStaticField(uint32_t i) const { // TODO: uint16_t
+ Field* GetStaticField(uint32_t i) const { // TODO: uint16_t
DCHECK_NE(NumStaticFields(), 0U);
return sfields_->Get(i);
}
- void SetStaticField(uint32_t i, StaticField* f) { // TODO: uint16_t
+ void SetStaticField(uint32_t i, Field* f) { // TODO: uint16_t
DCHECK_NE(NumStaticFields(), 0U);
sfields_->Set(i, f);
}
@@ -1067,7 +1029,7 @@
// All instance fields that refer to objects are guaranteed to be at
// the beginning of the field list. num_reference_instance_fields_
// specifies the number of reference fields.
- ObjectArray<InstanceField>* ifields_;
+ ObjectArray<Field>* ifields_;
// number of fields that are object refs
size_t num_reference_instance_fields_;
@@ -1079,7 +1041,7 @@
const char* source_file_;
// Static fields
- ObjectArray<StaticField>* sfields_;
+ ObjectArray<Field>* sfields_;
// static field storage
//