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 "compiled_method.h"
18 
19 #include "driver/compiled_method_storage.h"
20 #include "driver/compiler_driver.h"
21 #include "utils/swap_space.h"
22 
23 namespace art {
24 
CompiledCode(CompilerDriver * compiler_driver,InstructionSet instruction_set,const ArrayRef<const uint8_t> & quick_code)25 CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
26                            const ArrayRef<const uint8_t>& quick_code)
27     : compiler_driver_(compiler_driver),
28       instruction_set_(instruction_set),
29       quick_code_(compiler_driver_->GetCompiledMethodStorage()->DeduplicateCode(quick_code)) {
30 }
31 
~CompiledCode()32 CompiledCode::~CompiledCode() {
33   compiler_driver_->GetCompiledMethodStorage()->ReleaseCode(quick_code_);
34 }
35 
operator ==(const CompiledCode & rhs) const36 bool CompiledCode::operator==(const CompiledCode& rhs) const {
37   if (quick_code_ != nullptr) {
38     if (rhs.quick_code_ == nullptr) {
39       return false;
40     } else if (quick_code_->size() != rhs.quick_code_->size()) {
41       return false;
42     } else {
43       return std::equal(quick_code_->begin(), quick_code_->end(), rhs.quick_code_->begin());
44     }
45   }
46   return (rhs.quick_code_ == nullptr);
47 }
48 
AlignCode(size_t offset) const49 size_t CompiledCode::AlignCode(size_t offset) const {
50   return AlignCode(offset, instruction_set_);
51 }
52 
AlignCode(size_t offset,InstructionSet instruction_set)53 size_t CompiledCode::AlignCode(size_t offset, InstructionSet instruction_set) {
54   return RoundUp(offset, GetInstructionSetAlignment(instruction_set));
55 }
56 
CodeDelta() const57 size_t CompiledCode::CodeDelta() const {
58   return CodeDelta(instruction_set_);
59 }
60 
CodeDelta(InstructionSet instruction_set)61 size_t CompiledCode::CodeDelta(InstructionSet instruction_set) {
62   switch (instruction_set) {
63     case kArm:
64     case kArm64:
65     case kMips:
66     case kMips64:
67     case kX86:
68     case kX86_64:
69       return 0;
70     case kThumb2: {
71       // +1 to set the low-order bit so a BLX will switch to Thumb mode
72       return 1;
73     }
74     default:
75       LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
76       return 0;
77   }
78 }
79 
CodePointer(const void * code_pointer,InstructionSet instruction_set)80 const void* CompiledCode::CodePointer(const void* code_pointer,
81                                       InstructionSet instruction_set) {
82   switch (instruction_set) {
83     case kArm:
84     case kArm64:
85     case kMips:
86     case kMips64:
87     case kX86:
88     case kX86_64:
89       return code_pointer;
90     case kThumb2: {
91       uintptr_t address = reinterpret_cast<uintptr_t>(code_pointer);
92       // Set the low-order bit so a BLX will switch to Thumb mode
93       address |= 0x1;
94       return reinterpret_cast<const void*>(address);
95     }
96     default:
97       LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
98       return nullptr;
99   }
100 }
101 
CompiledMethod(CompilerDriver * driver,InstructionSet instruction_set,const ArrayRef<const uint8_t> & quick_code,const size_t frame_size_in_bytes,const uint32_t core_spill_mask,const uint32_t fp_spill_mask,const ArrayRef<const uint8_t> & method_info,const ArrayRef<const uint8_t> & vmap_table,const ArrayRef<const uint8_t> & cfi_info,const ArrayRef<const LinkerPatch> & patches)102 CompiledMethod::CompiledMethod(CompilerDriver* driver,
103                                InstructionSet instruction_set,
104                                const ArrayRef<const uint8_t>& quick_code,
105                                const size_t frame_size_in_bytes,
106                                const uint32_t core_spill_mask,
107                                const uint32_t fp_spill_mask,
108                                const ArrayRef<const uint8_t>& method_info,
109                                const ArrayRef<const uint8_t>& vmap_table,
110                                const ArrayRef<const uint8_t>& cfi_info,
111                                const ArrayRef<const LinkerPatch>& patches)
112     : CompiledCode(driver, instruction_set, quick_code),
113       frame_size_in_bytes_(frame_size_in_bytes),
114       core_spill_mask_(core_spill_mask),
115       fp_spill_mask_(fp_spill_mask),
116       method_info_(driver->GetCompiledMethodStorage()->DeduplicateMethodInfo(method_info)),
117       vmap_table_(driver->GetCompiledMethodStorage()->DeduplicateVMapTable(vmap_table)),
118       cfi_info_(driver->GetCompiledMethodStorage()->DeduplicateCFIInfo(cfi_info)),
119       patches_(driver->GetCompiledMethodStorage()->DeduplicateLinkerPatches(patches)) {
120 }
121 
SwapAllocCompiledMethod(CompilerDriver * driver,InstructionSet instruction_set,const ArrayRef<const uint8_t> & quick_code,const size_t frame_size_in_bytes,const uint32_t core_spill_mask,const uint32_t fp_spill_mask,const ArrayRef<const uint8_t> & method_info,const ArrayRef<const uint8_t> & vmap_table,const ArrayRef<const uint8_t> & cfi_info,const ArrayRef<const LinkerPatch> & patches)122 CompiledMethod* CompiledMethod::SwapAllocCompiledMethod(
123     CompilerDriver* driver,
124     InstructionSet instruction_set,
125     const ArrayRef<const uint8_t>& quick_code,
126     const size_t frame_size_in_bytes,
127     const uint32_t core_spill_mask,
128     const uint32_t fp_spill_mask,
129     const ArrayRef<const uint8_t>& method_info,
130     const ArrayRef<const uint8_t>& vmap_table,
131     const ArrayRef<const uint8_t>& cfi_info,
132     const ArrayRef<const LinkerPatch>& patches) {
133   SwapAllocator<CompiledMethod> alloc(driver->GetCompiledMethodStorage()->GetSwapSpaceAllocator());
134   CompiledMethod* ret = alloc.allocate(1);
135   alloc.construct(ret,
136                   driver,
137                   instruction_set,
138                   quick_code,
139                   frame_size_in_bytes,
140                   core_spill_mask,
141                   fp_spill_mask,
142                   method_info,
143                   vmap_table,
144                   cfi_info, patches);
145   return ret;
146 }
147 
ReleaseSwapAllocatedCompiledMethod(CompilerDriver * driver,CompiledMethod * m)148 void CompiledMethod::ReleaseSwapAllocatedCompiledMethod(CompilerDriver* driver, CompiledMethod* m) {
149   SwapAllocator<CompiledMethod> alloc(driver->GetCompiledMethodStorage()->GetSwapSpaceAllocator());
150   alloc.destroy(m);
151   alloc.deallocate(m, 1);
152 }
153 
~CompiledMethod()154 CompiledMethod::~CompiledMethod() {
155   CompiledMethodStorage* storage = GetCompilerDriver()->GetCompiledMethodStorage();
156   storage->ReleaseLinkerPatches(patches_);
157   storage->ReleaseCFIInfo(cfi_info_);
158   storage->ReleaseVMapTable(vmap_table_);
159   storage->ReleaseMethodInfo(method_info_);
160 }
161 
162 }  // namespace art
163