Carl Shapiro | 3ee755d | 2011-06-28 12:11:04 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
| 2 | |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 3 | #include "object.h" |
| 4 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 5 | #include <string.h> |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 6 | #include <algorithm> |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 7 | |
Elliott Hughes | d8ddfd5 | 2011-08-15 14:32:53 -0700 | [diff] [blame] | 8 | #include "class_linker.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 9 | #include "globals.h" |
Brian Carlstrom | a40f9bc | 2011-07-26 21:26:07 -0700 | [diff] [blame] | 10 | #include "heap.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 11 | #include "logging.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 12 | #include "dex_cache.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 13 | #include "dex_file.h" |
Carl Shapiro | 3ee755d | 2011-06-28 12:11:04 -0700 | [diff] [blame] | 14 | |
| 15 | namespace art { |
| 16 | |
Brian Carlstrom | f7ed11a | 2011-08-09 17:55:51 -0700 | [diff] [blame] | 17 | bool Class::Implements(const Class* klass) const { |
| 18 | DCHECK(klass != NULL); |
| 19 | DCHECK(klass->IsInterface()); |
| 20 | // All interfaces implemented directly and by our superclass, and |
| 21 | // recursively all super-interfaces of those interfaces, are listed |
| 22 | // in iftable_, so we can just do a linear scan through that. |
| 23 | for (size_t i = 0; i < iftable_count_; i++) { |
| 24 | if (iftable_[i].GetClass() == klass) { |
| 25 | return true; |
| 26 | } |
| 27 | } |
| 28 | return false; |
| 29 | } |
| 30 | |
| 31 | // Determine whether "this" is assignable from "klazz", where both of these |
| 32 | // are array classes. |
| 33 | // |
| 34 | // Consider an array class, e.g. Y[][], where Y is a subclass of X. |
| 35 | // Y[][] = Y[][] --> true (identity) |
| 36 | // X[][] = Y[][] --> true (element superclass) |
| 37 | // Y = Y[][] --> false |
| 38 | // Y[] = Y[][] --> false |
| 39 | // Object = Y[][] --> true (everything is an object) |
| 40 | // Object[] = Y[][] --> true |
| 41 | // Object[][] = Y[][] --> true |
| 42 | // Object[][][] = Y[][] --> false (too many []s) |
| 43 | // Serializable = Y[][] --> true (all arrays are Serializable) |
| 44 | // Serializable[] = Y[][] --> true |
| 45 | // Serializable[][] = Y[][] --> false (unless Y is Serializable) |
| 46 | // |
| 47 | // Don't forget about primitive types. |
| 48 | // int[] instanceof Object[] --> false |
| 49 | // |
| 50 | bool Class::IsArrayAssignableFromArray(const Class* klass) const { |
| 51 | DCHECK(IsArray()); |
| 52 | DCHECK(klass->IsArray()); |
| 53 | DCHECK_GT(array_rank_, 0); |
| 54 | DCHECK_GT(klass->array_rank_, 0); |
| 55 | DCHECK(component_type_ != NULL); |
| 56 | DCHECK(klass->component_type_ != NULL); |
| 57 | if (array_rank_ > klass->array_rank_) { |
| 58 | // Too many []s. |
| 59 | return false; |
| 60 | } |
| 61 | if (array_rank_ == klass->array_rank_) { |
| 62 | return component_type_->IsAssignableFrom(klass->component_type_); |
| 63 | } |
| 64 | DCHECK_LT(array_rank_, klass->array_rank_); |
| 65 | // The thing we might be assignable from has more dimensions. We |
| 66 | // must be an Object or array of Object, or a standard array |
| 67 | // interface or array of standard array interfaces (the standard |
| 68 | // interfaces being java/lang/Cloneable and java/io/Serializable). |
| 69 | if (component_type_->IsInterface()) { |
| 70 | // See if we implement our component type. We know the |
| 71 | // base element is an interface; if the array class implements |
| 72 | // it, we know it's a standard array interface. |
| 73 | return Implements(component_type_); |
| 74 | } |
| 75 | // See if this is an array of Object, Object[], etc. We know |
| 76 | // that the superclass of an array is always Object, so we |
| 77 | // just compare the element type to that. |
| 78 | Class* java_lang_Object = GetSuperClass(); |
| 79 | DCHECK(java_lang_Object != NULL); |
| 80 | DCHECK(java_lang_Object->GetSuperClass() == NULL); |
| 81 | return (component_type_ == java_lang_Object); |
| 82 | } |
| 83 | |
| 84 | bool Class::IsAssignableFromArray(const Class* klass) const { |
| 85 | DCHECK(!IsInterface()); // handled first in IsAssignableFrom |
| 86 | DCHECK(klass->IsArray()); |
| 87 | if (!IsArray()) { |
| 88 | // If "this" is not also an array, it must be Object. |
| 89 | // klass's super should be java_lang_Object, since it is an array. |
| 90 | Class* java_lang_Object = klass->GetSuperClass(); |
| 91 | DCHECK(java_lang_Object != NULL); |
| 92 | DCHECK(java_lang_Object->GetSuperClass() == NULL); |
| 93 | return this == java_lang_Object; |
| 94 | } |
| 95 | return IsArrayAssignableFromArray(klass); |
| 96 | } |
| 97 | |
| 98 | bool Class::IsSubClass(const Class* klass) const { |
| 99 | DCHECK(!IsInterface()); |
| 100 | DCHECK(!klass->IsArray()); |
| 101 | const Class* current = this; |
| 102 | do { |
| 103 | if (current == klass) { |
| 104 | return true; |
| 105 | } |
| 106 | current = current->GetSuperClass(); |
| 107 | } while (current != NULL); |
| 108 | return false; |
| 109 | } |
| 110 | |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 111 | bool Class::IsInSamePackage(const String* descriptor_string_1, |
| 112 | const String* descriptor_string_2) { |
| 113 | const std::string descriptor1(descriptor_string_1->ToModifiedUtf8()); |
| 114 | const std::string descriptor2(descriptor_string_2->ToModifiedUtf8()); |
| 115 | |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 116 | size_t i = 0; |
| 117 | while (descriptor1[i] != '\0' && descriptor1[i] == descriptor2[i]) { |
| 118 | ++i; |
| 119 | } |
Brian Carlstrom | 6cc1845 | 2011-07-18 15:10:33 -0700 | [diff] [blame] | 120 | if (descriptor1.find('/', i) != StringPiece::npos || |
| 121 | descriptor2.find('/', i) != StringPiece::npos) { |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 122 | return false; |
| 123 | } else { |
| 124 | return true; |
| 125 | } |
| 126 | } |
| 127 | |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 128 | #if 0 |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 129 | bool Class::IsInSamePackage(const StringPiece& descriptor1, |
| 130 | const StringPiece& descriptor2) { |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 131 | size_t size = std::min(descriptor1.size(), descriptor2.size()); |
Brian Carlstrom | 6cc1845 | 2011-07-18 15:10:33 -0700 | [diff] [blame] | 132 | std::pair<StringPiece::const_iterator, StringPiece::const_iterator> pos; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 133 | pos = std::mismatch(descriptor1.begin(), descriptor1.begin() + size, |
| 134 | descriptor2.begin()); |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 135 | return !(*(pos.second).rfind('/') != npos && descriptor2.rfind('/') != npos); |
| 136 | } |
| 137 | #endif |
| 138 | |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 139 | bool Class::IsInSamePackage(const Class* that) const { |
| 140 | const Class* klass1 = this; |
| 141 | const Class* klass2 = that; |
| 142 | if (klass1 == klass2) { |
| 143 | return true; |
| 144 | } |
| 145 | // Class loaders must match. |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 146 | if (klass1->GetClassLoader() != klass2->GetClassLoader()) { |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 147 | return false; |
| 148 | } |
| 149 | // Arrays are in the same package when their element classes are. |
| 150 | if (klass1->IsArray()) { |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 151 | klass1 = klass1->GetComponentType(); |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 152 | } |
| 153 | if (klass2->IsArray()) { |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 154 | klass2 = klass2->GetComponentType(); |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 155 | } |
| 156 | // Compare the package part of the descriptor string. |
Brian Carlstrom | 6cc1845 | 2011-07-18 15:10:33 -0700 | [diff] [blame] | 157 | return IsInSamePackage(klass1->descriptor_, klass2->descriptor_); |
Carl Shapiro | 894d0fa | 2011-06-30 14:48:49 -0700 | [diff] [blame] | 158 | } |
| 159 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 160 | bool Field::GetBoolean() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 161 | CHECK_EQ(GetType(), 'Z'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 162 | CHECK(IsStatic()); |
| 163 | return declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 164 | } |
| 165 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 166 | void Field::SetBoolean(bool z) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 167 | CHECK_EQ(GetType(), 'Z'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 168 | CHECK(IsStatic()); |
| 169 | declaring_class_->static_32bit_primitives_->Set(offset_, z); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 170 | } |
| 171 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 172 | int8_t Field::GetByte() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 173 | CHECK_EQ(GetType(), 'B'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 174 | CHECK(IsStatic()); |
| 175 | return declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 176 | } |
| 177 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 178 | void Field::SetByte(int8_t b) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 179 | CHECK_EQ(GetType(), 'B'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 180 | CHECK(IsStatic()); |
| 181 | declaring_class_->static_32bit_primitives_->Set(offset_, b); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 182 | } |
| 183 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 184 | uint16_t Field::GetChar() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 185 | CHECK_EQ(GetType(), 'C'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 186 | CHECK(IsStatic()); |
| 187 | return declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 188 | } |
| 189 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 190 | void Field::SetChar(uint16_t c) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 191 | CHECK_EQ(GetType(), 'C'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 192 | CHECK(IsStatic()); |
| 193 | declaring_class_->static_32bit_primitives_->Set(offset_, c); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 194 | } |
| 195 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 196 | uint16_t Field::GetShort() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 197 | CHECK_EQ(GetType(), 'S'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 198 | CHECK(IsStatic()); |
| 199 | return declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 200 | } |
| 201 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 202 | void Field::SetShort(uint16_t s) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 203 | CHECK_EQ(GetType(), 'S'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 204 | CHECK(IsStatic()); |
| 205 | declaring_class_->static_32bit_primitives_->Set(offset_, s); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 206 | } |
| 207 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 208 | int32_t Field::GetInt() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 209 | CHECK_EQ(GetType(), 'I'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 210 | CHECK(IsStatic()); |
| 211 | return declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 212 | } |
| 213 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 214 | void Field::SetInt(int32_t i) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 215 | CHECK_EQ(GetType(), 'I'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 216 | CHECK(IsStatic()); |
| 217 | declaring_class_->static_32bit_primitives_->Set(offset_, i); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 218 | } |
| 219 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 220 | int64_t Field::GetLong() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 221 | CHECK_EQ(GetType(), 'J'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 222 | CHECK(IsStatic()); |
| 223 | return declaring_class_->static_64bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 224 | } |
| 225 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 226 | void Field::SetLong(int64_t j) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 227 | CHECK_EQ(GetType(), 'J'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 228 | CHECK(IsStatic()); |
| 229 | declaring_class_->static_64bit_primitives_->Set(offset_, j); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 230 | } |
| 231 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 232 | float Field::GetFloat() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 233 | CHECK_EQ(GetType(), 'F'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 234 | CHECK(IsStatic()); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 235 | JValue float_bits; |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 236 | float_bits.i = declaring_class_->static_32bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 237 | return float_bits.f; |
| 238 | } |
| 239 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 240 | void Field::SetFloat(float f) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 241 | CHECK_EQ(GetType(), 'F'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 242 | CHECK(IsStatic()); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 243 | JValue float_bits; |
| 244 | float_bits.f = f; |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 245 | declaring_class_->static_32bit_primitives_->Set(offset_, float_bits.i); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 246 | } |
| 247 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 248 | double Field::GetDouble() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 249 | CHECK_EQ(GetType(), 'D'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 250 | CHECK(IsStatic()); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 251 | JValue double_bits; |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 252 | double_bits.j = declaring_class_->static_64bit_primitives_->Get(offset_); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 253 | return double_bits.d; |
| 254 | } |
| 255 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 256 | void Field::SetDouble(double d) { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 257 | CHECK_EQ(GetType(), 'D'); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 258 | CHECK(IsStatic()); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 259 | JValue double_bits; |
| 260 | double_bits.d = d; |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 261 | declaring_class_->static_64bit_primitives_->Set(offset_, double_bits.j); |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 262 | } |
| 263 | |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 264 | Object* Field::GetObject() { |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 265 | CHECK(GetType() == 'L' || GetType() == '['); |
Jesse Wilson | 35baaab | 2011-08-10 16:18:03 -0400 | [diff] [blame] | 266 | CHECK(IsStatic()); |
| 267 | return declaring_class_->static_references_->Get(offset_); |
| 268 | } |
| 269 | |
| 270 | const Object* Field::GetObject() const { |
| 271 | CHECK(GetType() == 'L' || GetType() == '['); |
| 272 | CHECK(IsStatic()); |
| 273 | return declaring_class_->static_references_->Get(offset_); |
| 274 | } |
| 275 | |
| 276 | void Field::SetObject(Object* l) { |
| 277 | CHECK(GetType() == 'L' || GetType() == '['); |
| 278 | declaring_class_->static_references_->Set(offset_, l); // TODO: write barrier |
Jesse Wilson | 7833bd2 | 2011-08-09 18:31:44 -0400 | [diff] [blame] | 279 | } |
| 280 | |
Carl Shapiro | 3ee755d | 2011-06-28 12:11:04 -0700 | [diff] [blame] | 281 | uint32_t Method::NumArgRegisters() { |
| 282 | CHECK(shorty_ != NULL); |
| 283 | uint32_t num_registers = 0; |
Carl Shapiro | 565f507 | 2011-07-10 13:39:43 -0700 | [diff] [blame] | 284 | for (int i = 1; i < shorty_.length(); ++i) { |
Carl Shapiro | 3ee755d | 2011-06-28 12:11:04 -0700 | [diff] [blame] | 285 | char ch = shorty_[i]; |
| 286 | if (ch == 'D' || ch == 'J') { |
| 287 | num_registers += 2; |
| 288 | } else { |
| 289 | num_registers += 1; |
| 290 | } |
| 291 | } |
| 292 | return num_registers; |
| 293 | } |
| 294 | |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 295 | size_t Method::NumArgArrayBytes() { |
| 296 | const StringPiece& shorty = GetShorty(); |
| 297 | size_t num_bytes = 0; |
| 298 | for (int i = 1; i < shorty.size(); ++i) { |
| 299 | char ch = shorty[i]; |
| 300 | if (ch == 'D' || ch == 'J') { |
| 301 | num_bytes += 8; |
Carl Shapiro | 84d00e6 | 2011-08-18 14:57:20 -0700 | [diff] [blame] | 302 | } else if (ch == 'L') { |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 303 | // Argument is a reference or an array. The shorty descriptor |
| 304 | // does not distinguish between these types. |
| 305 | num_bytes += sizeof(Object*); |
| 306 | } else { |
| 307 | num_bytes += 4; |
| 308 | } |
| 309 | } |
| 310 | return num_bytes; |
| 311 | } |
| 312 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 313 | // The number of reference arguments to this method including implicit this |
| 314 | // pointer |
| 315 | size_t Method::NumReferenceArgs() const { |
Shih-wei Liao | 5381cf9 | 2011-07-27 00:28:04 -0700 | [diff] [blame] | 316 | size_t result = IsStatic() ? 0 : 1; // The implicit this pointer. |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 317 | for (int i = 1; i < shorty_.length(); i++) { |
| 318 | if ((shorty_[i] == 'L') || (shorty_[i] == '[')) { |
| 319 | result++; |
| 320 | } |
| 321 | } |
| 322 | return result; |
| 323 | } |
| 324 | |
| 325 | // The number of long or double arguments |
| 326 | size_t Method::NumLongOrDoubleArgs() const { |
| 327 | size_t result = 0; |
| 328 | for (int i = 1; i < shorty_.length(); i++) { |
| 329 | if ((shorty_[i] == 'D') || (shorty_[i] == 'J')) { |
| 330 | result++; |
| 331 | } |
| 332 | } |
| 333 | return result; |
| 334 | } |
| 335 | |
| 336 | // The number of reference arguments to this method before the given parameter |
| 337 | // index |
| 338 | size_t Method::NumReferenceArgsBefore(unsigned int param) const { |
| 339 | CHECK_LT(param, NumArgs()); |
| 340 | unsigned int result = IsStatic() ? 0 : 1; |
| 341 | for (unsigned int i = 1; (i < (unsigned int)shorty_.length()) && |
| 342 | (i < (param + 1)); i++) { |
| 343 | if ((shorty_[i] == 'L') || (shorty_[i] == '[')) { |
| 344 | result++; |
| 345 | } |
| 346 | } |
| 347 | return result; |
| 348 | } |
| 349 | |
| 350 | // Is the given method parameter a reference? |
| 351 | bool Method::IsParamAReference(unsigned int param) const { |
| 352 | CHECK_LT(param, NumArgs()); |
| 353 | if (IsStatic()) { |
| 354 | param++; // 0th argument must skip return value at start of the shorty |
| 355 | } else if (param == 0) { |
| 356 | return true; // this argument |
| 357 | } |
| 358 | return ((shorty_[param] == 'L') || (shorty_[param] == '[')); |
| 359 | } |
| 360 | |
| 361 | // Is the given method parameter a long or double? |
| 362 | bool Method::IsParamALongOrDouble(unsigned int param) const { |
| 363 | CHECK_LT(param, NumArgs()); |
| 364 | if (IsStatic()) { |
| 365 | param++; // 0th argument must skip return value at start of the shorty |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 366 | } else if (param == 0) { |
| 367 | return false; // this argument |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 368 | } |
| 369 | return (shorty_[param] == 'J') || (shorty_[param] == 'D'); |
| 370 | } |
| 371 | |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 372 | static size_t ShortyCharToSize(char x) { |
| 373 | switch (x) { |
Ian Rogers | 45a76cb | 2011-07-21 22:00:15 -0700 | [diff] [blame] | 374 | case 'V': return 0; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 375 | case '[': return kPointerSize; |
| 376 | case 'L': return kPointerSize; |
| 377 | case 'D': return 8; |
| 378 | case 'J': return 8; |
| 379 | default: return 4; |
| 380 | } |
| 381 | } |
| 382 | |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 383 | size_t Method::ParamSize(unsigned int param) const { |
| 384 | CHECK_LT(param, NumArgs()); |
| 385 | if (IsStatic()) { |
| 386 | param++; // 0th argument must skip return value at start of the shorty |
| 387 | } else if (param == 0) { |
| 388 | return kPointerSize; // this argument |
| 389 | } |
| 390 | return ShortyCharToSize(shorty_[param]); |
| 391 | } |
| 392 | |
| 393 | size_t Method::ReturnSize() const { |
| 394 | return ShortyCharToSize(shorty_[0]); |
| 395 | } |
| 396 | |
Carl Shapiro | 8860c0e | 2011-08-04 17:36:16 -0700 | [diff] [blame] | 397 | bool Method::HasSameNameAndDescriptor(const Method* that) const { |
| 398 | return (this->GetName()->Equals(that->GetName()) && |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 399 | this->GetSignature()->Equals(that->GetSignature())); |
Carl Shapiro | 8860c0e | 2011-08-04 17:36:16 -0700 | [diff] [blame] | 400 | } |
| 401 | |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 402 | Method* Class::FindDeclaredDirectMethod(const StringPiece& name, |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 403 | const StringPiece& signature) { |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 404 | for (size_t i = 0; i < NumDirectMethods(); ++i) { |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 405 | Method* method = GetDirectMethod(i); |
Carl Shapiro | 8860c0e | 2011-08-04 17:36:16 -0700 | [diff] [blame] | 406 | if (method->GetName()->Equals(name) && |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 407 | method->GetSignature()->Equals(signature)) { |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 408 | return method; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 409 | } |
| 410 | } |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 411 | return NULL; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 412 | } |
| 413 | |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 414 | Method* Class::FindDirectMethod(const StringPiece& name, |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 415 | const StringPiece& signature) { |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 416 | for (Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) { |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 417 | Method* method = klass->FindDeclaredDirectMethod(name, signature); |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 418 | if (method != NULL) { |
| 419 | return method; |
| 420 | } |
| 421 | } |
| 422 | return NULL; |
| 423 | } |
| 424 | |
| 425 | Method* Class::FindDeclaredVirtualMethod(const StringPiece& name, |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 426 | const StringPiece& signature) { |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 427 | for (size_t i = 0; i < NumVirtualMethods(); ++i) { |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 428 | Method* method = GetVirtualMethod(i); |
Carl Shapiro | 8860c0e | 2011-08-04 17:36:16 -0700 | [diff] [blame] | 429 | if (method->GetName()->Equals(name) && |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 430 | method->GetSignature()->Equals(signature)) { |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 431 | return method; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 432 | } |
| 433 | } |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 434 | return NULL; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 435 | } |
| 436 | |
Carl Shapiro | 419ec7b | 2011-08-03 14:48:33 -0700 | [diff] [blame] | 437 | Method* Class::FindVirtualMethod(const StringPiece& name, |
| 438 | const StringPiece& descriptor) { |
| 439 | for (Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) { |
| 440 | Method* method = klass->FindDeclaredVirtualMethod(name, descriptor); |
| 441 | if (method != NULL) { |
| 442 | return method; |
| 443 | } |
| 444 | } |
| 445 | return NULL; |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 446 | } |
| 447 | |
Elliott Hughes | cdf5312 | 2011-08-19 15:46:09 -0700 | [diff] [blame] | 448 | Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& descriptor) { |
| 449 | // Is the field in this class? |
| 450 | // Interfaces are not relevant because they can't contain instance fields. |
| 451 | for (size_t i = 0; i < NumInstanceFields(); ++i) { |
| 452 | Field* f = GetInstanceField(i); |
| 453 | if (f->GetName()->Equals(name) && f->GetDescriptor() == descriptor) { |
| 454 | return f; |
| 455 | } |
| 456 | } |
| 457 | return NULL; |
| 458 | } |
| 459 | |
| 460 | Field* Class::FindInstanceField(const StringPiece& name, const StringPiece& descriptor) { |
| 461 | // Is the field in this class, or any of its superclasses? |
| 462 | // Interfaces are not relevant because they can't contain instance fields. |
| 463 | for (Class* c = this; c != NULL; c = c->GetSuperClass()) { |
| 464 | Field* f = c->FindDeclaredInstanceField(name, descriptor); |
| 465 | if (f != NULL) { |
| 466 | return f; |
| 467 | } |
| 468 | } |
| 469 | return NULL; |
| 470 | } |
| 471 | |
| 472 | Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& descriptor) { |
| 473 | for (size_t i = 0; i < NumStaticFields(); ++i) { |
| 474 | Field* f = GetStaticField(i); |
| 475 | if (f->GetName()->Equals(name) && f->GetDescriptor() == descriptor) { |
| 476 | return f; |
| 477 | } |
| 478 | } |
| 479 | return NULL; |
| 480 | } |
| 481 | |
| 482 | Field* Class::FindStaticField(const StringPiece& name, const StringPiece& descriptor) { |
| 483 | // Is the field in this class (or its interfaces), or any of its |
| 484 | // superclasses (or their interfaces)? |
| 485 | for (Class* c = this; c != NULL; c = c->GetSuperClass()) { |
| 486 | // Is the field in this class? |
| 487 | Field* f = c->FindDeclaredStaticField(name, descriptor); |
| 488 | if (f != NULL) { |
| 489 | return f; |
| 490 | } |
| 491 | |
| 492 | // Is this field in any of this class' interfaces? |
| 493 | for (size_t i = 0; i < c->NumInterfaces(); ++i) { |
| 494 | Class* interface = c->GetInterface(i); |
| 495 | f = interface->FindDeclaredStaticField(name, descriptor); |
| 496 | if (f != NULL) { |
| 497 | return f; |
| 498 | } |
| 499 | } |
| 500 | } |
| 501 | return NULL; |
| 502 | } |
| 503 | |
Elliott Hughes | d8ddfd5 | 2011-08-15 14:32:53 -0700 | [diff] [blame] | 504 | template<typename T> |
| 505 | PrimitiveArray<T>* PrimitiveArray<T>::Alloc(size_t length) { |
| 506 | Array* raw_array = Array::Alloc(array_class_, length, sizeof(T)); |
| 507 | return down_cast<PrimitiveArray<T>*>(raw_array); |
| 508 | } |
| 509 | |
| 510 | template <typename T> Class* PrimitiveArray<T>::array_class_ = NULL; |
| 511 | |
| 512 | // Explicitly instantiate all the primitive array types. |
| 513 | template class PrimitiveArray<uint8_t>; // BooleanArray |
| 514 | template class PrimitiveArray<int8_t>; // ByteArray |
| 515 | template class PrimitiveArray<uint16_t>; // CharArray |
| 516 | template class PrimitiveArray<double>; // DoubleArray |
| 517 | template class PrimitiveArray<float>; // FloatArray |
| 518 | template class PrimitiveArray<int32_t>; // IntArray |
| 519 | template class PrimitiveArray<int64_t>; // LongArray |
| 520 | template class PrimitiveArray<int16_t>; // ShortArray |
| 521 | |
Jesse Wilson | f7e85a5 | 2011-08-01 18:45:58 -0700 | [diff] [blame] | 522 | // TODO: get global references for these |
| 523 | Class* String::java_lang_String_ = NULL; |
Jesse Wilson | f7e85a5 | 2011-08-01 18:45:58 -0700 | [diff] [blame] | 524 | |
Brian Carlstrom | 9cff8e1 | 2011-08-18 16:47:29 -0700 | [diff] [blame^] | 525 | void String::InitClass(Class* java_lang_String) { |
Jesse Wilson | f7e85a5 | 2011-08-01 18:45:58 -0700 | [diff] [blame] | 526 | java_lang_String_ = java_lang_String; |
Jesse Wilson | f7e85a5 | 2011-08-01 18:45:58 -0700 | [diff] [blame] | 527 | } |
| 528 | |
Elliott Hughes | 1f359b0 | 2011-07-17 14:27:17 -0700 | [diff] [blame] | 529 | static const char* kClassStatusNames[] = { |
| 530 | "Error", |
| 531 | "NotReady", |
| 532 | "Idx", |
| 533 | "Loaded", |
| 534 | "Resolved", |
| 535 | "Verifying", |
| 536 | "Verified", |
| 537 | "Initializing", |
| 538 | "Initialized" |
| 539 | }; |
| 540 | std::ostream& operator<<(std::ostream& os, const Class::Status& rhs) { |
| 541 | if (rhs >= Class::kStatusError && rhs <= Class::kStatusInitialized) { |
Brian Carlstrom | ae3ac01 | 2011-07-27 01:30:28 -0700 | [diff] [blame] | 542 | os << kClassStatusNames[rhs + 1]; |
Elliott Hughes | 1f359b0 | 2011-07-17 14:27:17 -0700 | [diff] [blame] | 543 | } else { |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 544 | os << "Class::Status[" << static_cast<int>(rhs) << "]"; |
Elliott Hughes | 1f359b0 | 2011-07-17 14:27:17 -0700 | [diff] [blame] | 545 | } |
| 546 | return os; |
| 547 | } |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 548 | |
Carl Shapiro | 3ee755d | 2011-06-28 12:11:04 -0700 | [diff] [blame] | 549 | } // namespace art |