include art/build/Android.common.mk
LIBART_COMPILER_SRC_FILES := \
+ arch/arm/final_relocations_arm.cc \
+ arch/arm/entrypoint_trampoline.cc \
compiled_method.cc \
dex/local_value_numbering.cc \
dex/quick/arm/assemble_arm.cc \
dex/ssa_transformation.cc \
driver/compiler_driver.cc \
driver/dex_compilation_unit.cc \
+ final_relocations.cc \
jni/quick/arm/calling_convention_arm.cc \
jni/quick/arm64/calling_convention_arm64.cc \
jni/quick/mips/calling_convention_mips.cc \
--- /dev/null
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "driver/compiler_driver.h"
+
+namespace art {
+ void CompilerDriver::BuildArmEntrypointTrampolineCall(ThreadOffset<4> thread_offset) {
+ // Thumb2 instruction encoding of:
+ // ldr pc,[r9,#offset]
+
+ // TODO: we don't currently have a Thumb2 assembler, when we do use that
+ // in preference to the hand generated code below.
+ uint32_t offset = thread_offset.Uint32Value();
+ uint32_t instruction = 0xf8d0f000 | (9 << 16) | (offset & 0xfff);
+ entrypoint_trampoline_code_.push_back((instruction >> 16) & 0xff);
+ entrypoint_trampoline_code_.push_back((instruction >> 24) & 0xff);
+ entrypoint_trampoline_code_.push_back((instruction >> 0) & 0xff);
+ entrypoint_trampoline_code_.push_back((instruction >> 8) & 0xff);
+ }
+} // namespace art
--- /dev/null
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "arch/arm/final_relocations_arm.h"
+#include "compiled_method.h"
+#include "driver/compiler_driver.h"
+#include "oat_writer.h"
+#include "dex/compiler_ir.h"
+
+namespace art {
+
+void FinalEntrypointRelocationSetArm::Apply(uint8_t* code, const OatWriter* writer,
+ uint32_t address) const {
+ uint32_t island_offset = writer->GetCurrentTrampolineIslandOffset();
+ const bool kDebugPrint = false;
+
+ for (auto& reloc : relocations_) {
+ switch (reloc.type_) {
+ case kRelocationCall: {
+ // Fetch the instruction. This is two 16 bit words. We can't do a 32 bit load
+ // because it's not guaranteed to be 4-byte aligned.
+ uint32_t inst = static_cast<uint32_t>(
+ *reinterpret_cast<uint16_t*>(code + reloc.code_offset_) << 16
+ | *reinterpret_cast<uint16_t*>(code + reloc.code_offset_ + 2));
+
+ // Remove the current offset from the instruction. This is there
+ // to prevent deduplication from wrongly handling this instruction.
+ inst &= ~0x7ff; // Bottom 11 bits.
+
+ // Check that we are trying to relocate a Thumb2 BL instruction.
+ CHECK_EQ(inst, 0xf000d000);
+
+ uint32_t pc = address + reloc.code_offset_ + 4; // Thumb PC is instruction + 4
+
+ // The trampoline target is to a table starting at the island. Each trampoline
+ // entry is 4 bytes long.
+ uint32_t target = island_offset + static_cast<uint32_t>(reloc.value_) * 4;
+ int32_t delta = target - pc;
+
+
+ if (kDebugPrint) {
+ LOG(INFO) << "applying final relocation for island " << island_offset;
+ LOG(INFO) << "pc: " << std::hex << pc << ", target: " << target <<
+ ", reloc.value: " << reloc.value_ << ", delta: " << delta;
+ }
+
+ // Max range for a Thumb2 BL is 16MB. All calls will be to a lower address.
+ const int32_t kMaxRange = -16 * static_cast<int32_t>(MB);
+ CHECK_LT(delta, 0);
+ CHECK_GT(delta, kMaxRange);
+
+ // Modify the instruction using the T1 BL instruction format.
+ // This is equivalent of a R_ARM_THM_CALL ELF relocation.
+ delta >>= 1; // Low bit is implicit.
+ uint32_t signbit = (delta >> 31) & 0x1;
+ uint32_t i1 = (delta >> 22) & 0x1;
+ uint32_t i2 = (delta >> 21) & 0x1;
+ uint32_t imm10 = (delta >> 11) & 0x03ff;
+ uint32_t imm11 = delta & 0x07ff;
+ uint32_t j1 = (i1 ^ signbit) ? 0 : 1;
+ uint32_t j2 = (i2 ^ signbit) ? 0 : 1;
+ uint32_t value = (signbit << 26) | (j1 << 13) | (j2 << 11) | (imm10 << 16) |
+ imm11;
+
+ // Blit the value into the instruction.
+ inst |= value;
+
+ // Write the instruction back. High 16 bits first, little endian format.
+ uint32_t offset = reloc.code_offset_;
+ code[offset+0] = (inst >> 16) & 0xff;
+ code[offset+1] = (inst >> 24) & 0xff;
+ code[offset+2] = (inst >> 0) & 0xff;
+ code[offset+3] = (inst >> 8) & 0xff;
+ break;
+ }
+
+ default:
+ LOG(FATAL) << "Unknown entrypoint relocation type " << reloc.type_;
+ }
+ }
+}
+} // namespace art
--- /dev/null
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_ARCH_ARM_FINAL_RELOCATIONS_ARM_H_
+#define ART_COMPILER_ARCH_ARM_FINAL_RELOCATIONS_ARM_H_
+
+// ARM final relocations
+
+#include "final_relocations.h"
+
+namespace art {
+
+class CompilerDriver;
+struct CompilationUnit;
+
+class FinalEntrypointRelocationSetArm : public FinalEntrypointRelocationSet {
+ public:
+ explicit FinalEntrypointRelocationSetArm(const CompilerDriver* driver) : FinalEntrypointRelocationSet(driver) {}
+ ~FinalEntrypointRelocationSetArm() {}
+
+ void Apply(uint8_t* code, const OatWriter* writer, uint32_t address) const;
+};
+
+} // namespace art
+
+#endif // ART_COMPILER_ARCH_ARM_FINAL_RELOCATIONS_ARM_H_
#include "compiled_method.h"
#include "driver/compiler_driver.h"
+#include "oat_writer.h"
+#include "dex/compiler_ir.h"
namespace art {
CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
- const std::vector<uint8_t>& quick_code)
+ const std::vector<uint8_t>& quick_code,
+ const FinalRelocations* relocs)
: compiler_driver_(compiler_driver), instruction_set_(instruction_set),
- portable_code_(nullptr), quick_code_(nullptr) {
+ portable_code_(nullptr), quick_code_(nullptr), final_relocations_(relocs) {
SetCode(&quick_code, nullptr);
}
CompiledCode::CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
const std::string& elf_object, const std::string& symbol)
: compiler_driver_(compiler_driver), instruction_set_(instruction_set),
- portable_code_(nullptr), quick_code_(nullptr), symbol_(symbol) {
+ portable_code_(nullptr), quick_code_(nullptr), symbol_(symbol), final_relocations_(nullptr) {
CHECK_NE(elf_object.size(), 0U);
CHECK_NE(symbol.size(), 0U);
std::vector<uint8_t> temp_code(elf_object.size());
const std::vector<uint8_t>& mapping_table,
const std::vector<uint8_t>& vmap_table,
const std::vector<uint8_t>& native_gc_map,
- const std::vector<uint8_t>* cfi_info)
- : CompiledCode(&driver, instruction_set, quick_code), frame_size_in_bytes_(frame_size_in_bytes),
+ const std::vector<uint8_t>* cfi_info,
+ const FinalRelocations* relocs)
+ : CompiledCode(&driver, instruction_set, quick_code, relocs), frame_size_in_bytes_(frame_size_in_bytes),
core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask),
mapping_table_(driver.DeduplicateMappingTable(mapping_table)),
vmap_table_(driver.DeduplicateVMapTable(vmap_table)),
const size_t frame_size_in_bytes,
const uint32_t core_spill_mask,
const uint32_t fp_spill_mask)
- : CompiledCode(&driver, instruction_set, code),
+ : CompiledCode(&driver, instruction_set, code, nullptr),
frame_size_in_bytes_(frame_size_in_bytes),
core_spill_mask_(core_spill_mask), fp_spill_mask_(fp_spill_mask),
mapping_table_(driver.DeduplicateMappingTable(std::vector<uint8_t>())),
vmap_table_ = driver.DeduplicateVMapTable(std::vector<uint8_t>());
gc_map_ = driver.DeduplicateGCMap(std::vector<uint8_t>());
}
-
} // namespace art
#include "instruction_set.h"
#include "utils.h"
#include "UniquePtr.h"
+#include "final_relocations.h"
namespace llvm {
class Function;
namespace art {
class CompilerDriver;
+class OatWriter;
class CompiledCode {
public:
// For Quick to supply an code blob
CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
- const std::vector<uint8_t>& quick_code);
+ const std::vector<uint8_t>& quick_code,
+ const FinalRelocations* relocations);
// For Portable to supply an ELF object
CompiledCode(CompilerDriver* compiler_driver, InstructionSet instruction_set,
const std::vector<uint32_t>& GetOatdataOffsetsToCompliledCodeOffset() const;
void AddOatdataOffsetToCompliledCodeOffset(uint32_t offset);
+ // Apply all the final relocations to the quick code sequence.
+ void ApplyFinalRelocations(const OatWriter *writer, uint32_t address) {
+ if (final_relocations_.get() != nullptr) {
+ final_relocations_->Apply(&(*quick_code_)[0], writer, address);
+ }
+ }
+
private:
CompilerDriver* const compiler_driver_;
// OatWriter and then used by the ElfWriter to add relocations so
// that MCLinker can update the values to the location in the linked .so.
std::vector<uint32_t> oatdata_offsets_to_compiled_code_offset_;
+
+ // Set of relocations to apply as the final pass. This happens
+ // only when the the final oat file addresses are known.
+ UniquePtr<const FinalRelocations> final_relocations_;
};
class CompiledMethod : public CompiledCode {
const std::vector<uint8_t>& mapping_table,
const std::vector<uint8_t>& vmap_table,
const std::vector<uint8_t>& native_gc_map,
- const std::vector<uint8_t>* cfi_info);
+ const std::vector<uint8_t>* cfi_info,
+ const FinalRelocations* relocations);
// Constructs a CompiledMethod for the QuickJniCompiler.
CompiledMethod(CompilerDriver& driver,
kFixupT2Branch, // Thumb2 Unconditional branch
kFixupBlx1, // Blx1 (start of Blx1/Blx2 pair).
kFixupBl1, // Bl1 (start of Bl1/Bl2 pair).
+ kFixup2Bl1, // Thumb2 Bl1 (start of Bl1/Bl2 pair).
kFixupAdr, // Adr.
kFixupMovImmLST, // kThumb2MovImm16LST.
kFixupMovImmHST, // kThumb2MovImm16HST.
kFixupAlign4, // Align to 4-byte boundary.
+ kFixupTrampCall, // Call into trampoline for runtime helper.
};
std::ostream& operator<<(std::ostream& os, const FixupKind& kind);
kThumb2LdrdPcRel8, // ldrd rt, rt2, pc +-/1024.
kThumb2LdrdI8, // ldrd rt, rt2, [rn +-/1024].
kThumb2StrdI8, // strd rt, rt2, [rn +-/1024].
+ kThumb2BlTramp, // Thumb2 BL to trampoline
kArmLast,
};
kFmtBitBlt, 7, 0,
IS_QUAD_OP | REG_USE0 | REG_USE1 | REG_USE2 | IS_STORE,
"strd", "!0C, !1C, [!2C, #!3E]", 4, kFixupNone),
+ ENCODING_MAP(kThumb2BlTramp, 0xf000d000,
+ kFmtBitBlt, 10, 0, kFmtUnused, -1, -1, kFmtUnused, -1, -1,
+ kFmtUnused, -1, -1,
+ IS_UNARY_OP | IS_BRANCH | REG_DEF_LR | NEEDS_FIXUP,
+ "bl", "!0t", 4, kFixupTrampCall),
};
// new_lir replaces orig_lir in the pcrel_fixup list.
while (true) {
offset_adjustment = 0;
AssemblerStatus res = kSuccess; // Assume success
+
generation ^= 1;
// Note: nodes requring possible fixup linked in ascending order.
lir = first_fixup_;
}
break;
}
+ case kFixupTrampCall: {
+ // This is a call to a trampoline. The value for the trampoline call needs
+ // both the offset into the code and the trampoline to call. It will be
+ // added to the list of calls when we actually insert this instruction into
+ // the code_buffer (when we have a stable instruction stream).
+ uint32_t instoffset = lir->offset;
+ // LOG(INFO) << "adding trampoline call: offset: " << instoffset <<
+ // " entrypoint: " << lir->operands[0];
+ trampoline_calls_.push_back(TrampolineCall(instoffset, lir->operands[0]));
+ break;
+ }
default:
LOG(FATAL) << "Unexpected case " << lir->flags.fixup;
}
starting_offset += offset_adjustment;
data_offset_ = (starting_offset + 0x3) & ~0x3;
AssignDataOffsets();
+ trampoline_calls_.clear(); // These are invalid now.
}
}
total_size_ = AssignFillArrayDataOffset(offset);
}
-
} // namespace art
#include "arm_lir.h"
#include "codegen_arm.h"
#include "dex/quick/mir_to_lir-inl.h"
+#include "driver/compiler_options.h"
#include "entrypoints/quick/quick_entrypoints.h"
namespace art {
NewLIR1(kThumbBx, rARM_LR);
}
+// Entrypoint calls.
+RegStorage ArmMir2Lir::CallHelperSetup(ThreadOffset<4> helper_offset) {
+ const CompilerOptions& compiler_options = cu_->compiler_driver->GetCompilerOptions();
+ if (compiler_options.GenerateHelperTrampolines()) {
+ return RegStorage::InvalidReg();
+ } else {
+ return LoadHelper(helper_offset);
+ }
+}
+
+LIR* ArmMir2Lir::CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc,
+ bool use_link) {
+ LIR* call_inst = nullptr;
+ if (use_link) {
+ const CompilerOptions& compiler_options = cu_->compiler_driver->GetCompilerOptions();
+ if (compiler_options.GenerateHelperTrampolines()) {
+ call_inst = OpThreadMem(kOpBlx, helper_offset);
+ } else {
+ call_inst = OpReg(kOpBlx, r_tgt);
+ FreeTemp(r_tgt);
+ }
+ } else {
+ call_inst = OpReg(kOpBx, r_tgt);
+ FreeTemp(r_tgt);
+ }
+ if (safepoint_pc) {
+ MarkSafepointPC(call_inst);
+ }
+ return call_inst;
+}
} // namespace art
bool InexpensiveConstantLong(int64_t value);
bool InexpensiveConstantDouble(int64_t value);
+ // Entrypoint calls.
+ RegStorage CallHelperSetup(ThreadOffset<4> helper_offset);
+ LIR* CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset,
+ bool safepoint_pc, bool use_link);
+
private:
void GenFusedLongCmpImmBranch(BasicBlock* bb, RegLocation rl_src1, int64_t val,
ConditionCode ccode);
}
LIR* ArmMir2Lir::OpThreadMem(OpKind op, ThreadOffset<4> thread_offset) {
- LOG(FATAL) << "Unexpected use of OpThreadMem for Arm";
- return NULL;
+ if (op == kOpBlx) {
+ const uint32_t trampoline = cu_->compiler_driver->AddEntrypointTrampoline(
+ thread_offset.Int32Value());
+ return NewLIR1(kThumb2BlTramp, trampoline);
+ } else {
+ LOG(FATAL) << "Invalid opcode for ARM OpThreadMem on Arm";
+ return NULL;
+ }
}
LIR* ArmMir2Lir::OpMem(OpKind op, RegStorage r_base, int disp) {
vmap_encoder.PushBackUnsigned(0u); // Size is 0.
}
+ // All relocations
+ UniquePtr<FinalRelocations> all_relocs(new FinalRelocations());
+
+ // Build the final relocations for this method.
+ if (trampoline_calls_.size() != 0) {
+ FinalEntrypointRelocationSet* ep_relocs =
+ cu_->compiler_driver->AllocateFinalEntrypointRelocationSet(cu_);
+ for (size_t i = 0 ; i < trampoline_calls_.size(); ++i) {
+ const TrampolineCall& call = trampoline_calls_[i];
+ ep_relocs->Add(call.code_offset_, call.trampoline_offset_);
+ }
+ all_relocs->push_back(ep_relocs);
+ }
+
UniquePtr<std::vector<uint8_t> > cfi_info(ReturnCallFrameInformation());
CompiledMethod* result =
new CompiledMethod(*cu_->compiler_driver, cu_->instruction_set, code_buffer_, frame_size_,
core_spill_mask_, fp_spill_mask_, encoded_mapping_table_,
- vmap_encoder.GetData(), native_gc_map_, cfi_info.get());
+ vmap_encoder.GetData(), native_gc_map_, cfi_info.get(),
+ all_relocs.release());
return result;
}
#include "dex/compiler_internals.h"
#include "dex/quick/arm/arm_lir.h"
#include "dex/quick/mir_to_lir-inl.h"
+#include "driver/compiler_options.h"
#include "entrypoints/quick/quick_entrypoints.h"
#include "mirror/array.h"
#include "mirror/object-inl.h"
void Compile() {
GenerateTargetLabel();
- RegStorage r_tgt = m2l_->CallHelperSetup(QUICK_ENTRYPOINT_OFFSET(4, pResolveString));
+ const CompilerOptions& compiler_options =
+ m2l_->cu_->compiler_driver->GetCompilerOptions();
+ if (compiler_options.GenerateHelperTrampolines()) {
+ m2l_->OpRegCopy(m2l_->TargetReg(kArg0), r_method_);
+ m2l_->CallHelper(RegStorage::InvalidReg(), QUICK_ENTRYPOINT_OFFSET(4, pResolveString),
+ true);
+ } else {
+ RegStorage r_tgt = m2l_->CallHelperSetup(QUICK_ENTRYPOINT_OFFSET(4, pResolveString));
- m2l_->OpRegCopy(m2l_->TargetReg(kArg0), r_method_); // .eq
- LIR* call_inst = m2l_->OpReg(kOpBlx, r_tgt);
- m2l_->MarkSafepointPC(call_inst);
- m2l_->FreeTemp(r_tgt);
+ m2l_->OpRegCopy(m2l_->TargetReg(kArg0), r_method_);
+ LIR* call_inst = m2l_->OpReg(kOpBlx, r_tgt);
+ m2l_->MarkSafepointPC(call_inst);
+ m2l_->FreeTemp(r_tgt);
+ }
m2l_->OpUnconditionalBranch(cont_);
}
#include "dex/quick/dex_file_method_inliner.h"
#include "dex/quick/dex_file_to_method_inliner_map.h"
#include "dex_file-inl.h"
+#include "driver/compiler_options.h"
#include "entrypoints/quick/quick_entrypoints.h"
#include "invoke_type.h"
#include "mirror/array.h"
/*
* To save scheduling time, helper calls are broken into two parts: generation of
- * the helper target address, and the actual call to the helper. Because x86
- * has a memory call operation, part 1 is a NOP for x86. For other targets,
- * load arguments between the two parts.
+ * the helper target address, and the actual call to the helper.
+ * These functions can be overridden by architecture specific codegen.
*/
RegStorage Mir2Lir::CallHelperSetup(ThreadOffset<4> helper_offset) {
- return (cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64) ? RegStorage::InvalidReg() : LoadHelper(helper_offset);
+ return LoadHelper(helper_offset);
}
/* NOTE: if r_tgt is a temp, it will be freed following use */
LIR* Mir2Lir::CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc,
bool use_link) {
- LIR* call_inst;
OpKind op = use_link ? kOpBlx : kOpBx;
- if (cu_->instruction_set == kX86 || cu_->instruction_set == kX86_64) {
- call_inst = OpThreadMem(op, helper_offset);
- } else {
- call_inst = OpReg(op, r_tgt);
- FreeTemp(r_tgt);
- }
+ LIR* call_inst = OpReg(op, r_tgt);
+ FreeTemp(r_tgt);
if (safepoint_pc) {
MarkSafepointPC(call_inst);
}
LIR* const cont_;
};
+ // This holds the data for a call to a trampoline. An instruction is making a call
+ // to something through a trampoline and this holds the offset into the code containing
+ // the instruction, and which trampoline offset to call.
+ struct TrampolineCall {
+ TrampolineCall(uint32_t code_offset, uint32_t trampoline_offset) : code_offset_(code_offset),
+ trampoline_offset_(trampoline_offset) {
+ }
+
+ uint32_t code_offset_; // Offset of instruction in method code stream (bytes).
+ uint32_t trampoline_offset_; // Which trampoline to call.
+ };
+
virtual ~Mir2Lir() {}
int32_t s4FromSwitchData(const void* switch_data) {
virtual void GenConstWide(RegLocation rl_dest, int64_t value);
virtual void GenArithOpInt(Instruction::Code opcode, RegLocation rl_dest,
RegLocation rl_src1, RegLocation rl_src2);
+ virtual LIR* CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc,
+ bool use_link = true);
+ virtual RegStorage CallHelperSetup(ThreadOffset<4> helper_offset);
// Shared by all targets - implemented in gen_invoke.cc.
- LIR* CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc,
- bool use_link = true);
- RegStorage CallHelperSetup(ThreadOffset<4> helper_offset);
void CallRuntimeHelper(ThreadOffset<4> helper_offset, bool safepoint_pc);
void CallRuntimeHelperImm(ThreadOffset<4> helper_offset, int arg0, bool safepoint_pc);
void CallRuntimeHelperReg(ThreadOffset<4> helper_offset, RegStorage arg0, bool safepoint_pc);
LIR* last_lir_insn_;
GrowableArray<LIRSlowPath*> slow_paths_;
+ std::vector<TrampolineCall> trampoline_calls_;
}; // Class Mir2Lir
} // namespace art
NewLIR0(kX86Ret);
}
+RegStorage X86Mir2Lir::CallHelperSetup(ThreadOffset<4> helper_offset) {
+ return RegStorage::InvalidReg();
+}
+
+LIR* X86Mir2Lir::CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset, bool safepoint_pc,
+ bool use_link) {
+ LIR* call_inst = OpThreadMem(use_link ? kOpBlx : kOpBx, helper_offset);
+ if (safepoint_pc) {
+ MarkSafepointPC(call_inst);
+ }
+ return call_inst;
+}
+
+
} // namespace art
*/
std::vector<uint8_t>* ReturnCallFrameInformation();
+ // Entrypoint calls.
+ RegStorage CallHelperSetup(ThreadOffset<4> helper_offset);
+ LIR* CallHelper(RegStorage r_tgt, ThreadOffset<4> helper_offset,
+ bool safepoint_pc, bool use_link);
+
private:
void EmitPrefix(const X86EncodingMap* entry);
void EmitOpcode(const X86EncodingMap* entry);
#include <vector>
#include <unistd.h>
+#include "arch/arm/final_relocations_arm.h"
+#include "base/hex_dump.h"
#include "base/stl_util.h"
#include "base/timing_logger.h"
#include "class_linker.h"
UniquePtr<ThreadPool> thread_pool(new ThreadPool("Compiler driver thread pool", thread_count_ - 1));
PreCompile(class_loader, dex_files, thread_pool.get(), timings);
Compile(class_loader, dex_files, thread_pool.get(), timings);
+ PostCompile();
if (dump_stats_) {
stats_->Dump();
}
UpdateImageClasses(timings);
}
+void CompilerDriver::PostCompile() {
+ BuildEntrypointTrampolineCode();
+}
+
bool CompilerDriver::IsImageClass(const char* descriptor) const {
if (!IsImage()) {
return true;
return result;
}
+uint32_t CompilerDriver::AddEntrypointTrampoline(uint32_t entrypoint) {
+ return entrypoint_trampolines_.AddEntrypoint(Thread::Current(), entrypoint);
+}
+
+
+void CompilerDriver::BuildEntrypointTrampolineCode() {
+ const auto& table = entrypoint_trampolines_.GetTrampolineTable();
+ for (uint32_t offset : table) {
+ switch (instruction_set_) {
+ case kArm:
+ // Intentional fall through.
+ case kThumb2:
+ BuildArmEntrypointTrampolineCall(ThreadOffset<4>(offset));
+ break;
+ default:
+ UNIMPLEMENTED(FATAL) << "No entrypoint trampolines for this architecture";
+ }
+ }
+}
+
+
void CompilerDriver::AddCodePatch(const DexFile* dex_file,
uint16_t referrer_class_def_idx,
uint32_t referrer_method_idx,
}
return !compile;
}
+
+FinalEntrypointRelocationSet* CompilerDriver::AllocateFinalEntrypointRelocationSet(
+ CompilationUnit* cu) const {
+ switch (instruction_set_) {
+ case kArm:
+ case kThumb2:
+ return new FinalEntrypointRelocationSetArm(this);
+ default:
+ UNIMPLEMENTED(FATAL) << "Cannot allocate FinalEntrypointRelocationSet for non-ARM";
+ return nullptr;
+ }
+}
+
} // namespace art
// Should the compiler run on this method given profile information?
bool SkipCompilation(const std::string& method_name);
+ // Entrypoint trampolines.
+ //
+ // The idea here is that we can save code size by collecting the branches
+ // to the entrypoints (helper functions called by the generated code) into a
+ // table and then branching relative to that table from the code. On ARM 32 this
+ // will save 2 bytes per call. Only the entrypoints used by the program (the whole
+ // program - these are global) are in this table and are in no particular order.
+ //
+ // The trampolines will be placed right at the start of the .text section in the file
+ // and will consist of a table of instructions, each of which will branch relative to
+ // the thread register (r9 on ARM) to an entrypoint. On ARM this would look like:
+ //
+ // trampolines:
+ // 1: ldr pc, [r9, #40]
+ // 2: ldr pc, [r9, #8]
+ // ...
+ //
+ // Then a call to an entrypoint would be an immediate BL instruction to the appropriate
+ // label (1 or 2 in the above example). Because the entrypoint table has the lower bit
+ // of the address already set, the ldr pc will switch from ARM to Thumb for the entrypoint as
+ // necessary.
+ //
+ // On ARM, the range of a BL instruction is +-32M to this is more than enough for an
+ // immediate BL instruction in the generated code.
+ //
+ // The actual address of the trampoline for a particular entrypoint is not known until
+ // the OAT file is written and we know the addresses of all the branch instructions in
+ // the program. At this point we can rewrite the BL instruction to have the correct relative
+ // offset.
+ class EntrypointTrampolines {
+ public:
+ EntrypointTrampolines() : current_offset_(0), lock_("Entrypoint Trampolines") {}
+ ~EntrypointTrampolines() {}
+
+ // Add a trampoline and return the offset added. If it already exists
+ // return the offset it was added at previously.
+ uint32_t AddEntrypoint(Thread* self, uint32_t ep) LOCKS_EXCLUDED(lock_) {
+ MutexLock mu(self, lock_);
+ Trampolines::iterator tramp = trampolines_.find(ep);
+ if (tramp == trampolines_.end()) {
+ trampolines_[ep] = current_offset_;
+ trampoline_table_.push_back(ep);
+ LOG(DEBUG) << "adding new trampoline for " << ep << " at offset " << current_offset_;
+ return current_offset_++;
+ } else {
+ return tramp->second;
+ }
+ }
+
+ const std::vector<uint32_t>& GetTrampolineTable() const {
+ return trampoline_table_;
+ }
+
+ uint32_t GetTrampolineTableSize() const {
+ return current_offset_;
+ }
+
+ private:
+ uint32_t current_offset_;
+ // Mapping of entrypoint offset vs offset into trampoline table.
+ typedef std::map<uint32_t, uint32_t> Trampolines;
+ Trampolines trampolines_ GUARDED_BY(lock_);
+
+ // Table of all registered offsets in order of registration.
+ std::vector<uint32_t> trampoline_table_;
+ Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ };
+
+ uint32_t AddEntrypointTrampoline(uint32_t entrypoint);
+
+ const std::vector<uint32_t>& GetEntrypointTrampolineTable() const {
+ return entrypoint_trampolines_.GetTrampolineTable();
+ }
+
+ uint32_t GetEntrypointTrampolineTableSize() const {
+ uint32_t size = entrypoint_trampolines_.GetTrampolineTableSize();
+ switch (instruction_set_) {
+ case kThumb2:
+ case kArm:
+ return size * 4;
+ default:
+ return size;
+ }
+ }
+
+ // Get the maximum offset between entrypoint trampoline islands. Different architectures
+ // have limitations on the max offset for a call instruction. This function is used
+ // to determine when we need to generate a new trampoline island in the output to keep
+ // subsequent calls in range.
+ size_t GetMaxEntrypointTrampolineOffset() const {
+ switch (instruction_set_) {
+ case kThumb2:
+ case kArm:
+ // On Thumb2, the max range of a BL instruction is 16MB. Give it a little wiggle room.
+ return 15*MB;
+ default:
+ // Returning 0 means we won't generate a trampoline island.
+ return 0;
+ }
+ }
+
+ void BuildEntrypointTrampolineCode();
+
+ // Architecture specific Entrypoint trampoline builder.
+ void BuildArmEntrypointTrampolineCall(ThreadOffset<4> offset);
+
+ const std::vector<uint8_t>& GetEntrypointTrampolineTableCode() const {
+ return entrypoint_trampoline_code_;
+ }
+
+ FinalEntrypointRelocationSet* AllocateFinalEntrypointRelocationSet(CompilationUnit* cu) const;
+
private:
// These flags are internal to CompilerDriver for collecting INVOKE resolution statistics.
// The only external contract is that unresolved method has flags 0 and resolved non-0.
LOCKS_EXCLUDED(Locks::mutator_lock_);
void LoadImageClasses(TimingLogger* timings);
+ void PostCompile() LOCKS_EXCLUDED(Locks::mutator_lock_);
// Attempt to resolve all type, methods, fields, and strings
// referenced from code in the dex file following PathClassLoader
DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_gc_map_;
DedupeSet<std::vector<uint8_t>, size_t, DedupeHashFunc, 4> dedupe_cfi_info_;
+ EntrypointTrampolines entrypoint_trampolines_;
+
+ std::vector<uint8_t> entrypoint_trampoline_code_;
+
DISALLOW_COPY_AND_ASSIGN(CompilerDriver);
};
small_method_threshold_(kDefaultSmallMethodThreshold),
tiny_method_threshold_(kDefaultTinyMethodThreshold),
num_dex_methods_threshold_(kDefaultNumDexMethodsThreshold),
- generate_gdb_information_(false)
+ generate_gdb_information_(false),
+ generate_helper_trampolines_(false)
#ifdef ART_SEA_IR_MODE
, sea_ir_mode_(false)
#endif
size_t small_method_threshold,
size_t tiny_method_threshold,
size_t num_dex_methods_threshold,
- bool generate_gdb_information
+ bool generate_gdb_information,
+ bool generate_helper_trampolines
#ifdef ART_SEA_IR_MODE
, bool sea_ir_mode
#endif
small_method_threshold_(small_method_threshold),
tiny_method_threshold_(tiny_method_threshold),
num_dex_methods_threshold_(num_dex_methods_threshold),
- generate_gdb_information_(generate_gdb_information)
+ generate_gdb_information_(generate_gdb_information),
+ generate_helper_trampolines_(generate_helper_trampolines)
#ifdef ART_SEA_IR_MODE
, sea_ir_mode_(sea_ir_mode)
#endif
return generate_gdb_information_;
}
+ bool GenerateHelperTrampolines() const {
+ return generate_helper_trampolines_;
+ }
+
private:
CompilerFilter compiler_filter_;
size_t huge_method_threshold_;
size_t tiny_method_threshold_;
size_t num_dex_methods_threshold_;
bool generate_gdb_information_;
+ bool generate_helper_trampolines_;
#ifdef ART_SEA_IR_MODE
bool sea_ir_mode_;
--- /dev/null
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "final_relocations.h"
+
+namespace art {
+
+class OatWriter;
+
+void FinalRelocations::Apply(uint8_t* code, const OatWriter* writer, uint32_t address) const {
+ for (const auto& s : *this) {
+ s->Apply(code, writer, address);
+ }
+}
+
+void FinalEntrypointRelocationSet::Add(uint32_t offset, uint32_t entrypoint_offset) {
+ relocations_.push_back(Relocation(kRelocationCall, offset, entrypoint_offset));
+}
+} // namespace art
--- /dev/null
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_FINAL_RELOCATIONS_H_
+#define ART_COMPILER_FINAL_RELOCATIONS_H_
+
+#include <string>
+#include <vector>
+#include "base/macros.h"
+
+namespace art {
+
+class CompilerDriver;
+class OatWriter;
+
+enum FinalRelocationType {
+ kRelocationCall // Relocation of a call instruction.
+};
+
+// This is a set of relocations that is performed when the code is finally
+// written to the output file. This is when we know all the offsets and
+// can patch the binary instructions with known PC relative addresses.
+//
+// This is an abstract class that can be used for sets of relocations of different
+// types. For example, one type of relocation set is the relocation of calls
+// to entrypoint trampoline islands. Another type could be intra-app direct
+// method calls. The 'Apply' function is virtual and is implemented by
+// each concrete subclass.
+class FinalRelocationSet {
+ public:
+ explicit FinalRelocationSet(const CompilerDriver* driver) : driver_(driver) {}
+ virtual ~FinalRelocationSet() {}
+
+ void AddRelocation(FinalRelocationType type, uint32_t offset, uintptr_t value) {
+ relocations_.push_back(Relocation(type, offset, value));
+ }
+
+ // Apply this relocation set to the given code.
+ virtual void Apply(uint8_t* code, const OatWriter* writer, uint32_t address) const = 0;
+
+ protected:
+ struct Relocation {
+ Relocation()=delete;
+ Relocation(FinalRelocationType type, uint32_t offset, uintptr_t value) :
+ type_(type), code_offset_(offset), value_(value) {}
+ FinalRelocationType type_;
+ uint32_t code_offset_;
+ uintptr_t value_;
+ };
+
+ const CompilerDriver* const driver_;
+ typedef std::vector<Relocation> Relocations;
+ Relocations relocations_;
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(FinalRelocationSet);
+};
+
+/* abstract. Implemented by architecture-specific subclasses */
+class FinalEntrypointRelocationSet : public FinalRelocationSet {
+ public:
+ explicit FinalEntrypointRelocationSet(const CompilerDriver* driver) : FinalRelocationSet(driver) {
+ }
+ ~FinalEntrypointRelocationSet() {}
+
+ void Add(uint32_t offset, uint32_t entrypoint_offset);
+};
+
+// Holder class for a set of final relocations.
+class FinalRelocations : public std::vector<const FinalRelocationSet*> {
+ public:
+ void Apply(uint8_t* code, const OatWriter* writer, uint32_t address) const;
+};
+} // namespace art
+
+#endif // ART_COMPILER_FINAL_RELOCATIONS_H_
size_oat_class_type_(0),
size_oat_class_status_(0),
size_oat_class_method_bitmaps_(0),
- size_oat_class_method_offsets_(0) {
+ size_oat_class_method_offsets_(0),
+ current_trampoline_island_offset_(0xffffffff) {
size_t offset;
{
TimingLogger::ScopedSplit split("InitOatHeader", timings);
CHECK(quick_code != nullptr);
offset = compiled_method->AlignCode(offset);
DCHECK_ALIGNED(offset, kArmAlignment);
+
+ uint32_t thumb_offset = compiled_method->CodeDelta();
+ uint32_t tramp_offset = offset + thumb_offset;
+
+ // Allocate a trampoline island if we need to.
+ uint32_t trampsize = AllocateTrampolineIslandIfNecessary(tramp_offset);
+ if (trampsize > 0) {
+ offset += trampsize; // Account for island in current offset.
+
+ // Realign code after trampoline island.
+ offset = compiled_method->AlignCode(offset);
+ DCHECK_ALIGNED(offset, kArmAlignment);
+ }
+
uint32_t code_size = quick_code->size() * sizeof(uint8_t);
CHECK_NE(code_size, 0U);
- uint32_t thumb_offset = compiled_method->CodeDelta();
quick_code_offset = offset + sizeof(code_size) + thumb_offset;
std::vector<uint8_t>* cfi_info = compiler_driver_->GetCallFrameInformation();
if (cfi_info != nullptr) {
- // Copy in the FDE, if present
- const std::vector<uint8_t>* fde = compiled_method->GetCFIInfo();
+ // Copy in the FDE, if present
+ const std::vector<uint8_t>* fde = compiled_method->GetCFIInfo();
if (fde != nullptr) {
// Copy the information into cfi_info and then fix the address in the new copy.
int cur_offset = cfi_info->size();
}
}
+
// Deduplicate code arrays
SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator code_iter =
code_offsets_.find(quick_code);
offset += sizeof(code_size); // code size is prepended before code
offset += code_size;
oat_header_->UpdateChecksum(&(*quick_code)[0], code_size);
+
+ // Apply the final relocations to the code now that we
+ // know the offset.
+ compiled_method->ApplyFinalRelocations(this, quick_code_offset);
}
}
+
frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
core_spill_mask = compiled_method->GetCoreSpillMask();
fp_spill_mask = compiled_method->GetFpSpillMask();
DCHECK_OFFSET();
}
DCHECK_ALIGNED(relative_offset, kArmAlignment);
+
+ // Write out a trampoline island if there is one at this point.
+ uint32_t trampsize = WriteTrampolineIslandIfNecessary(out, relative_offset +
+ compiled_method->CodeDelta());
+ if (trampsize > 0) {
+ relative_offset += trampsize;
+ size_code_ += trampsize;
+ DCHECK_OFFSET();
+
+ // Need to realign the code again after the island.
+ uint32_t aligned_offset = compiled_method->AlignCode(relative_offset);
+ uint32_t aligned_code_delta = aligned_offset - relative_offset;
+ if (aligned_code_delta != 0) {
+ off_t new_offset = out->Seek(aligned_code_delta, kSeekCurrent);
+ size_code_alignment_ += aligned_code_delta;
+ uint32_t expected_offset = file_offset + aligned_offset;
+ if (static_cast<uint32_t>(new_offset) != expected_offset) {
+ PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
+ << " Expected: " << expected_offset << " File: " << out->GetLocation();
+ return 0;
+ }
+ relative_offset += aligned_code_delta;
+ DCHECK_OFFSET();
+ }
+ DCHECK_ALIGNED(relative_offset, kArmAlignment);
+ }
+
uint32_t code_size = quick_code->size() * sizeof(uint8_t);
CHECK_NE(code_size, 0U);
// Deduplicate code arrays
size_t code_offset = relative_offset + sizeof(code_size) + compiled_method->CodeDelta();
+
SafeMap<const std::vector<uint8_t>*, uint32_t>::iterator code_iter =
code_offsets_.find(quick_code);
if (code_iter != code_offsets_.end() && code_offset != method_offsets.code_offset_) {
return true;
}
+// Allocate a trampoline island if we need to.
+uint32_t OatWriter::AllocateTrampolineIslandIfNecessary(uint32_t offset) {
+ size_t max_offset = compiler_driver_->GetMaxEntrypointTrampolineOffset();
+ if (max_offset == 0) {
+ // Compiler driver says we don't need trampoline islands.
+ return 0;
+ }
+ uint32_t next_trampoline = current_trampoline_island_offset_ + max_offset;
+ if (current_trampoline_island_offset_ == 0xffffffff || offset >= next_trampoline) {
+ LOG(DEBUG) << "Need trampoline island at offset " << std::hex << offset;
+ uint32_t size = compiler_driver_->GetEntrypointTrampolineTableSize();
+ trampoline_island_offsets_.push_back(offset);
+ current_trampoline_island_offset_ = offset;
+ return size;
+ }
+ return 0;
+}
+
+uint32_t OatWriter::WriteTrampolineIslandIfNecessary(OutputStream* out, uint32_t offset) {
+ for (size_t i = 0; i < trampoline_island_offsets_.size(); ++i) {
+ if (trampoline_island_offsets_[i] == offset) {
+ uint32_t size = compiler_driver_->GetEntrypointTrampolineTableSize();
+ LOG(DEBUG) << "Writing trampoline island at offset " << std::hex << offset << " size: "
+ << std::dec << size;
+ const std::vector<uint8_t>& code = compiler_driver_->GetEntrypointTrampolineTableCode();
+ out->WriteFully(&code[0], size);
+ return size;
+ }
+ }
+ return 0;
+}
+
} // namespace art
return method_info_;
}
+ uint32_t GetCurrentTrampolineIslandOffset() const {
+ return current_trampoline_island_offset_;
+ }
+
private:
size_t InitOatHeader();
size_t InitOatDexFiles(size_t offset);
void ReportWriteFailure(const char* what, uint32_t method_idx, const DexFile& dex_file,
const OutputStream& out) const;
+ uint32_t AllocateTrampolineIslandIfNecessary(uint32_t offset);
+ uint32_t WriteTrampolineIslandIfNecessary(OutputStream* out, uint32_t offset);
+
class OatDexFile {
public:
explicit OatDexFile(size_t offset, const DexFile& dex_file);
SafeMap<const std::vector<uint8_t>*, uint32_t> mapping_table_offsets_;
SafeMap<const std::vector<uint8_t>*, uint32_t> gc_map_offsets_;
+ // The trampoline islands. These are sequences of code inserted between methods
+ // in the output. They contain jumps to other addresses and are accessed
+ // by direct calls in the method code. Due to the range of call instructions
+ // on certain architectures, we need to be able to put down multiple islands that
+ // are in range of the call instructions. On ARM this is done every 15MB (the call range
+ // on Thumb2 is 16MB). At any point in the output we have a current island that is
+ // guaranteed to be in range. This is held in the 'current_trampoline_island_offset'
+ // variable (an offset into the instruction stream).
+ //
+ // The vector 'trampoline_island_offsets' contains the offsets of the all the
+ // islands we have generated. This is used when performing the write of the file.
+
+ uint32_t current_trampoline_island_offset_; // Current island offset.
+ std::vector<uint32_t> trampoline_island_offsets_; // All the island offsets.
+
DISALLOW_COPY_AND_ASSIGN(OatWriter);
};
mapping_table,
vmap_table,
gc_map,
+ nullptr,
nullptr);
}
UsageError(" Use a separate --runtime-arg switch for each argument.");
UsageError(" Example: --runtime-arg -Xms256m");
UsageError("");
- UsageError(" --profile-file=<filename>: specify profiler output file to use for compilation.");
+ UsageError(" --profile-file=<filename>: profile file from a previous run used to determine");
+ UsageError(" whether to compile methods or not.");
+ UsageError("");
+ UsageError(" --no-profile-file: don't use a profile file for compilation.");
+ UsageError("");
+ UsageError(" --no-helper-trampolines: don't use trampolines for calls to ARM helper functions.");
UsageError("");
UsageError(" --print-pass-names: print a list of pass names");
UsageError("");
bool dump_slow_timing = kIsDebugBuild;
bool watch_dog_enabled = !kIsTargetBuild;
bool generate_gdb_information = kIsDebugBuild;
+ bool generate_helper_trampolines = true;
for (int i = 0; i < argc; i++) {
const StringPiece option(argv[i]);
watch_dog_enabled = false;
} else if (option == "--gen-gdb-info") {
generate_gdb_information = true;
+ } else if (option == "--no-helper-trampolines") {
+ generate_helper_trampolines = false;
} else if (option == "--no-gen-gdb-info") {
generate_gdb_information = false;
} else if (option.starts_with("-j")) {
profile_file = option.substr(strlen("--profile-file=")).data();
VLOG(compiler) << "dex2oat: profile file is " << profile_file;
} else if (option == "--no-profile-file") {
- LOG(INFO) << "dex2oat: no profile file supplied (explictly)";
+ LOG(INFO) << "dex2oat: no profile file supplied (explicitly)";
// No profile
} else if (option == "--print-pass-names") {
PassDriver::PrintPassNames();
Usage("Unknown --compiler-filter value %s", compiler_filter_string);
}
+ // TODO: update this code sequence when other platforms support
+ // helper trampoline calls.
+ bool helper_trampolines_available;
+ switch (instruction_set) {
+ case kArm:
+ case kThumb2:
+ helper_trampolines_available = true;
+ break;
+ default:
+ helper_trampolines_available = false;
+ break;
+ }
+
CompilerOptions compiler_options(compiler_filter,
huge_method_threshold,
large_method_threshold,
small_method_threshold,
tiny_method_threshold,
num_dex_methods_threshold,
- generate_gdb_information
+ generate_gdb_information,
+ generate_helper_trampolines && helper_trampolines_available
#ifdef ART_SEA_IR_MODE
, compiler_options.sea_ir_ = true;
#endif
// |332|22|2|2222221111|11|1 |1|1 |10000000000|
// |1 9|87|6|5 0 6|54|3 |2|1 |0 5 0|
// |---|--|-|----------|--|--|-|--|-----------|
- // |111|10|S| imm10 |11|J1|L|J2| imm11 |
+ // |111|10|S| imm10 |11|J1|X|J2| imm11 |
uint32_t S = (instr >> 26) & 1;
uint32_t J2 = (instr >> 11) & 1;
- uint32_t L = (instr >> 12) & 1;
+ uint32_t X = (instr >> 12) & 1;
uint32_t J1 = (instr >> 13) & 1;
uint32_t imm10 = (instr >> 16) & 0x3FF;
uint32_t imm11 = instr & 0x7FF;
- if (L == 0) {
- opcode << "bx";
- } else {
+ if (X == 0) {
+ // This bit is unnamed in spec, but if zero, the instruction
+ // is BLX.
opcode << "blx";
+ } else {
+ opcode << "bl";
}
uint32_t I1 = ~(J1 ^ S);
uint32_t I2 = ~(J2 ^ S);
int32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) | (imm10 << 12) | (imm11 << 1);
imm32 = (imm32 << 8) >> 8; // sign extend 24 bit immediate.
DumpBranchTarget(args, instr_ptr + 4, imm32);
+ if (X == 1) {
+ // For a BL instruction we look and see if it's an entrypoint
+ // trampoline.
+ const uint16_t* target = reinterpret_cast<const uint16_t*>(instr_ptr + 4 + imm32);
+ if (target == nullptr) {
+ // Defensive, will probably never happen.
+ break;
+ }
+ const uint32_t targetinst = static_cast<uint32_t>(*target << 16 | *(target + 1));
+
+ // Is the target instruction an entrypoint trampoline:
+ // ldr pc,[r9,#foo]
+ if ((targetinst & 0xfffff000) == (0xf8d0f000 | (9 << 16))) {
+ uint16_t offset = targetinst & 0xfff;
+ args << " ; ";
+ Thread::DumpThreadOffset<4>(args, offset);
+ }
+ }
break;
}
}
sc->arm_pc = reinterpret_cast<uintptr_t>(art_quick_implicit_suspend);
// Now remove the suspend trigger that caused this fault.
- Thread::Current()->RemoveSuspendTrigger();
- LOG(DEBUG) << "removed suspend trigger invoking test suspend";
+ Thread* thread = reinterpret_cast<Thread*>(sc->arm_r9);
+ DCHECK_EQ(thread, Thread::Current());
+
+ LOG(DEBUG) << "removed suspend trigger invoking test suspend on thread " << thread;
+ thread->RemoveSuspendTrigger();
return true;
}
return false;
namespace art {
const uint8_t OatHeader::kOatMagic[] = { 'o', 'a', 't', '\n' };
-const uint8_t OatHeader::kOatVersion[] = { '0', '2', '0', '\0' };
+const uint8_t OatHeader::kOatVersion[] = { '0', '2', '1', '\0' };
OatHeader::OatHeader() {
memset(this, 0, sizeof(*this));
OSDN Git Service
