Home | History | Annotate | Download | only in runtime 
      1 /*
      2  * Copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "art_field.h"
     18 
     19 #include "art_field-inl.h"
     20 #include "base/utils.h"
     21 #include "class_linker-inl.h"
     22 #include "dex/descriptors_names.h"
     23 #include "gc/accounting/card_table-inl.h"
     24 #include "handle_scope.h"
     25 #include "mirror/class-inl.h"
     26 #include "mirror/object-inl.h"
     27 #include "mirror/object_array-inl.h"
     28 #include "runtime.h"
     29 #include "scoped_thread_state_change-inl.h"
     30 #include "well_known_classes.h"
     31 
     32 namespace art {
     33 
     34 void ArtField::SetOffset(MemberOffset num_bytes) {
     35   DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
     36   if (kIsDebugBuild && Runtime::Current()->IsAotCompiler() &&
     37       Runtime::Current()->IsCompilingBootImage()) {
     38     Primitive::Type type = GetTypeAsPrimitiveType();
     39     if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
     40       DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
     41     }
     42   }
     43   // Not called within a transaction.
     44   offset_ = num_bytes.Uint32Value();
     45 }
     46 
     47 ObjPtr<mirror::Class> ArtField::ProxyFindSystemClass(const char* descriptor) {
     48   DCHECK(GetDeclaringClass()->IsProxyClass());
     49   ObjPtr<mirror::Class> klass = Runtime::Current()->GetClassLinker()->LookupClass(
     50       Thread::Current(), descriptor, /* class_loader */ nullptr);
     51   DCHECK(klass != nullptr);
     52   return klass;
     53 }
     54 
     55 ObjPtr<mirror::String> ArtField::ResolveGetStringName(Thread* self,
     56                                                       dex::StringIndex string_idx,
     57                                                       ObjPtr<mirror::DexCache> dex_cache) {
     58   StackHandleScope<1> hs(self);
     59   return Runtime::Current()->GetClassLinker()->ResolveString(string_idx, hs.NewHandle(dex_cache));
     60 }
     61 
     62 std::string ArtField::PrettyField(ArtField* f, bool with_type) {
     63   if (f == nullptr) {
     64     return "null";
     65   }
     66   return f->PrettyField(with_type);
     67 }
     68 
     69 std::string ArtField::PrettyField(bool with_type) {
     70   std::string result;
     71   if (with_type) {
     72     result += PrettyDescriptor(GetTypeDescriptor());
     73     result += ' ';
     74   }
     75   std::string temp;
     76   result += PrettyDescriptor(GetDeclaringClass()->GetDescriptor(&temp));
     77   result += '.';
     78   result += GetName();
     79   return result;
     80 }
     81 
     82 void ArtField::GetAccessFlagsDCheck() {
     83   CHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
     84 }
     85 
     86 void ArtField::GetOffsetDCheck() {
     87   CHECK(GetDeclaringClass()->IsResolved());
     88 }
     89 
     90 }  // namespace art
     91