diff options
| -rw-r--r-- | compiler/dex/quick/arm/assemble_arm.cc | 6 | ||||
| -rw-r--r-- | compiler/dex/quick/arm/call_arm.cc | 29 | ||||
| -rw-r--r-- | compiler/dex/quick/codegen_util.cc | 7 | ||||
| -rw-r--r-- | compiler/dex/quick/mips/assemble_mips.cc | 2 | ||||
| -rw-r--r-- | compiler/dex/quick/x86/assemble_x86.cc | 2 | ||||
| -rw-r--r-- | compiler/utils/arena_allocator.h | 3 | ||||
| -rw-r--r-- | compiler/utils/scoped_arena_allocator.cc | 2 | ||||
| -rw-r--r-- | compiler/utils/scoped_arena_allocator.h | 2 | ||||
| -rw-r--r-- | runtime/arch/arm/fault_handler_arm.cc | 135 | ||||
| -rw-r--r-- | runtime/arch/arm/quick_entrypoints_arm.S | 25 | ||||
| -rw-r--r-- | runtime/base/logging.h | 1 | ||||
| -rw-r--r-- | runtime/fault_handler.cc | 26 | ||||
| -rw-r--r-- | runtime/interpreter/interpreter.cc | 12 | ||||
| -rw-r--r-- | runtime/parsed_options.cc | 3 | ||||
| -rw-r--r-- | runtime/stack.cc | 58 | ||||
| -rw-r--r-- | runtime/stack.h | 8 | ||||
| -rw-r--r-- | runtime/thread.cc | 15 | ||||
| -rw-r--r-- | runtime/utils.cc | 6 | ||||
| -rw-r--r-- | runtime/verifier/method_verifier.cc | 5 | ||||
| -rwxr-xr-x | test/etc/push-and-run-test-jar | 2 |
20 files changed, 155 insertions, 194 deletions
diff --git a/compiler/dex/quick/arm/assemble_arm.cc b/compiler/dex/quick/arm/assemble_arm.cc index cac766d587..a895e6ec34 100644 --- a/compiler/dex/quick/arm/assemble_arm.cc +++ b/compiler/dex/quick/arm/assemble_arm.cc @@ -1213,7 +1213,7 @@ void ArmMir2Lir::AssembleLIR() { cu_->NewTimingSplit("Assemble"); int assembler_retries = 0; CodeOffset starting_offset = LinkFixupInsns(first_lir_insn_, last_lir_insn_, 0); - data_offset_ = (starting_offset + 0x3) & ~0x3; + data_offset_ = RoundUp(starting_offset, 4); int32_t offset_adjustment; AssignDataOffsets(); @@ -1596,7 +1596,7 @@ void ArmMir2Lir::AssembleLIR() { LOG(FATAL) << "Assembler error - too many retries"; } starting_offset += offset_adjustment; - data_offset_ = (starting_offset + 0x3) & ~0x3; + data_offset_ = RoundUp(starting_offset, 4); AssignDataOffsets(); } } @@ -1609,7 +1609,7 @@ void ArmMir2Lir::AssembleLIR() { write_pos = EncodeLIRs(write_pos, first_lir_insn_); DCHECK_EQ(static_cast<CodeOffset>(write_pos - &code_buffer_[0]), starting_offset); - DCHECK_EQ(data_offset_, (code_buffer_.size() + 0x3) & ~0x3); + DCHECK_EQ(data_offset_, RoundUp(code_buffer_.size(), 4)); // Install literals InstallLiteralPools(); diff --git a/compiler/dex/quick/arm/call_arm.cc b/compiler/dex/quick/arm/call_arm.cc index 163c0fed4a..d3477c9af3 100644 --- a/compiler/dex/quick/arm/call_arm.cc +++ b/compiler/dex/quick/arm/call_arm.cc @@ -360,6 +360,22 @@ void ArmMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) { if (Runtime::Current()->ExplicitStackOverflowChecks()) { /* Load stack limit */ Load32Disp(rs_rARM_SELF, Thread::StackEndOffset<4>().Int32Value(), rs_r12); + } else { + // Implicit stack overflow check. + // Generate a load from [sp, #-overflowsize]. If this is in the stack + // redzone we will get a segmentation fault. + // + // Caveat coder: if someone changes the kStackOverflowReservedBytes value + // we need to make sure that it's loadable in an immediate field of + // a sub instruction. Otherwise we will get a temp allocation and the + // code size will increase. + // + // This is done before the callee save instructions to avoid any possibility + // of these overflowing. This uses r12 and that's never saved in a callee + // save. + OpRegRegImm(kOpSub, rs_r12, rs_rARM_SP, Thread::kStackOverflowReservedBytes); + Load32Disp(rs_r12, 0, rs_r12); + MarkPossibleStackOverflowException(); } } /* Spill core callee saves */ @@ -418,17 +434,8 @@ void ArmMir2Lir::GenEntrySequence(RegLocation* ArgLocs, RegLocation rl_method) { AddSlowPath(new(arena_)StackOverflowSlowPath(this, branch, false, frame_size_)); } } else { - // Implicit stack overflow check. - // Generate a load from [sp, #-overflowsize]. If this is in the stack - // redzone we will get a segmentation fault. - // - // Caveat coder: if someone changes the kStackOverflowReservedBytes value - // we need to make sure that it's loadable in an immediate field of - // a sub instruction. Otherwise we will get a temp allocation and the - // code size will increase. - OpRegRegImm(kOpSub, rs_r12, rs_rARM_SP, Thread::kStackOverflowReservedBytes); - Load32Disp(rs_r12, 0, rs_r12); - MarkPossibleStackOverflowException(); + // Implicit stack overflow check has already been done. Just make room on the + // stack for the frame now. OpRegImm(kOpSub, rs_rARM_SP, frame_size_without_spills); } } else { diff --git a/compiler/dex/quick/codegen_util.cc b/compiler/dex/quick/codegen_util.cc index 9f84e098d9..de13a2ee69 100644 --- a/compiler/dex/quick/codegen_util.cc +++ b/compiler/dex/quick/codegen_util.cc @@ -558,7 +558,7 @@ static int AssignLiteralOffsetCommon(LIR* lir, CodeOffset offset) { static int AssignLiteralPointerOffsetCommon(LIR* lir, CodeOffset offset, unsigned int element_size) { // Align to natural pointer size. - offset = (offset + (element_size - 1)) & ~(element_size - 1); + offset = RoundUp(offset, element_size); for (; lir != NULL; lir = lir->next) { lir->offset = offset; offset += element_size; @@ -758,7 +758,7 @@ int Mir2Lir::AssignFillArrayDataOffset(CodeOffset offset) { tab_rec->offset = offset; offset += tab_rec->size; // word align - offset = (offset + 3) & ~3; + offset = RoundUp(offset, 4); } return offset; } @@ -1049,14 +1049,13 @@ size_t Mir2Lir::GetNumBytesForCompilerTempSpillRegion() { int Mir2Lir::ComputeFrameSize() { /* Figure out the frame size */ - static const uint32_t kAlignMask = kStackAlignment - 1; uint32_t size = num_core_spills_ * GetBytesPerGprSpillLocation(cu_->instruction_set) + num_fp_spills_ * GetBytesPerFprSpillLocation(cu_->instruction_set) + sizeof(uint32_t) // Filler. + (cu_->num_regs + cu_->num_outs) * sizeof(uint32_t) + GetNumBytesForCompilerTempSpillRegion(); /* Align and set */ - return (size + kAlignMask) & ~(kAlignMask); + return RoundUp(size, kStackAlignment); } /* diff --git a/compiler/dex/quick/mips/assemble_mips.cc b/compiler/dex/quick/mips/assemble_mips.cc index baae31915e..b26ab579c3 100644 --- a/compiler/dex/quick/mips/assemble_mips.cc +++ b/compiler/dex/quick/mips/assemble_mips.cc @@ -748,7 +748,7 @@ void MipsMir2Lir::AssignOffsets() { int offset = AssignInsnOffsets(); /* Const values have to be word aligned */ - offset = (offset + 3) & ~3; + offset = RoundUp(offset, 4); /* Set up offsets for literals */ data_offset_ = offset; diff --git a/compiler/dex/quick/x86/assemble_x86.cc b/compiler/dex/quick/x86/assemble_x86.cc index 0fc5c6e943..7436e3960a 100644 --- a/compiler/dex/quick/x86/assemble_x86.cc +++ b/compiler/dex/quick/x86/assemble_x86.cc @@ -1483,7 +1483,7 @@ void X86Mir2Lir::AssignOffsets() { int offset = AssignInsnOffsets(); /* Const values have to be word aligned */ - offset = (offset + 3) & ~3; + offset = RoundUp(offset, 4); /* Set up offsets for literals */ data_offset_ = offset; diff --git a/compiler/utils/arena_allocator.h b/compiler/utils/arena_allocator.h index 18a5bce77d..032eabc7df 100644 --- a/compiler/utils/arena_allocator.h +++ b/compiler/utils/arena_allocator.h @@ -23,6 +23,7 @@ #include "base/macros.h" #include "base/mutex.h" #include "mem_map.h" +#include "utils.h" namespace art { @@ -155,7 +156,7 @@ class ArenaAllocator : private ArenaAllocatorStats { if (UNLIKELY(running_on_valgrind_)) { return AllocValgrind(bytes, kind); } - bytes = (bytes + 3) & ~3; + bytes = RoundUp(bytes, 4); if (UNLIKELY(ptr_ + bytes > end_)) { // Obtain a new block. ObtainNewArenaForAllocation(bytes); diff --git a/compiler/utils/scoped_arena_allocator.cc b/compiler/utils/scoped_arena_allocator.cc index bd78eaef0d..b8b0e6ef7d 100644 --- a/compiler/utils/scoped_arena_allocator.cc +++ b/compiler/utils/scoped_arena_allocator.cc @@ -92,7 +92,7 @@ void ArenaStack::UpdateBytesAllocated() { } void* ArenaStack::AllocValgrind(size_t bytes, ArenaAllocKind kind) { - size_t rounded_bytes = (bytes + kValgrindRedZoneBytes + 3) & ~3; + size_t rounded_bytes = RoundUp(bytes + kValgrindRedZoneBytes, 4); uint8_t* ptr = top_ptr_; if (UNLIKELY(static_cast<size_t>(top_end_ - ptr) < rounded_bytes)) { ptr = AllocateFromNextArena(rounded_bytes); diff --git a/compiler/utils/scoped_arena_allocator.h b/compiler/utils/scoped_arena_allocator.h index 28e86ec005..d5b003ca4d 100644 --- a/compiler/utils/scoped_arena_allocator.h +++ b/compiler/utils/scoped_arena_allocator.h @@ -67,7 +67,7 @@ class ArenaStack : private DebugStackRefCounter { if (UNLIKELY(running_on_valgrind_)) { return AllocValgrind(bytes, kind); } - size_t rounded_bytes = (bytes + 3) & ~3; + size_t rounded_bytes = RoundUp(bytes, 4); uint8_t* ptr = top_ptr_; if (UNLIKELY(static_cast<size_t>(top_end_ - ptr) < rounded_bytes)) { ptr = AllocateFromNextArena(rounded_bytes); diff --git a/runtime/arch/arm/fault_handler_arm.cc b/runtime/arch/arm/fault_handler_arm.cc index eddaa0bc5e..f81e2f9797 100644 --- a/runtime/arch/arm/fault_handler_arm.cc +++ b/runtime/arch/arm/fault_handler_arm.cc @@ -34,7 +34,7 @@ namespace art { extern "C" void art_quick_throw_null_pointer_exception(); -extern "C" void art_quick_throw_stack_overflow(void*); +extern "C" void art_quick_throw_stack_overflow_from_signal(); extern "C" void art_quick_implicit_suspend(); // Get the size of a thumb2 instruction in bytes. @@ -50,7 +50,7 @@ void FaultManager::GetMethodAndReturnPCAndSP(void* context, mirror::ArtMethod** struct ucontext *uc = (struct ucontext *)context; struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext); *out_sp = static_cast<uintptr_t>(sc->arm_sp); - LOG(DEBUG) << "sp: " << *out_sp; + VLOG(signals) << "sp: " << *out_sp; if (*out_sp == 0) { return; } @@ -74,7 +74,7 @@ void FaultManager::GetMethodAndReturnPCAndSP(void* context, mirror::ArtMethod** // Need to work out the size of the instruction that caused the exception. uint8_t* ptr = reinterpret_cast<uint8_t*>(sc->arm_pc); - LOG(DEBUG) << "pc: " << std::hex << static_cast<void*>(ptr); + VLOG(signals) << "pc: " << std::hex << static_cast<void*>(ptr); uint32_t instr_size = GetInstructionSize(ptr); *out_return_pc = (sc->arm_pc + instr_size) | 1; @@ -95,7 +95,7 @@ bool NullPointerHandler::Action(int sig, siginfo_t* info, void* context) { uint32_t instr_size = GetInstructionSize(ptr); sc->arm_lr = (sc->arm_pc + instr_size) | 1; // LR needs to point to gc map location sc->arm_pc = reinterpret_cast<uintptr_t>(art_quick_throw_null_pointer_exception); - LOG(DEBUG) << "Generating null pointer exception"; + VLOG(signals) << "Generating null pointer exception"; return true; } @@ -117,10 +117,10 @@ bool SuspensionHandler::Action(int sig, siginfo_t* info, void* context) { struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext); uint8_t* ptr2 = reinterpret_cast<uint8_t*>(sc->arm_pc); uint8_t* ptr1 = ptr2 - 4; - LOG(DEBUG) << "checking suspend"; + VLOG(signals) << "checking suspend"; uint16_t inst2 = ptr2[0] | ptr2[1] << 8; - LOG(DEBUG) << "inst2: " << std::hex << inst2 << " checkinst2: " << checkinst2; + VLOG(signals) << "inst2: " << std::hex << inst2 << " checkinst2: " << checkinst2; if (inst2 != checkinst2) { // Second instruction is not good, not ours. return false; @@ -132,7 +132,7 @@ bool SuspensionHandler::Action(int sig, siginfo_t* info, void* context) { bool found = false; while (ptr1 > limit) { uint32_t inst1 = ((ptr1[0] | ptr1[1] << 8) << 16) | (ptr1[2] | ptr1[3] << 8); - LOG(DEBUG) << "inst1: " << std::hex << inst1 << " checkinst1: " << checkinst1; + VLOG(signals) << "inst1: " << std::hex << inst1 << " checkinst1: " << checkinst1; if (inst1 == checkinst1) { found = true; break; @@ -140,7 +140,7 @@ bool SuspensionHandler::Action(int sig, siginfo_t* info, void* context) { ptr1 -= 2; // Min instruction size is 2 bytes. } if (found) { - LOG(DEBUG) << "suspend check match"; + VLOG(signals) << "suspend check match"; // This is a suspend check. Arrange for the signal handler to return to // art_quick_implicit_suspend. Also set LR so that after the suspend check it // will resume the instruction (current PC + 2). PC points to the @@ -148,14 +148,14 @@ bool SuspensionHandler::Action(int sig, siginfo_t* info, void* context) { // NB: remember that we need to set the bottom bit of the LR register // to switch to thumb mode. - LOG(DEBUG) << "arm lr: " << std::hex << sc->arm_lr; - LOG(DEBUG) << "arm pc: " << std::hex << sc->arm_pc; + VLOG(signals) << "arm lr: " << std::hex << sc->arm_lr; + VLOG(signals) << "arm pc: " << std::hex << sc->arm_pc; sc->arm_lr = sc->arm_pc + 3; // +2 + 1 (for thumb) 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"; + VLOG(signals) << "removed suspend trigger invoking test suspend"; return true; } return false; @@ -174,103 +174,60 @@ bool SuspensionHandler::Action(int sig, siginfo_t* info, void* context) { // on the stack. // // If we determine this is a stack overflow we need to move the stack pointer -// to the overflow region below the protected region. Because we now have -// a gap in the stack (skips over protected region), we need to arrange -// for the rest of the system to be unaware of the new stack arrangement -// and behave as if there is a fully valid stack. We do this by placing -// a unique address onto the stack followed by -// the size of the gap. The stack walker will detect this and skip over the -// gap. - -// NB. We also need to be careful of stack alignment as the ARM EABI specifies that -// stack must be 8 byte aligned when making any calls. - -// NB. The size of the gap is the difference between the previous frame's SP and -// the SP at which the size word is pushed. +// to the overflow region below the protected region. bool StackOverflowHandler::Action(int sig, siginfo_t* info, void* context) { struct ucontext *uc = (struct ucontext *)context; struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext); - LOG(DEBUG) << "stack overflow handler with sp at " << std::hex << &uc; - LOG(DEBUG) << "sigcontext: " << std::hex << sc; + VLOG(signals) << "stack overflow handler with sp at " << std::hex << &uc; + VLOG(signals) << "sigcontext: " << std::hex << sc; - uint8_t* sp = reinterpret_cast<uint8_t*>(sc->arm_sp); - LOG(DEBUG) << "sp: " << static_cast<void*>(sp); + uintptr_t sp = sc->arm_sp; + VLOG(signals) << "sp: " << std::hex << sp; - uintptr_t* fault_addr = reinterpret_cast<uintptr_t*>(sc->fault_address); - LOG(DEBUG) << "fault_addr: " << std::hex << fault_addr; - LOG(DEBUG) << "checking for stack overflow, sp: " << std::hex << static_cast<void*>(sp) << + uintptr_t fault_addr = sc->fault_address; + VLOG(signals) << "fault_addr: " << std::hex << fault_addr; + VLOG(signals) << "checking for stack overflow, sp: " << std::hex << sp << ", fault_addr: " << fault_addr; - uintptr_t* overflow_addr = reinterpret_cast<uintptr_t*>(sp - Thread::kStackOverflowReservedBytes); + + uintptr_t overflow_addr = sp - Thread::kStackOverflowReservedBytes; + + Thread* self = reinterpret_cast<Thread*>(sc->arm_r9); + CHECK_EQ(self, Thread::Current()); + uintptr_t pregion = reinterpret_cast<uintptr_t>(self->GetStackEnd()) - + Thread::kStackOverflowProtectedSize; // Check that the fault address is the value expected for a stack overflow. if (fault_addr != overflow_addr) { - LOG(DEBUG) << "Not a stack overflow"; + VLOG(signals) << "Not a stack overflow"; return false; } // We know this is a stack overflow. We need to move the sp to the overflow region - // the exists below the protected region. R9 contains the current Thread* so - // we can read the stack_end from that and subtract the size of the - // protected region. This creates a gap in the stack that needs to be marked. - Thread* self = reinterpret_cast<Thread*>(sc->arm_r9); + // the exists below the protected region. Determine the address of the next + // available valid address below the protected region. + uintptr_t prevsp = sp; + sp = pregion; + VLOG(signals) << "setting sp to overflow region at " << std::hex << sp; - uint8_t* prevsp = sp; - sp = self->GetStackEnd() - Thread::kStackOverflowProtectedSize; - LOG(DEBUG) << "setting sp to overflow region at " << std::hex << static_cast<void*>(sp); - - // We need to find the previous frame. Remember that - // this has not yet been fully constructed because the SP has not been - // decremented. So we need to work out the size of the spill portion of the - // frame. This consists of something like: - // - // 0xb6a1d49c: e92d40e0 push {r5, r6, r7, lr} - // 0xb6a1d4a0: ed2d8a06 vpush.f32 {s16-s21} - // - // The first is encoded in the ArtMethod as the spill_mask, the second as the - // fp_spill_mask. A population count on each will give the number of registers - // in each mask. Each register is 4 bytes on ARM32. - - mirror::ArtMethod* method = reinterpret_cast<mirror::ArtMethod*>(sc->arm_r0); - uint32_t spill_mask = method->GetCoreSpillMask(); - uint32_t numcores = POPCOUNT(spill_mask); - uint32_t fp_spill_mask = method->GetFpSpillMask(); - uint32_t numfps = POPCOUNT(fp_spill_mask); - uint32_t spill_size = (numcores + numfps) * 4; - LOG(DEBUG) << "spill size: " << spill_size; - uint8_t* prevframe = prevsp + spill_size; - LOG(DEBUG) << "previous frame: " << static_cast<void*>(prevframe); - - // NOTE: the ARM EABI needs an 8 byte alignment. In the case of ARM32 a pointer - // is 4 bytes so that, together with the offset to the previous frame is 8 - // bytes. On other architectures we will need to align the stack. - - // Push a marker onto the stack to tell the stack walker that there is a stack - // overflow and the stack is not contiguous. - - // First the offset from SP to the previous frame. - sp -= sizeof(uint32_t); - LOG(DEBUG) << "push gap of " << static_cast<uint32_t>(prevframe - sp); - *reinterpret_cast<uint32_t*>(sp) = static_cast<uint32_t>(prevframe - sp); - - // Now the gap marker (pointer sized). - sp -= sizeof(mirror::ArtMethod*); - *reinterpret_cast<void**>(sp) = stack_overflow_gap_marker; + // Since the compiler puts the implicit overflow + // check before the callee save instructions, the SP is already pointing to + // the previous frame. + VLOG(signals) << "previous frame: " << std::hex << prevsp; // Now establish the stack pointer for the signal return. - sc->arm_sp = reinterpret_cast<uintptr_t>(sp); + sc->arm_sp = prevsp; - // Now arrange for the signal handler to return to art_quick_throw_stack_overflow. - // We need the LR to point to the GC map just after the fault instruction. - uint8_t* ptr = reinterpret_cast<uint8_t*>(sc->arm_pc); - uint32_t instr_size = GetInstructionSize(ptr); - sc->arm_lr = (sc->arm_pc + instr_size) | 1; // LR needs to point to gc map location - sc->arm_pc = reinterpret_cast<uintptr_t>(art_quick_throw_stack_overflow); + // Tell the stack overflow code where the new stack pointer should be. + sc->arm_ip = sp; // aka r12 + + // Now arrange for the signal handler to return to art_quick_throw_stack_overflow_from_signal. + // The value of LR must be the same as it was when we entered the code that + // caused this fault. This will be inserted into a callee save frame by + // the function to which this handler returns (art_quick_throw_stack_overflow_from_signal). + sc->arm_pc = reinterpret_cast<uintptr_t>(art_quick_throw_stack_overflow_from_signal); - // The kernel will now return to the address in sc->arm_pc. We have arranged the - // stack pointer to be in the overflow region. Throwing the exception will perform - // a longjmp which will restore the stack pointer to the correct location for the - // exception catch. + // The kernel will now return to the address in sc->arm_pc. return true; } } // namespace art diff --git a/runtime/arch/arm/quick_entrypoints_arm.S b/runtime/arch/arm/quick_entrypoints_arm.S index bc80644945..dcf4561a9f 100644 --- a/runtime/arch/arm/quick_entrypoints_arm.S +++ b/runtime/arch/arm/quick_entrypoints_arm.S @@ -235,6 +235,31 @@ NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow, artThrowStackOverflowFr */ ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method, artThrowNoSuchMethodFromCode + /* + * Invoke stack overflow exception from signal handler. + * On entry: + * r9: thread + * sp: address of last known frame + * r12: address of next valid SP below protected region in stack + * + * This is deceptively simple but hides some complexity. It is called in the case of + * a stack overflow condition during implicit checks. The signal handler has been + * called by the kernel due to a load from the protected stack region. The handler + * works out the address of the previous frame and passes this in SP. However there + * is a piece of memory somewhere below the current SP that is not accessible (the + * memory that caused the signal). The signal handler works out the next + * accessible value of SP and passes this in r12. This code then sets up the SP + * to be this new value and calls the code to create and throw the stack overflow + * exception. + */ +ENTRY art_quick_throw_stack_overflow_from_signal + SETUP_SAVE_ALL_CALLEE_SAVE_FRAME // save all registers as basis for long jump context + mov r0, r9 @ pass Thread::Current + mov r1, sp @ pass SP + mov sp, r12 @ move SP down to below protected region. + b artThrowStackOverflowFromCode @ artThrowStackOverflowFromCode(Thread*, SP) +END art_quick_throw_stack_overflow_from_signal + /* * All generated callsites for interface invokes and invocation slow paths will load arguments * as usual - except instead of loading arg0/r0 with the target Method*, arg0/r0 will contain diff --git a/runtime/base/logging.h b/runtime/base/logging.h index bd5ae85f5c..c4461fab07 100644 --- a/runtime/base/logging.h +++ b/runtime/base/logging.h @@ -296,6 +296,7 @@ struct LogVerbosity { bool startup; bool third_party_jni; // Enabled with "-verbose:third-party-jni". bool threads; + bool signals; }; extern LogVerbosity gLogVerbosity; diff --git a/runtime/fault_handler.cc b/runtime/fault_handler.cc index b8093bc288..1304b04b90 100644 --- a/runtime/fault_handler.cc +++ b/runtime/fault_handler.cc @@ -106,23 +106,23 @@ void FaultManager::RemoveHandler(FaultHandler* handler) { bool FaultManager::IsInGeneratedCode(void* context, bool check_dex_pc) { // We can only be running Java code in the current thread if it // is in Runnable state. - LOG(DEBUG) << "Checking for generated code"; + VLOG(signals) << "Checking for generated code"; Thread* thread = Thread::Current(); if (thread == nullptr) { - LOG(DEBUG) << "no current thread"; + VLOG(signals) << "no current thread"; return false; } ThreadState state = thread->GetState(); if (state != kRunnable) { - LOG(DEBUG) << "not runnable"; + VLOG(signals) << "not runnable"; return false; } // Current thread is runnable. // Make sure it has the mutator lock. if (!Locks::mutator_lock_->IsSharedHeld(thread)) { - LOG(DEBUG) << "no lock"; + VLOG(signals) << "no lock"; return false; } @@ -135,9 +135,9 @@ bool FaultManager::IsInGeneratedCode(void* context, bool check_dex_pc) { GetMethodAndReturnPCAndSP(context, &method_obj, &return_pc, &sp); // If we don't have a potential method, we're outta here. - LOG(DEBUG) << "potential method: " << method_obj; + VLOG(signals) << "potential method: " << method_obj; if (method_obj == 0 || !IsAligned<kObjectAlignment>(method_obj)) { - LOG(DEBUG) << "no method"; + VLOG(signals) << "no method"; return false; } @@ -147,36 +147,36 @@ bool FaultManager::IsInGeneratedCode(void* context, bool check_dex_pc) { // TODO: Method might be not a heap address, and GetClass could fault. mirror::Class* cls = method_obj->GetClass<kVerifyNone>(); if (cls == nullptr) { - LOG(DEBUG) << "not a class"; + VLOG(signals) << "not a class"; return false; } if (!IsAligned<kObjectAlignment>(cls)) { - LOG(DEBUG) << "not aligned"; + VLOG(signals) << "not aligned"; return false; } if (!VerifyClassClass(cls)) { - LOG(DEBUG) << "not a class class"; + VLOG(signals) << "not a class class"; return false; } // Now make sure the class is a mirror::ArtMethod. if (!cls->IsArtMethodClass()) { - LOG(DEBUG) << "not a method"; + VLOG(signals) << "not a method"; return false; } // We can be certain that this is a method now. Check if we have a GC map // at the return PC address. if (true || kIsDebugBuild) { - LOG(DEBUG) << "looking for dex pc for return pc " << std::hex << return_pc; + VLOG(signals) << "looking for dex pc for return pc " << std::hex << return_pc; const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(method_obj); uint32_t sought_offset = return_pc - reinterpret_cast<uintptr_t>(code); - LOG(DEBUG) << "pc offset: " << std::hex << sought_offset; + VLOG(signals) << "pc offset: " << std::hex << sought_offset; } uint32_t dexpc = method_obj->ToDexPc(return_pc, false); - LOG(DEBUG) << "dexpc: " << dexpc; + VLOG(signals) << "dexpc: " << dexpc; return !check_dex_pc || dexpc != DexFile::kDexNoIndex; } diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc index 7232e54944..a87f95c8d2 100644 --- a/runtime/interpreter/interpreter.cc +++ b/runtime/interpreter/interpreter.cc @@ -28,7 +28,17 @@ static void UnstartedRuntimeJni(Thread* self, ArtMethod* method, Object* receiver, uint32_t* args, JValue* result) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { std::string name(PrettyMethod(method)); - if (name == "java.lang.ClassLoader dalvik.system.VMStack.getCallingClassLoader()") { + if (name == "java.lang.Object dalvik.system.VMRuntime.newUnpaddedArray(java.lang.Class, int)") { + int32_t length = args[1]; + DCHECK_GE(length, 0); + mirror::Class* element_class = reinterpret_cast<Object*>(args[0])->AsClass(); + Runtime* runtime = Runtime::Current(); + mirror::Class* array_class = runtime->GetClassLinker()->FindArrayClass(self, element_class); + DCHECK(array_class != nullptr); + gc::AllocatorType allocator = runtime->GetHeap()->GetCurrentAllocator(); + result->SetL(mirror::Array::Alloc<true>(self, array_class, length, + array_class->GetComponentSize(), allocator, true)); + } else if (name == "java.lang.ClassLoader dalvik.system.VMStack.getCallingClassLoader()") { result->SetL(NULL); } else if (name == "java.lang.Class dalvik.system.VMStack.getStackClass2()") { NthCallerVisitor visitor(self, 3); diff --git a/runtime/parsed_options.cc b/runtime/parsed_options.cc index 9cf878535e..f6a98e1e9d 100644 --- a/runtime/parsed_options.cc +++ b/runtime/parsed_options.cc @@ -232,6 +232,7 @@ bool ParsedOptions::Parse(const Runtime::Options& options, bool ignore_unrecogni // gLogVerbosity.startup = true; // TODO: don't check this in! // gLogVerbosity.third_party_jni = true; // TODO: don't check this in! // gLogVerbosity.threads = true; // TODO: don't check this in! +// gLogVerbosity.signals = true; // TODO: don't check this in! method_trace_ = false; method_trace_file_ = "/data/method-trace-file.bin"; @@ -464,6 +465,8 @@ bool ParsedOptions::Parse(const Runtime::Options& options, bool ignore_unrecogni gLogVerbosity.third_party_jni = true; } else if (verbose_options[i] == "threads") { gLogVerbosity.threads = true; + } else if (verbose_options[i] == "signals") { + gLogVerbosity.signals = true; } else { Usage("Unknown -verbose option %s\n", verbose_options[i].c_str()); return false; diff --git a/runtime/stack.cc b/runtime/stack.cc index 9c709ae505..5e64e597f9 100644 --- a/runtime/stack.cc +++ b/runtime/stack.cc @@ -32,14 +32,6 @@ namespace art { -// Define a piece of memory, the address of which can be used as a marker -// for the gap in the stack added during stack overflow handling. -static uint32_t stack_overflow_object; - -// The stack overflow gap marker is simply a valid unique address. -void* stack_overflow_gap_marker = &stack_overflow_object; - - mirror::Object* ShadowFrame::GetThisObject() const { mirror::ArtMethod* m = GetMethod(); if (m->IsStatic()) { @@ -305,56 +297,23 @@ void StackVisitor::WalkStack(bool include_transitions) { bool exit_stubs_installed = Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled(); uint32_t instrumentation_stack_depth = 0; - bool kDebugStackWalk = false; - bool kDebugStackWalkVeryVerbose = false; // The name says it all. - - if (kDebugStackWalk) { - LOG(INFO) << "walking stack"; - } for (const ManagedStack* current_fragment = thread_->GetManagedStack(); current_fragment != NULL; current_fragment = current_fragment->GetLink()) { cur_shadow_frame_ = current_fragment->GetTopShadowFrame(); cur_quick_frame_ = current_fragment->GetTopQuickFrame(); cur_quick_frame_pc_ = current_fragment->GetTopQuickFramePc(); - if (kDebugStackWalkVeryVerbose) { - LOG(INFO) << "cur_quick_frame: " << cur_quick_frame_; - LOG(INFO) << "cur_quick_frame_pc: " << std::hex << cur_quick_frame_pc_; - } if (cur_quick_frame_ != NULL) { // Handle quick stack frames. // Can't be both a shadow and a quick fragment. DCHECK(current_fragment->GetTopShadowFrame() == NULL); mirror::ArtMethod* method = *cur_quick_frame_; while (method != NULL) { - // Check for a stack overflow gap marker. - if (method == reinterpret_cast<mirror::ArtMethod*>(stack_overflow_gap_marker)) { - // Marker for a stack overflow. This is followed by the offset from the - // current SP to the next frame. There is a gap in the stack here. Jump - // the gap silently. - // Caveat coder: the layout of the overflow marker depends on the architecture. - // The first element is address sized (8 bytes on a 64 bit machine). The second - // element is 32 bits. So be careful with those address calculations. - - // Get the address of the offset, just beyond the marker pointer. - byte* gapsizeaddr = reinterpret_cast<byte*>(cur_quick_frame_) + sizeof(uintptr_t); - uint32_t gap = *reinterpret_cast<uint32_t*>(gapsizeaddr); - CHECK_GT(gap, Thread::kStackOverflowProtectedSize); - mirror::ArtMethod** next_frame = reinterpret_cast<mirror::ArtMethod**>( - reinterpret_cast<byte*>(gapsizeaddr) + gap); - if (kDebugStackWalk) { - LOG(INFO) << "stack overflow marker hit, gap: " << gap << ", next_frame: " << - next_frame; - } - cur_quick_frame_ = next_frame; - method = *next_frame; - CHECK(method != nullptr); - } else { - SanityCheckFrame(); - bool should_continue = VisitFrame(); - if (UNLIKELY(!should_continue)) { - return; - } + SanityCheckFrame(); + bool should_continue = VisitFrame(); + if (UNLIKELY(!should_continue)) { + return; } + if (context_ != NULL) { context_->FillCalleeSaves(*this); } @@ -363,9 +322,6 @@ void StackVisitor::WalkStack(bool include_transitions) { size_t return_pc_offset = method->GetReturnPcOffsetInBytes(); byte* return_pc_addr = reinterpret_cast<byte*>(cur_quick_frame_) + return_pc_offset; uintptr_t return_pc = *reinterpret_cast<uintptr_t*>(return_pc_addr); - if (kDebugStackWalkVeryVerbose) { - LOG(INFO) << "frame size: " << frame_size << ", return_pc: " << std::hex << return_pc; - } if (UNLIKELY(exit_stubs_installed)) { // While profiling, the return pc is restored from the side stack, except when walking // the stack for an exception where the side stack will be unwound in VisitFrame. @@ -398,10 +354,6 @@ void StackVisitor::WalkStack(bool include_transitions) { cur_quick_frame_ = reinterpret_cast<mirror::ArtMethod**>(next_frame); cur_depth_++; method = *cur_quick_frame_; - if (kDebugStackWalkVeryVerbose) { - LOG(INFO) << "new cur_quick_frame_: " << cur_quick_frame_; - LOG(INFO) << "new cur_quick_frame_pc_: " << std::hex << cur_quick_frame_pc_; - } } } else if (cur_shadow_frame_ != NULL) { do { diff --git a/runtime/stack.h b/runtime/stack.h index 73a823aac7..88ef78f4b2 100644 --- a/runtime/stack.h +++ b/runtime/stack.h @@ -102,14 +102,6 @@ enum VRegBaseRegNum : int { kVRegNonSpecialTempBaseReg = -3, }; -// Special object used to mark the gap in the stack placed when a stack -// overflow fault occurs during implicit stack checking. This is not -// a real object - it is used simply as a valid address to which a -// mirror::ArtMethod* can be compared during a stack walk. It is inserted -// into the stack during the stack overflow signal handling to mark the gap -// in which the memory is protected against read and write. -extern void* stack_overflow_gap_marker; - // A reference from the shadow stack to a MirrorType object within the Java heap. template<class MirrorType> class MANAGED StackReference : public mirror::ObjectReference<false, MirrorType> { diff --git a/runtime/thread.cc b/runtime/thread.cc index 23a6779639..3a62cd5823 100644 --- a/runtime/thread.cc +++ b/runtime/thread.cc @@ -243,10 +243,16 @@ void Thread::InstallImplicitProtection(bool is_main_stack) { pregion -= kStackOverflowProtectedSize; // Touch the pages in the region to map them in. Otherwise mprotect fails. Only - // need to do this on the main stack. + // need to do this on the main stack. We only need to touch one byte per page. if (is_main_stack) { - memset(pregion, 0x55, kStackOverflowProtectedSize); + byte* start = pregion; + byte* end = pregion + kStackOverflowProtectedSize; + while (start < end) { + *start = static_cast<byte>(0); + start += kPageSize; + } } + VLOG(threads) << "installing stack protected region at " << std::hex << static_cast<void*>(pregion) << " to " << static_cast<void*>(pregion + kStackOverflowProtectedSize - 1); @@ -255,6 +261,11 @@ void Thread::InstallImplicitProtection(bool is_main_stack) { LOG(FATAL) << "Unable to create protected region in stack for implicit overflow check. Reason:" << strerror(errno); } + + // Tell the kernel that we won't be needing these pages any more. + if (is_main_stack) { + madvise(pregion, kStackOverflowProtectedSize, MADV_DONTNEED); + } } void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) { diff --git a/runtime/utils.cc b/runtime/utils.cc index ee2cca4b64..c332bdf815 100644 --- a/runtime/utils.cc +++ b/runtime/utils.cc @@ -1169,10 +1169,12 @@ const char* GetAndroidData() { std::string GetDalvikCacheOrDie(const char* subdir, const bool create_if_absent) { CHECK(subdir != nullptr); - const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", GetAndroidData())); + const char* android_data = GetAndroidData(); + const std::string dalvik_cache_root(StringPrintf("%s/dalvik-cache/", android_data)); const std::string dalvik_cache = dalvik_cache_root + subdir; if (create_if_absent && !OS::DirectoryExists(dalvik_cache.c_str())) { - if (StartsWith(dalvik_cache_root, "/tmp/")) { + // Don't create the system's /data/dalvik-cache/... because it needs special permissions. + if (strcmp(android_data, "/data") != 0) { int result = mkdir(dalvik_cache_root.c_str(), 0700); if (result != 0 && errno != EEXIST) { PLOG(FATAL) << "Failed to create dalvik-cache directory " << dalvik_cache_root; diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc index 03ceed357c..bf1de86f2d 100644 --- a/runtime/verifier/method_verifier.cc +++ b/runtime/verifier/method_verifier.cc @@ -3126,9 +3126,10 @@ mirror::ArtMethod* MethodVerifier::GetQuickInvokedMethod(const Instruction* inst return nullptr; } mirror::ObjectArray<mirror::ArtMethod>* vtable = actual_arg_type.GetClass()->GetVTable(); - CHECK(vtable != nullptr); + CHECK(vtable != nullptr) << PrettyDescriptor(actual_arg_type.GetClass()); uint16_t vtable_index = is_range ? inst->VRegB_3rc() : inst->VRegB_35c(); - CHECK_LT(static_cast<int32_t>(vtable_index), vtable->GetLength()); + CHECK_LT(static_cast<int32_t>(vtable_index), vtable->GetLength()) + << PrettyDescriptor(actual_arg_type.GetClass()); mirror::ArtMethod* res_method = vtable->Get(vtable_index); CHECK(!Thread::Current()->IsExceptionPending()); return res_method; diff --git a/test/etc/push-and-run-test-jar b/test/etc/push-and-run-test-jar index e0d2f1decf..6cf79985a9 100755 --- a/test/etc/push-and-run-test-jar +++ b/test/etc/push-and-run-test-jar @@ -150,7 +150,7 @@ fi JNI_OPTS="-Xjnigreflimit:512 -Xcheck:jni" -cmdline="cd $DEX_LOCATION && mkdir -p dalvik-cache/{arm,arm64,mips,x86,x86_64} && export ANDROID_DATA=$DEX_LOCATION && export DEX_LOCATION=$DEX_LOCATION && \ +cmdline="cd $DEX_LOCATION && export ANDROID_DATA=$DEX_LOCATION && export DEX_LOCATION=$DEX_LOCATION && \ $INVOKE_WITH $gdb /system/bin/dalvikvm$TARGET_SUFFIX $FLAGS $gdbargs -XXlib:$LIB $ZYGOTE $JNI_OPTS $INT_OPTS $DEBUGGER_OPTS $BOOT_OPT -cp $DEX_LOCATION/$TEST_NAME.jar Main" if [ "$DEV_MODE" = "y" ]; then echo $cmdline "$@" |