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#ifndef ART_RUNTIME_OAT_H_
18#define ART_RUNTIME_OAT_H_
19
20#include <vector>
21
22#include "base/macros.h"
23#include "dex_file.h"
24#include "instruction_set.h"
25#include "quick/quick_method_frame_info.h"
26#include "safe_map.h"
27
28namespace art {
29
30class PACKED(4) OatHeader {
31 public:
32  static const uint8_t kOatMagic[4];
33  static const uint8_t kOatVersion[4];
34
35  static constexpr const char* kImageLocationKey = "image-location";
36  static constexpr const char* kDex2OatCmdLineKey = "dex2oat-cmdline";
37  static constexpr const char* kDex2OatHostKey = "dex2oat-host";
38
39  static OatHeader* Create(InstructionSet instruction_set,
40                           const InstructionSetFeatures& instruction_set_features,
41                           const std::vector<const DexFile*>* dex_files,
42                           uint32_t image_file_location_oat_checksum,
43                           uint32_t image_file_location_oat_data_begin,
44                           const SafeMap<std::string, std::string>* variable_data);
45
46  bool IsValid() const;
47  const char* GetMagic() const;
48  uint32_t GetChecksum() const;
49  void UpdateChecksum(const void* data, size_t length);
50  uint32_t GetDexFileCount() const {
51    DCHECK(IsValid());
52    return dex_file_count_;
53  }
54  uint32_t GetExecutableOffset() const;
55  void SetExecutableOffset(uint32_t executable_offset);
56
57  const void* GetInterpreterToInterpreterBridge() const;
58  uint32_t GetInterpreterToInterpreterBridgeOffset() const;
59  void SetInterpreterToInterpreterBridgeOffset(uint32_t offset);
60  const void* GetInterpreterToCompiledCodeBridge() const;
61  uint32_t GetInterpreterToCompiledCodeBridgeOffset() const;
62  void SetInterpreterToCompiledCodeBridgeOffset(uint32_t offset);
63
64  const void* GetJniDlsymLookup() const;
65  uint32_t GetJniDlsymLookupOffset() const;
66  void SetJniDlsymLookupOffset(uint32_t offset);
67
68  const void* GetPortableResolutionTrampoline() const;
69  uint32_t GetPortableResolutionTrampolineOffset() const;
70  void SetPortableResolutionTrampolineOffset(uint32_t offset);
71  const void* GetPortableImtConflictTrampoline() const;
72  uint32_t GetPortableImtConflictTrampolineOffset() const;
73  void SetPortableImtConflictTrampolineOffset(uint32_t offset);
74  const void* GetPortableToInterpreterBridge() const;
75  uint32_t GetPortableToInterpreterBridgeOffset() const;
76  void SetPortableToInterpreterBridgeOffset(uint32_t offset);
77
78  const void* GetQuickGenericJniTrampoline() const;
79  uint32_t GetQuickGenericJniTrampolineOffset() const;
80  void SetQuickGenericJniTrampolineOffset(uint32_t offset);
81  const void* GetQuickResolutionTrampoline() const;
82  uint32_t GetQuickResolutionTrampolineOffset() const;
83  void SetQuickResolutionTrampolineOffset(uint32_t offset);
84  const void* GetQuickImtConflictTrampoline() const;
85  uint32_t GetQuickImtConflictTrampolineOffset() const;
86  void SetQuickImtConflictTrampolineOffset(uint32_t offset);
87  const void* GetQuickToInterpreterBridge() const;
88  uint32_t GetQuickToInterpreterBridgeOffset() const;
89  void SetQuickToInterpreterBridgeOffset(uint32_t offset);
90
91  int32_t GetImagePatchDelta() const;
92  void RelocateOat(off_t delta);
93  void SetImagePatchDelta(int32_t off);
94
95  InstructionSet GetInstructionSet() const;
96  const InstructionSetFeatures& GetInstructionSetFeatures() const;
97  uint32_t GetImageFileLocationOatChecksum() const;
98  uint32_t GetImageFileLocationOatDataBegin() const;
99
100  uint32_t GetKeyValueStoreSize() const;
101  const uint8_t* GetKeyValueStore() const;
102  const char* GetStoreValueByKey(const char* key) const;
103  bool GetStoreKeyValuePairByIndex(size_t index, const char** key, const char** value) const;
104
105  size_t GetHeaderSize() const;
106
107 private:
108  OatHeader(InstructionSet instruction_set,
109            const InstructionSetFeatures& instruction_set_features,
110            const std::vector<const DexFile*>* dex_files,
111            uint32_t image_file_location_oat_checksum,
112            uint32_t image_file_location_oat_data_begin,
113            const SafeMap<std::string, std::string>* variable_data);
114
115  void Flatten(const SafeMap<std::string, std::string>* variable_data);
116
117  uint8_t magic_[4];
118  uint8_t version_[4];
119  uint32_t adler32_checksum_;
120
121  InstructionSet instruction_set_;
122  InstructionSetFeatures instruction_set_features_;
123  uint32_t dex_file_count_;
124  uint32_t executable_offset_;
125  uint32_t interpreter_to_interpreter_bridge_offset_;
126  uint32_t interpreter_to_compiled_code_bridge_offset_;
127  uint32_t jni_dlsym_lookup_offset_;
128  uint32_t portable_imt_conflict_trampoline_offset_;
129  uint32_t portable_resolution_trampoline_offset_;
130  uint32_t portable_to_interpreter_bridge_offset_;
131  uint32_t quick_generic_jni_trampoline_offset_;
132  uint32_t quick_imt_conflict_trampoline_offset_;
133  uint32_t quick_resolution_trampoline_offset_;
134  uint32_t quick_to_interpreter_bridge_offset_;
135
136  // The amount that the image this oat is associated with has been patched.
137  int32_t image_patch_delta_;
138
139  uint32_t image_file_location_oat_checksum_;
140  uint32_t image_file_location_oat_data_begin_;
141
142  uint32_t key_value_store_size_;
143  uint8_t key_value_store_[0];  // note variable width data at end
144
145  DISALLOW_COPY_AND_ASSIGN(OatHeader);
146};
147
148// OatMethodOffsets are currently 5x32-bits=160-bits long, so if we can
149// save even one OatMethodOffsets struct, the more complicated encoding
150// using a bitmap pays for itself since few classes will have 160
151// methods.
152enum OatClassType {
153  kOatClassAllCompiled = 0,   // OatClass is followed by an OatMethodOffsets for each method.
154  kOatClassSomeCompiled = 1,  // A bitmap of which OatMethodOffsets are present follows the OatClass.
155  kOatClassNoneCompiled = 2,  // All methods are interpretted so no OatMethodOffsets are necessary.
156  kOatClassMax = 3,
157};
158
159std::ostream& operator<<(std::ostream& os, const OatClassType& rhs);
160
161class PACKED(4) OatMethodOffsets {
162 public:
163  OatMethodOffsets();
164
165  OatMethodOffsets(uint32_t code_offset,
166                   uint32_t gc_map_offset);
167
168  ~OatMethodOffsets();
169
170  uint32_t code_offset_;
171  uint32_t gc_map_offset_;
172};
173
174// OatQuickMethodHeader precedes the raw code chunk generated by the Quick compiler.
175class PACKED(4) OatQuickMethodHeader {
176 public:
177  OatQuickMethodHeader();
178
179  explicit OatQuickMethodHeader(uint32_t mapping_table_offset, uint32_t vmap_table_offset,
180                                uint32_t frame_size_in_bytes, uint32_t core_spill_mask,
181                                uint32_t fp_spill_mask, uint32_t code_size);
182
183  ~OatQuickMethodHeader();
184
185  // The offset in bytes from the start of the mapping table to the end of the header.
186  uint32_t mapping_table_offset_;
187  // The offset in bytes from the start of the vmap table to the end of the header.
188  uint32_t vmap_table_offset_;
189  // The stack frame information.
190  QuickMethodFrameInfo frame_info_;
191  // The code size in bytes.
192  uint32_t code_size_;
193};
194
195}  // namespace art
196
197#endif  // ART_RUNTIME_OAT_H_
198