|
|
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
walkalpha.c
Abstract:
This file implements the ALPHA stack walking api.
Author:
Wesley Witt (wesw) 1-Oct-1993
Environment:
User Mode
--*/
#define _IMAGEHLP_SOURCE_
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include "private.h"
#define NOEXTAPI
#include "wdbgexts.h"
#include "ntdbg.h"
#include "symbols.h"
#include "alphaops.h"
#include <stdlib.h>
#include <stddef.h>
#include <globals.h>
#include "fecache.hpp"
#ifdef __cplusplus
extern "C"#endif
BOOLWalkAlphaInit( HANDLE hProcess, LPSTACKFRAME64 StackFrame, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64 );
BOOLWalkAlphaNext( HANDLE hProcess, LPSTACKFRAME64 StackFrame, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64 );
BOOLWalkAlphaGetStackFrame( HANDLE hProcess, PULONG64 ReturnAddress, PULONG64 FramePointer, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, PKDHELP64 KdHelp, BOOL Use64 );
VOIDGetUnwindFunctionEntry( HANDLE hProcess, ULONG64 ControlPc, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64, FeCacheEntry* FunctionEntry, PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY UnwindFunctionEntry, PULONG StackAdjust, PULONG64 FixedReturn );
#define ZERO 0x0 /* integer register 0 */
#define SP 0x1d /* integer register 29 */
#define RA 0x1f /* integer register 31 */
#define SAVED_FLOATING_MASK 0xfff00000 /* saved floating registers */
#define SAVED_INTEGER_MASK 0xf3ffff02 /* saved integer registers */
#define IS_FLOATING_SAVED(Register) ((SAVED_FLOATING_MASK >> Register) & 1L)
#define IS_INTEGER_SAVED(Register) ((SAVED_INTEGER_MASK >> Register) & 1L)
#define IS_HANDLER_DEFINED(FunctionEntry) \
(RF_EXCEPTION_HANDLER(FunctionEntry) != 0)
BOOLWalkAlpha( HANDLE hProcess, LPSTACKFRAME64 StackFrame, PVOID ContextRecord, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64 ){ BOOL rval; PALPHA_NT5_CONTEXT Context = (PALPHA_NT5_CONTEXT)ContextRecord;
if (StackFrame->Virtual) {
rval = WalkAlphaNext( hProcess, StackFrame, Context, ReadMemory, GetModuleBase, GetFunctionEntry, Use64 );
} else {
rval = WalkAlphaInit( hProcess, StackFrame, Context, ReadMemory, GetModuleBase, GetFunctionEntry, Use64 );
}
return rval;}
ULONG64VirtualUnwind ( HANDLE hProcess, ULONG64 ControlPc, PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY FunctionEntry, ULONG StackAdjust, ULONG64 FixedReturn, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory// PKNONVOLATILE_CONTEXT_POINTERS ContextPointers OPTIONAL
)
/*++
Routine Description:
This function virtually unwinds the specified function by executing its prologue code backwards. Given the current context and the instructions that preserve registers in the prologue, it is possible to recreate the nonvolatile context at the point the function was called.
If the function is a leaf function, then the address where control left the previous frame is obtained from the context record. If the function is a nested function, but not an exception or interrupt frame, then the prologue code is executed backwards and the address where control left the previous frame is obtained from the updated context record.
Otherwise, an exception or interrupt entry to the system is being unwound and a specially coded prologue restores the return address twice. Once from the fault instruction address and once from the saved return address register. The first restore is returned as the function value and the second restore is placed in the updated context record.
During the unwind, the virtual and real frame pointers for the function are calculated and returned in the given frame pointers structure.
If a context pointers record is specified, then the address where each register is restored from is recorded in the appropriate element of the context pointers record.
Arguments:
ControlPc - Supplies the address where control left the specified function.
FunctionEntry - Supplies the address of the function table entry for the specified function.
ContextRecord - Supplies the address of a context record.
ContextPointers - Supplies an optional pointer to a context pointers record.
Return Value:
The address where control left the previous frame is returned as the function value.
Implementation Notes:
N.B. "where control left" is not the "return address" of the call in the previous frame. For normal frames, NextPc points to the last instruction that completed in the previous frame (the JSR/BSR). The difference between NextPc and NextPc + 4 (return address) is important for correct behavior in boundary cases of exception addresses and scope tables.
For exception and interrupt frames, NextPc is obtained from the trap frame contination address (Fir). For faults and synchronous traps, NextPc is both the last instruction to execute in the previous frame and the next instruction to execute if the function were to return. For asynchronous traps, NextPc is the continuation address. It is the responsibility of the compiler to insert TRAPB instructions to insure asynchronous traps do not occur outside the scope from the instruction(s) that caused them.
N.B. in this and other files where RtlVirtualUnwind is used, the variable named NextPc is perhaps more accurately, LastPc - the last PC value in the previous frame, or CallPc - the address of the call instruction, or ControlPc - the address where control left the previous frame. Instead think of NextPc as the next PC to use in another call to virtual unwind.
The Alpha version of virtual unwind is similar in design, but slightly more complex than the Mips version. This is because Alpha compilers are given more flexibility to optimize generated code and instruction sequences, including within procedure prologues. And also because of compiler design issues, the function must manage both virtual and real frame pointers.
Version Information: This version was taken from exdspatch.c@v37 (Feb 1993)
--*/
{ ALPHA_INSTRUCTION FollowingInstruction; ALPHA_INSTRUCTION Instruction; ULONGLONG Address; ULONG DecrementOffset; ULONG DecrementRegister; PULONGLONG FloatingRegister; ULONG FrameSize; ULONG Function; PULONGLONG IntegerRegister; ULONG Literal8; ULONGLONG NextPc; LONG Offset16; ULONG Opcode; ULONG Ra; ULONG Rb; ULONG Rc; BOOLEAN RestoredRa; BOOLEAN RestoredSp; DWORD cb; PVOID Prolog;
//
// perf hack: fill cache with prolog
// skip it if this is a secondary function entry
//
if (FunctionEntry && (ALPHA_RF_PROLOG_END_ADDRESS(FunctionEntry) > ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) && (ALPHA_RF_PROLOG_END_ADDRESS(FunctionEntry) < ALPHA_RF_END_ADDRESS(FunctionEntry)) ) {
cb = (ULONG)(ALPHA_RF_PROLOG_END_ADDRESS(FunctionEntry) - ALPHA_RF_BEGIN_ADDRESS(FunctionEntry));
//
// If the function is a leaf it doesn't have a prolog, skip this
// optimization.
//
if (cb != 0) { Prolog = (PVOID) MemAlloc( cb ); if (!ReadMemory( hProcess, ALPHA_RF_BEGIN_ADDRESS(FunctionEntry), Prolog, cb, &cb )) { return 0; } MemFree(Prolog); } }
//
// Set the base address of the integer and floating register arrays within
// the context record. Each set of 32 registers is known to be contiguous.
//
// assuming that quad values are together in context.
IntegerRegister = &Context->IntV0; FloatingRegister = &Context->FltF0;
//
// Handle the epilogue case where the next instruction is a return.
//
// Exception handlers cannot be called if the ControlPc is within the
// epilogue because exception handlers expect to operate with a current
// stack frame. The value of SP is not current within the epilogue.
//
if (!ReadMemory(hProcess, ControlPc, &Instruction.Long, 4, &cb)) { return(0); }
if (IS_RETURN_0001_INSTRUCTION(Instruction.Long)) { Rb = Instruction.Jump.Rb; NextPc = IntegerRegister[Rb] - 4;
//
// The instruction at the point where control left the specified
// function is a return, so any saved registers have already been
// restored, and the stack pointer has already been adjusted. The
// stack does not need to be unwound in this case and the saved
// return address register is returned as the function value.
//
// In fact, reverse execution of the prologue is not possible in
// this case: the stack pointer has already been incremented and
// so, for this frame, neither a valid stack pointer nor frame
// pointer exists from which to begin reverse execution of the
// prologue. In addition, the integrity of any data on the stack
// below the stack pointer is never guaranteed (due to interrupts
// and exceptions).
//
// The epilogue instruction sequence is:
//
// ==> ret zero, (Ra), 1 // return
// or
//
// mov ra, Rx // save return address
// ...
// ==> ret zero, (Rx), 1 // return
//
return NextPc; }
//
// Handle the epilogue case where the next two instructions are a stack
// frame deallocation and a return.
//
if (!ReadMemory(hProcess,(ControlPc+4),&FollowingInstruction.Long,4,&cb)) { return 0; }
if (IS_RETURN_0001_INSTRUCTION(FollowingInstruction.Long)) { Rb = FollowingInstruction.Jump.Rb; NextPc = IntegerRegister[Rb] - 4;
//
// The second instruction following the point where control
// left the specified function is a return. If the instruction
// before the return is a stack increment instruction, then all
// saved registers have already been restored except for SP.
// The value of the stack pointer register cannot be recovered
// through reverse execution of the prologue because in order
// to begin reverse execution either the stack pointer or the
// frame pointer (if any) must still be valid.
//
// Instead, the effect that the stack increment instruction
// would have had on the context is manually applied to the
// current context. This is forward execution of the epilogue
// rather than reverse execution of the prologue.
//
// In an epilogue, as in a prologue, the stack pointer is always
// adjusted with a single instruction: either an immediate-value
// (lda) or a register-value (addq) add instruction.
//
Function = Instruction.OpReg.Function; Offset16 = Instruction.Memory.MemDisp; Opcode = Instruction.OpReg.Opcode; Ra = Instruction.OpReg.Ra; Rb = Instruction.OpReg.Rb; Rc = Instruction.OpReg.Rc;
if ((Opcode == LDA_OP) && (Ra == SP_REG)) {
//
// Load Address instruction.
//
// Since the destination (Ra) register is SP, an immediate-
// value stack deallocation operation is being performed. The
// displacement value should be added to SP. The displacement
// value is assumed to be positive. The amount of stack
// deallocation possible using this instruction ranges from
// 16 to 32752 (32768 - 16) bytes. The base register (Rb) is
// usually SP, but may be another register.
//
// The epilogue instruction sequence is:
//
// ==> lda sp, +N(sp) // deallocate stack frame
// ret zero, (ra) // return
// or
//
// ==> lda sp, +N(Rx) // restore SP and deallocate frame
// ret zero, (ra) // return
//
Context->IntSp = Offset16 + IntegerRegister[Rb]; return NextPc;
} else if ((Opcode == ARITH_OP) && (Function == ADDQ_FUNC) && (Rc == SP_REG) && (Instruction.OpReg.RbvType == RBV_REGISTER_FORMAT)) {
//
// Add Quadword instruction.
//
// Since both source operands are registers, and the
// destination register is SP, a register-value stack
// deallocation is being performed. The value of the two
// source registers should be added and this is the new
// value of SP. One of the source registers is usually SP,
// but may be another register.
//
// The epilogue instruction sequence is:
//
// ldiq Rx, N // set [large] frame size
// ...
// ==> addq sp, Rx, sp // deallocate stack frame
// ret zero, (ra) // return
// or
//
// ==> addq Rx, Ry, sp // restore SP and deallocate frame
// ret zero, (ra) // return
//
Context->IntSp = IntegerRegister[Ra] + IntegerRegister[Rb]; return NextPc; } }
//
// By default set the frame pointers to the current value of SP.
//
// When a procedure is called, the value of SP before the stack
// allocation instruction is the virtual frame pointer. When reverse
// executing instructions in the prologue, the value of SP before the
// stack allocation instruction is encountered is the real frame
// pointer. This is the current value of SP unless the procedure uses
// a frame pointer (e.g., FP_REG).
//
//
// If the address where control left the specified function is beyond
// the end of the prologue, then the control PC is considered to be
// within the function and the control address is set to the end of
// the prologue. Otherwise, the control PC is not considered to be
// within the function (i.e., the prologue).
//
// N.B. PrologEndAddress is equal to BeginAddress for a leaf function.
//
// The low-order two bits of PrologEndAddress are reserved for the IEEE
// exception mode and so must be masked out.
//
if ((ControlPc < ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) || (ControlPc >= ALPHA_RF_PROLOG_END_ADDRESS(FunctionEntry))) { ControlPc = ALPHA_RF_PROLOG_END_ADDRESS(FunctionEntry); }
//
// Scan backward through the prologue to reload callee saved registers
// that were stored or copied and to increment the stack pointer if it
// was decremented.
//
DecrementRegister = ZERO_REG; NextPc = Context->IntRa - 4; RestoredRa = FALSE; RestoredSp = FALSE; while (ControlPc > ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) {
//
// Get instruction value, decode fields, case on opcode value, and
// reverse register store and stack decrement operations.
// N.B. The location of Opcode, Ra, Rb, and Rc is the same across
// all opcode formats. The same is not true for Function.
//
ControlPc -= 4; if (!ReadMemory(hProcess, ControlPc, &Instruction.Long, 4, &cb)) { return 0; } Function = Instruction.OpReg.Function; Literal8 = Instruction.OpLit.Literal; Offset16 = Instruction.Memory.MemDisp; Opcode = Instruction.OpReg.Opcode; Ra = Instruction.OpReg.Ra; Rb = Instruction.OpReg.Rb; Rc = Instruction.OpReg.Rc;
//
// Compare against each instruction type that will affect the context
// and that is allowed in a prologue. Any other instructions found
// in the prologue will be ignored since they are assumed to have no
// effect on the context.
//
switch (Opcode) {
case STQ_OP :
//
// Store Quad instruction.
//
// If the base register is SP, then reload the source register
// value from the value stored on the stack.
//
// The prologue instruction sequence is:
//
// ==> stq Rx, N(sp) // save integer register Rx
//
if ((Rb == SP_REG) && (Ra != ZERO_REG)) {
//
// Reload the register by retrieving the value previously
// stored on the stack.
//
Address = (Offset16 + Context->IntSp); if (!ReadMemory(hProcess, Address, &IntegerRegister[Ra], 8L, &cb)) { return 0; }
//
// If the destination register is RA and this is the first
// time that RA is being restored, then set the address of
// where control left the previous frame. Otherwise, if this
// is the second time RA is being restored, then the first
// one was an interrupt or exception address and the return
// PC should not have been biased by 4.
//
if (Ra == RA_REG) { if (RestoredRa == FALSE) { NextPc = Context->IntRa - 4; RestoredRa = TRUE;
} else { NextPc += 4; }
//
// Otherwise, if the destination register is SP and this is
// the first time that SP is being restored, then set the
// establisher frame pointers.
//
} else if ((Ra == SP_REG) && (RestoredSp == FALSE)) { RestoredSp = TRUE; }
//
// If a context pointer record is specified, then record
// the address where the destination register contents
// are stored.
//
//if (ContextPointers != (PKNONVOLATILE_CONTEXT_POINTERS) NULL) {
// ContextPointers->IntegerContext[Ra] = (PULONGLONG)Address;
//}
} break;
case LDAH_OP : Offset16 <<= 16;
case LDA_OP :
//
// Load Address High, Load Address instruction.
//
// There are several cases where the lda and/or ldah instructions
// are used: one to decrement the stack pointer directly, and the
// others to load immediate values into another register and that
// register is then used to decrement the stack pointer.
//
// In the examples below, as a single instructions or as a pair,
// a lda may be substituted for a ldah and visa-versa.
//
if (Ra == SP_REG) { if (Rb == SP_REG) {
//
// If both the destination (Ra) and base (Rb) registers
// are SP, then a standard stack allocation was performed
// and the negated displacement value is the stack frame
// size. The amount of stack allocation possible using
// the lda instruction ranges from 16 to 32768 bytes and
// the amount of stack allocation possible using the ldah
// instruction ranges from 65536 to 2GB in multiples of
// 65536 bytes. It is rare for the ldah instruction to be
// used in this manner.
//
// The prologue instruction sequence is:
//
// ==> lda sp, -N(sp) // allocate stack frame
//
FrameSize = -Offset16; goto StackAllocation;
} else {
//
// The destination register is SP and the base register
// is not SP, so this instruction must be the second
// half of an instruction pair to allocate a large size
// (>32768 bytes) stack frame. Save the displacement value
// as the partial decrement value and postpone adjusting
// the value of SP until the first instruction of the pair
// is encountered.
//
// The prologue instruction sequence is:
//
// ldah Rx, -N(sp) // prepare new SP (upper)
// ==> lda sp, sN(Rx) // allocate stack frame
//
DecrementRegister = Rb; DecrementOffset = Offset16; }
} else if (Ra == DecrementRegister) { if (Rb == DecrementRegister) {
//
// Both the destination and base registers are the
// decrement register, so this instruction exists as the
// second half of a two instruction pair to load a
// 31-bit immediate value into the decrement register.
// Save the displacement value as the partial decrement
// value.
//
// The prologue instruction sequence is:
//
// ldah Rx, +N(zero) // set frame size (upper)
// ==> lda Rx, sN(Rx) // set frame size (+lower)
// ...
// subq sp, Rx, sp // allocate stack frame
//
DecrementOffset += Offset16;
} else if (Rb == ZERO_REG) {
//
// The destination register is the decrement register and
// the base register is zero, so this instruction exists
// to load an immediate value into the decrement register.
// The stack frame size is the new displacement value added
// to the previous displacement value, if any.
//
// The prologue instruction sequence is:
//
// ==> lda Rx, +N(zero) // set frame size
// ...
// subq sp, Rx, sp // allocate stack frame
// or
//
// ==> ldah Rx, +N(zero) // set frame size (upper)
// lda Rx, sN(Rx) // set frame size (+lower)
// ...
// subq sp, Rx, sp // allocate stack frame
//
FrameSize = (Offset16 + DecrementOffset); goto StackAllocation;
} else if (Rb == SP_REG) {
//
// The destination (Ra) register is SP and the base (Rb)
// register is the decrement register, so a two
// instruction, large size (>32768 bytes) stack frame
// allocation was performed. Add the new displacement
// value to the previous displacement value. The negated
// displacement value is the stack frame size.
//
// The prologue instruction sequence is:
//
// ==> ldah Rx, -N(sp) // prepare new SP (upper)
// lda sp, sN(Rx) // allocate stack frame
//
FrameSize = -(Offset16 + (LONG)DecrementOffset); goto StackAllocation; } } break;
case ARITH_OP :
if ((Function == ADDQ_FUNC) && (Instruction.OpReg.RbvType != RBV_REGISTER_FORMAT)) {
//
// Add Quadword (immediate) instruction.
//
// If the first source register is zero, and the second
// operand is a literal, and the destination register is
// the decrement register, then the instruction exists
// to load an unsigned immediate value less than 256 into
// the decrement register. The immediate value is the stack
// frame size.
//
// The prologue instruction sequence is:
//
// ==> addq zero, N, Rx // set frame size
// ...
// subq sp, Rx, sp // allocate stack frame
//
if ((Ra == ZERO_REG) && (Rc == DecrementRegister)) { FrameSize = Literal8; goto StackAllocation; }
} else if ((Function == SUBQ_FUNC) && (Instruction.OpReg.RbvType == RBV_REGISTER_FORMAT)) {
//
// Subtract Quadword (register) instruction.
//
// If both source operands are registers and the first
// source (minuend) register and the destination
// (difference) register are both SP, then a register value
// stack allocation was performed and the second source
// (subtrahend) register value will be added to SP when its
// value is known. Until that time save the register number of
// this decrement register.
//
// The prologue instruction sequence is:
//
// ldiq Rx, N // set frame size
// ...
// ==> subq sp, Rx, sp // allocate stack frame
//
if ((Ra == SP_REG) && (Rc == SP_REG)) { DecrementRegister = Rb; DecrementOffset = 0; } } break;
case BIT_OP :
//
// If the second operand is a register the bit set instruction
// may be a register move instruction, otherwise if the second
// operand is a literal, the bit set instruction may be a load
// immediate value instruction.
//
if ((Function == BIS_FUNC) && (Rc != ZERO_REG)) { if (Instruction.OpReg.RbvType == RBV_REGISTER_FORMAT) {
//
// Bit Set (register move) instruction.
//
// If both source registers are the same register, or
// one of the source registers is zero, then this is a
// register move operation. Restore the value of the
// source register by copying the current destination
// register value back to the source register.
//
// The prologue instruction sequence is:
//
// ==> bis Rx, Rx, Ry // copy register Rx
// or
//
// ==> bis Rx, zero, Ry // copy register Rx
// or
//
// ==> bis zero, Rx, Ry // copy register Rx
//
if (Ra == ZERO_REG) {
//
// Map the third case above to the first case.
//
Ra = Rb;
} else if (Rb == ZERO_REG) {
//
// Map the second case above to the first case.
//
Rb = Ra; }
if ((Ra == Rb) && (Ra != ZERO_REG)) { IntegerRegister[Ra] = IntegerRegister[Rc];
//
// If the destination register is RA and this is the
// first time that RA is being restored, then set the
// address of where control left the previous frame.
// Otherwise, if this is the second time RA is being
// restored, then the first one was an interrupt or
// exception address and the return PC should not
// have been biased by 4.
//
if (Ra == RA_REG) { if (RestoredRa == FALSE) { NextPc = Context->IntRa - 4; RestoredRa = TRUE;
} else { NextPc += 4; } }
//
// If the source register is SP and this is the first
// time SP is set, then this is a frame pointer set
// instruction. Reset the frame pointers to this new
// value of SP.
//
if ((Ra == SP_REG) && (RestoredSp == FALSE)) { RestoredSp = TRUE; } }
} else {
//
// Bit Set (load immediate) instruction.
//
// If the first source register is zero, and the second
// operand is a literal, and the destination register is
// the decrement register, then this instruction exists
// to load an unsigned immediate value less than 256 into
// the decrement register. The decrement register value is
// the stack frame size.
//
// The prologue instruction sequence is:
//
// ==> bis zero, N, Rx // set frame size
// ...
// subq sp, Rx, sp // allocate stack frame
//
if ((Ra == ZERO_REG) && (Rc == DecrementRegister)) { FrameSize = Literal8;StackAllocation: //
// Add the frame size to SP to reverse the stack frame
// allocation, leave the real frame pointer as is, set
// the virtual frame pointer with the updated SP value,
// and clear the decrement register.
//
Context->IntSp += FrameSize; DecrementRegister = ZERO_REG; } } } break;
case STT_OP :
//
// Store T-Floating (quadword integer) instruction.
//
// If the base register is SP, then reload the source register
// value from the value stored on the stack.
//
// The prologue instruction sequence is:
//
// ==> stt Fx, N(sp) // save floating register Fx
//
if ((Rb == SP_REG) && (Ra != FZERO_REG)) {
//
// Reload the register by retrieving the value previously
// stored on the stack.
//
Address = (Offset16 + Context->IntSp); if (!ReadMemory(hProcess, Address, &FloatingRegister[Ra], 8L, &cb)) { return 0; }
//
// If a context pointer record is specified, then record
// the address where the destination register contents are
// stored.
//
//if (ContextPointers != (PKNONVOLATILE_CONTEXT_POINTERS) NULL) {
// ContextPointers->FloatingContext[Ra] = (PULONGLONG)Address;
//}
} break;
case STS_OP :
//
// Store T-Floating (dword integer) instruction.
//
// If the base register is SP, then reload the source register
// value from the value stored on the stack.
//
// The prologue instruction sequence is:
//
// ==> stt Fx, N(sp) // save floating register Fx
//
if ((Rb == SP_REG) && (Ra != FZERO_REG)) {
//
// Reload the register by retrieving the value previously
// stored on the stack.
//
float f;
Address = (Offset16 + Context->IntSp); if (!ReadMemory(hProcess, Address, &f, sizeof(float), &cb)) { return 0; }
//
// value was stored as a float. Do a conversion to a
// double, since registers are Always read as doubles
//
FloatingRegister[Ra] = (ULONGLONG)(double)f;
//
// If a context pointer record is specified, then record
// the address where the destination register contents are
// stored.
//
//if (ContextPointers != (PKNONVOLATILE_CONTEXT_POINTERS) NULL) {
// ContextPointers->FloatingContext[Ra] = (PULONGLONG)Address;
//}
} break;
case FPOP_OP :
//
// N.B. The floating operate function field is not the same as
// the integer operate nor the jump function fields.
//
if (Instruction.FpOp.Function == CPYS_FUNC) {
//
// Copy Sign (floating-point move) instruction.
//
// If both source registers are the same register, then this is
// a floating-point register move operation. Restore the value
// of the source register by copying the current destination
// register value to the source register.
//
// The prologue instruction sequence is:
//
// ==> cpys Fx, Fx, Fy // copy floating register Fx
//
if ((Ra == Rb) && (Ra != FZERO_REG)) { FloatingRegister[Ra] = FloatingRegister[Rc]; } }
default : break; } }
if (StackAdjust) { // Check for exlicit stack adjust amount
Context->IntSp += StackAdjust; }
if (FixedReturn != 0) { NextPc = FixedReturn; }
return NextPc;}
BOOLWalkAlphaGetStackFrame( HANDLE hProcess, PULONG64 ReturnAddress, PULONG64 FramePointer, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, PKDHELP64 KdHelp, BOOL Use64 ){ FeCacheEntry* CacheEntry; FeCacheEntry UnwindFunctionEntry; ULONG64 NextPc = Context->IntRa; BOOL rval = TRUE; ULONG cb; ULONG StackAdjust; ULONG64 FixedReturn;
if (*ReturnAddress == 0) { return FALSE; }
__try { FunctionEntryCache* Cache = GetFeCache(Use64 ? IMAGE_FILE_MACHINE_ALPHA64 : IMAGE_FILE_MACHINE_ALPHA, TRUE); if (Cache != NULL) { CacheEntry = Cache->Find(hProcess, *ReturnAddress, ReadMemory, GetModuleBase, GetFunctionEntry); } else { CacheEntry = NULL; }
if (CacheEntry != NULL) {
// Construct a function entry suitable for unwinding from ControlPc
UnwindFunctionEntry.Address = 0; UnwindFunctionEntry.Process = 0;
GetUnwindFunctionEntry( hProcess, *ReturnAddress, ReadMemory, GetModuleBase, GetFunctionEntry, Use64, CacheEntry, &UnwindFunctionEntry.Data.Axp64, &StackAdjust, &FixedReturn ); FE_SET_DESC(&UnwindFunctionEntry, "from UnwindFunctionEntry"); FE_ShowRuntimeFunctionAxp64((&UnwindFunctionEntry, "VirtualUnwind: unwind function entry"));#if DBG
if (tlsvar(DebugFunctionEntries)) { dbPrint(" FixedReturn = %16.8I64x\n", FixedReturn ); dbPrint(" StackAdjust = %16x\n", StackAdjust ); }#endif
NextPc = VirtualUnwind( hProcess, *ReturnAddress, &UnwindFunctionEntry.Data.Axp64, StackAdjust, FixedReturn, Context, ReadMemory);#if DBG
if (tlsvar(DebugFunctionEntries)) { dbPrint("NextPc = %.8I64x\n", NextPc ); }#endif
if (!NextPc) { rval = FALSE; }
//
// The Ra value coming out of mainCRTStartup is set by some RTL
// routines to be "1"; return out of mainCRTStartup is actually
// done through Jump/Unwind, so this serves to cause an error if
// someone actually does a return. That's why we check here for
// NextPc == 1 - this happens when in the frame for CRTStartup.
//
// We test for (0-4) and (1-4) because on ALPHA, the value returned by
// VirtualUnwind is the value to be passed to the next call to
// VirtualUnwind, which is NOT the same as the Ra - it's sometimes
// decremented by four - this gives the faulting instruction -
// in particular, we want the fault instruction so we can get the
// correct scope in the case of an exception.
//
if ((NextPc == 1) || (NextPc == 4) || (NextPc == (0-4)) || (NextPc == (1-4)) ) { NextPc = 0; } if ( !NextPc || (NextPc == *ReturnAddress && *FramePointer == Context->IntSp) ) { rval = FALSE; }
*ReturnAddress = NextPc; *FramePointer = Context->IntSp;
} else {
if ( (NextPc == *ReturnAddress && *FramePointer == Context->IntSp) || (NextPc == 1) || (NextPc == 0) || (NextPc == (-4)) ) { rval = FALSE; }
*ReturnAddress = Context->IntRa; *FramePointer = Context->IntSp;
}
} __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { rval = FALSE; }
return rval;}
BOOLWalkAlphaInit( HANDLE hProcess, LPSTACKFRAME64 StackFrame, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64 ){ ALPHA_NT5_CONTEXT ContextSave; ULONG64 PcOffset; ULONG64 FrameOffset; DWORD cb; ALPHA_KEXCEPTION_FRAME ExceptionFrame; PALPHA_KEXCEPTION_FRAME pef = &ExceptionFrame; DWORD Result;
if (StackFrame->AddrFrame.Offset) {#if 0
if (ReadMemory( hProcess, StackFrame->AddrFrame.Offset, &ExceptionFrame, sizeof(ALPHA_KEXCEPTION_FRAME), &cb )) { //
// successfully read an exception frame from the stack
//
Context->IntSp = StackFrame->AddrFrame.Offset; Context->Fir = pef->SwapReturn; Context->IntRa = pef->SwapReturn; Context->IntS0 = pef->IntS0; Context->IntS1 = pef->IntS1; Context->IntS2 = pef->IntS2; Context->IntS3 = pef->IntS3; Context->IntS4 = pef->IntS4; Context->IntS5 = pef->IntS5; Context->Psr = pef->Psr; } else { return FALSE; }#endif
}
ZeroMemory( StackFrame, FIELD_OFFSET( STACKFRAME64, KdHelp.ThCallbackBStore) );
StackFrame->Virtual = TRUE;
StackFrame->AddrPC.Offset = Context->Fir; StackFrame->AddrPC.Mode = AddrModeFlat;
StackFrame->AddrFrame.Offset = Context->IntSp; StackFrame->AddrFrame.Mode = AddrModeFlat;
ContextSave = *Context; PcOffset = StackFrame->AddrPC.Offset; FrameOffset = StackFrame->AddrFrame.Offset;
if (!WalkAlphaGetStackFrame( hProcess, &PcOffset, &FrameOffset, &ContextSave, ReadMemory, GetModuleBase, GetFunctionEntry, &StackFrame->KdHelp, Use64) ) {
StackFrame->AddrReturn.Offset = Context->IntRa;
} else {
StackFrame->AddrReturn.Offset = PcOffset; }
StackFrame->AddrReturn.Mode = AddrModeFlat;
//
// get the arguments to the function
//
StackFrame->Params[0] = Context->IntA0; StackFrame->Params[1] = Context->IntA1; StackFrame->Params[2] = Context->IntA2; StackFrame->Params[3] = Context->IntA3;
return TRUE;}
BOOLWalkAlphaNext( HANDLE hProcess, LPSTACKFRAME64 StackFrame, PALPHA_NT5_CONTEXT Context, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64 ){ DWORD cb; ALPHA_NT5_CONTEXT ContextSave; BOOL rval = TRUE; ULONG64 Address; FunctionEntryCache* Cache; FeCacheEntry* CacheEntry; ULONG64 SystemRangeStart; DWORD dw; ULONG64 qw;
if (!WalkAlphaGetStackFrame( hProcess, &StackFrame->AddrPC.Offset, &StackFrame->AddrFrame.Offset, Context, ReadMemory, GetModuleBase, GetFunctionEntry, &StackFrame->KdHelp, Use64) ) {
rval = FALSE;
//
// If the frame could not be unwound or is terminal, see if
// there is a callback frame:
//
if (g.AppVersion.Revision >= 4 && CALLBACK_STACK(StackFrame)) {
if (g.AppVersion.Revision >= 6) { SystemRangeStart = SYSTEM_RANGE_START(StackFrame); } else { //
// This might not really work right with old debuggers, but it keeps
// us from looking off the end of the structure anyway.
//
SystemRangeStart = 0x80000000; }
if (CALLBACK_STACK(StackFrame) >= SystemRangeStart) {
//
// it is the pointer to the stack frame that we want,
// or -1.
Address = CALLBACK_STACK(StackFrame);
} else {
//
// if it is a positive integer, it is the offset to
// the address in the thread.
// Look up the pointer:
//
if (Use64) { rval = ReadMemory(hProcess, (CALLBACK_THREAD(StackFrame) + CALLBACK_STACK(StackFrame)), &Address, sizeof(ULONG64), &cb); } else { rval = ReadMemory(hProcess, (CALLBACK_THREAD(StackFrame) + CALLBACK_STACK(StackFrame)), &dw, sizeof(DWORD), &cb); Address = (ULONG64)(LONG64)(LONG)dw; }
if (!rval || Address == 0) { Address = (ULONG64)-1; CALLBACK_STACK(StackFrame) = (DWORD)-1; }
}
if ( (Address == (ULONG64)-1) || (Cache = GetFeCache(Use64 ? IMAGE_FILE_MACHINE_ALPHA64 : IMAGE_FILE_MACHINE_ALPHA, TRUE)) == NULL || (CacheEntry = Cache->Find(hProcess, CALLBACK_FUNC(StackFrame), ReadMemory, GetModuleBase, GetFunctionEntry)) == NULL ) {
rval = FALSE;
} else {
if (Use64) { ReadMemory(hProcess, (Address + CALLBACK_NEXT(StackFrame)), &CALLBACK_STACK(StackFrame), sizeof(ULONG64), &cb); StackFrame->AddrPC.Offset = ALPHA_RF_PROLOG_END_ADDRESS(&CacheEntry->Data.Axp64); } else { ReadMemory(hProcess, (Address + CALLBACK_NEXT(StackFrame)), &dw, sizeof(DWORD), &cb); CALLBACK_STACK(StackFrame) = dw; StackFrame->AddrPC.Offset = ALPHA_RF_PROLOG_END_ADDRESS((PIMAGE_ALPHA_RUNTIME_FUNCTION_ENTRY)&CacheEntry->Data.Axp64); }
StackFrame->AddrFrame.Offset = Address; Context->IntSp = Address;
rval = TRUE; } } }
//
// get the return address
//
ContextSave = *Context; StackFrame->AddrReturn.Offset = StackFrame->AddrPC.Offset; qw = 0;
if (!WalkAlphaGetStackFrame( hProcess, &StackFrame->AddrReturn.Offset, &qw, &ContextSave, ReadMemory, GetModuleBase, GetFunctionEntry, &StackFrame->KdHelp, Use64) ) {
StackFrame->AddrReturn.Offset = 0;
}
//
// get the arguments to the function
//
StackFrame->Params[0] = ContextSave.IntA0; StackFrame->Params[1] = ContextSave.IntA1; StackFrame->Params[2] = ContextSave.IntA2; StackFrame->Params[3] = ContextSave.IntA3;
return rval;}
VOIDGetUnwindFunctionEntry( HANDLE hProcess, ULONG64 ControlPc, PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemory, PGET_MODULE_BASE_ROUTINE64 GetModuleBase, PFUNCTION_TABLE_ACCESS_ROUTINE64 GetFunctionEntry, BOOL Use64, FeCacheEntry* CacheEntry, PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY UnwindFunctionEntry, PULONG StackAdjust, PULONG64 FixedReturn )/*++
Routine Description:
This function returns a function entry (RUNTIME_FUNCTION) suitable for unwinding from ControlPc. It encapsulates the handling of primary and secondary function entries so that this processing is not duplicated in VirtualUnwind and other similar functions.
Arguments:
ControlPc - Supplies the address where control left the specified function.
FunctionEntry - Supplies the address of the function table entry for the specified function.
UnwindFunctionEntry - Supplies the address of a function table entry which will be setup with appropriate fields for unwinding from ControlPc
Return Value:
None.
--*/
{ ULONG EntryType = 0; PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY SecondaryFunctionEntry = NULL; ULONG64 AlternateProlog; FeCacheEntry LocalCache; PIMAGE_ALPHA64_RUNTIME_FUNCTION_ENTRY FunctionEntry; FunctionEntryCache* Cache; FeCacheEntry* SecCache;
*FixedReturn = 0; *StackAdjust = 0;
#if DBG
if (ControlPc & 0x3) { dbPrint("GetUnwindFunctionEntry: invalid PC for unwinding (low bits set): %16.8I64x\n", ControlPc); }#endif
Cache = GetFeCache(Use64 ? IMAGE_FILE_MACHINE_ALPHA64 : IMAGE_FILE_MACHINE_ALPHA, TRUE); // CacheEntry should never be null, but if it is create one that
// looks like a leaf entry for ControlPc
if (Cache == NULL || CacheEntry == NULL) {#if DBG
dbPrint("\nGetUnwindFunctionEntry: Null function table entry for unwinding\n");#endif
UnwindFunctionEntry->BeginAddress = ControlPc; UnwindFunctionEntry->EndAddress = ControlPc+4; UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ControlPc; return; }
// Work off a local copy of the function entry passed in
// as later function entry lookups may cause it to be
// evicted from the cache, invalidating the pointer.
LocalCache = *CacheEntry; CacheEntry = &LocalCache; FunctionEntry = &CacheEntry->Data.Axp64;
//
// Because of the secondary-to-primary function entry indirection applied by
// Find() ControlPc may not be within the range described
// by the supplied function entry. Call FindDirect()
// to recover the actual (secondary) function entry. If we don't get a
// valid associated function entry then process the unwind with the one
// supplied, trusting that the caller has supplied the given entry intentionally.
//
// A secondary function entry is a RUNTIME_FUNCTION entry where
// PrologEndAddress is not in the range of BeginAddress to EndAddress.
// There are three types of secondary function entries. They are
// distinquished by the Entry Type field (2 bits):
//
// ALPHA_RF_NOT_CONTIGUOUS - discontiguous code
// ALPHA_RF_ALT_ENT_PROLOG - alternate entry point prologue
// ALPHA_RF_NULL_CONTEXT - null-context code
//
if ((ControlPc < ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) || (ControlPc >= ALPHA_RF_END_ADDRESS(FunctionEntry))) {
// ControlPC is not in the range of the supplied function entry.
// Get the actual function entry which is expected to be the
// associated secondary function entry or a fixed return primary function.
#if DBG
if (tlsvar(DebugFunctionEntries)) { dbPrint("\nGetUnwindFunctionEntry:LookupDirectFunctionEntry(ControlPc=%.8I64x,Use64=%d)\n", ControlPc, Use64 ); }#endif
SecCache = Cache-> FindDirect( hProcess, ControlPc, ReadMemory, GetModuleBase, GetFunctionEntry ); if (SecCache != NULL) { SecondaryFunctionEntry = &SecCache->Data.Axp64; } else { SecondaryFunctionEntry = NULL; }
if (SecondaryFunctionEntry) {
FE_ShowRuntimeFunctionAxp64((SecCache, "GetUnwindFunctionEntry: LookupDirectFunctionEntry"));
// If this is a null-context tail region then unwind with a null-context-like descriptor
if ((ControlPc >= ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry)-(ALPHA_RF_NULL_CONTEXT_COUNT(SecondaryFunctionEntry)*4)) && (ControlPc < ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry))) {
// Use the secondary function entry with PrologEndAddress = BeginAddress.
// This ensures that the prologue is not reverse executed.
UnwindFunctionEntry->BeginAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); return; }
if ((SecondaryFunctionEntry->PrologEndAddress < ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry)) || (SecondaryFunctionEntry->PrologEndAddress > ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry))) {
// Got a secondary function entry as expected. But if indirection doesn't point
// to FunctionEntry then ignore it and use the caller supplied FunctionEntry.
if (ALPHA_RF_PROLOG_END_ADDRESS(SecondaryFunctionEntry) != CacheEntry->Address) { FE_ShowRuntimeFunctionAxp64((SecCache, "GetUnwindFunctionEntry: unexpected secondary function entry from LookupDirectFunctionEntry")); SecondaryFunctionEntry = NULL; } } else if (ALPHA_RF_IS_FIXED_RETURN(SecondaryFunctionEntry)) { // Got a fixed return entry. Switch to using the fixed return entry as the primary.
FunctionEntry = SecondaryFunctionEntry; CacheEntry = SecCache; SecondaryFunctionEntry = NULL;
} else {
// Got a primary function entry. Ignore it and use caller supplied FunctionEntry.
FE_ShowRuntimeFunctionAxp64((SecCache, "GetUnwindFunctionEntry: unexpected primary function entry from LookupDirectFunctionEntry")); SecondaryFunctionEntry = NULL; }#if DBG
} else { ShowRuntimeFunctionAxp64(SecCache, "GetUnwindFunctionEntry: LookupDirectFunctionEntry returned NULL");#endif
} } else {
// ControlPC is in the range of the supplied function entry.
// If this is a null-context tail region then unwind with a null-context-like descriptor
if ((ControlPc >= ALPHA_RF_END_ADDRESS(FunctionEntry)-(ALPHA_RF_NULL_CONTEXT_COUNT(FunctionEntry)*4)) && (ControlPc < ALPHA_RF_END_ADDRESS(FunctionEntry))) {
// Use the secondary function entry with PrologEndAddress = BeginAddress.
// This ensures that the prologue is not reverse executed.
UnwindFunctionEntry->BeginAddress = ALPHA_RF_BEGIN_ADDRESS(FunctionEntry); UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(FunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ALPHA_RF_BEGIN_ADDRESS(FunctionEntry); return; }
// Check if it is a secondary function entry. This shouldn't happen because
// LookupFunctionEntry is always supposed to return a primary function entry.
// But if we get passed a secondary, then switch to it's primary. However note
// that we've gone through this pass
if ((FunctionEntry->PrologEndAddress < ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) || (FunctionEntry->PrologEndAddress > ALPHA_RF_END_ADDRESS(FunctionEntry))) { SecondaryFunctionEntry = FunctionEntry; SecCache = Cache->ReadImage ( hProcess, ALPHA_RF_PROLOG_END_ADDRESS(SecondaryFunctionEntry), ReadMemory, GetModuleBase ); if (SecCache != NULL) { SecondaryFunctionEntry = &SecCache->Data.Axp64; } else { SecondaryFunctionEntry = NULL; } FE_ShowRuntimeFunctionAxp64((SecCache, "GetUnwindFunctionEntry: received secondary function entry")); } }
// FunctionEntry is now the primary function entry and if SecondaryFunctionEntry is
// not NULL then it is the secondary function entry that contains the ControlPC. Setup a
// copy of the FunctionEntry suitable for unwinding. By default use the supplied FunctionEntry.
if (SecondaryFunctionEntry) {
// Extract the secondary function entry type.
EntryType = ALPHA_RF_ENTRY_TYPE(SecondaryFunctionEntry);
if (EntryType == ALPHA_RF_NOT_CONTIGUOUS) { // The exception happened in the body of the procedure but in a non-contiguous
// section of code. Regardless of what entry point was used, it is normally valid
// to unwind using the primary entry point prologue. The only exception is when an
// alternate prologue is specified However, there may be an
// alternate prologue end addresss specified in which case unwind using this
// block as though it were the primary.
AlternateProlog = ALPHA_RF_ALT_PROLOG64(SecondaryFunctionEntry);
if ((AlternateProlog >= ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry)) && (AlternateProlog < ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry))) {
// If the control PC is in the alternate prologue, use the secondary.
// The control Pc is not in procedure context.
if ((ControlPc >= ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry)) && (ControlPc < ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry))) {
UnwindFunctionEntry->BeginAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = AlternateProlog; return; } }
// Fall out of the if statement to pick up the primary function entry below.
// This code is in-procedure-context and subject to the primary's prologue
// and exception handlers.
} else if (EntryType == ALPHA_RF_ALT_ENT_PROLOG) { // Exception occured in an alternate entry point prologue.
// Use the secondary function entry with a fixed-up PrologEndAddress.
UnwindFunctionEntry->BeginAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ALPHA_RF_END_ADDRESS(UnwindFunctionEntry);
// Check for an alternate prologue.
AlternateProlog = ALPHA_RF_ALT_PROLOG64(SecondaryFunctionEntry); if (AlternateProlog >= UnwindFunctionEntry->BeginAddress && AlternateProlog < UnwindFunctionEntry->EndAddress ) { // The prologue is only part of the procedure
UnwindFunctionEntry->PrologEndAddress = AlternateProlog; }
return;
} else if (EntryType == ALPHA_RF_NULL_CONTEXT) {
// Exception occured in null-context code associated with a primary function.
// Use the secondary function entry with a PrologEndAddress = BeginAddress.
// There is no prologue for null-context code.
*StackAdjust = ALPHA_RF_STACK_ADJUST(SecondaryFunctionEntry); UnwindFunctionEntry->BeginAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(SecondaryFunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ALPHA_RF_BEGIN_ADDRESS(SecondaryFunctionEntry); return; } }
// FunctionEntry is only null if there was an error fetching it from a passed in
// secondary function entry.
if (FunctionEntry == NULL) {#if DBG
dbPrint("\nGetUnwindFunctionEntry: Error in FetchFunctionEntry\n");#endif
UnwindFunctionEntry->BeginAddress = ControlPc; UnwindFunctionEntry->EndAddress = ControlPc+4; UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; UnwindFunctionEntry->PrologEndAddress = ControlPc; return; }
#if DBG
if (ALPHA_RF_BEGIN_ADDRESS(FunctionEntry) >= ALPHA_RF_END_ADDRESS(FunctionEntry)) { ShowRuntimeFunctionAxp64(CacheEntry, "GetUnwindFunctionEntry: Warning - BeginAddress < EndAddress."); } else if (FunctionEntry->PrologEndAddress < ALPHA_RF_BEGIN_ADDRESS(FunctionEntry)) { ShowRuntimeFunctionAxp64(CacheEntry, "GetUnwindFunctionEntry: Warning - PrologEndAddress < BeginAddress."); } else if (FunctionEntry->PrologEndAddress > ALPHA_RF_END_ADDRESS(FunctionEntry)) { ShowRuntimeFunctionAxp64(CacheEntry, "GetUnwindFunctionEntry: Warning - PrologEndAddress > EndAddress."); }#endif
// Use the primary function entry
*UnwindFunctionEntry = *FunctionEntry; UnwindFunctionEntry->EndAddress = ALPHA_RF_END_ADDRESS(UnwindFunctionEntry); // Remove null-context count
// If the primary has a fixed return address, pull that out now.
if (ALPHA_RF_IS_FIXED_RETURN(FunctionEntry)) { *FixedReturn = ALPHA_RF_FIXED_RETURN64(FunctionEntry); UnwindFunctionEntry->ExceptionHandler = 0; UnwindFunctionEntry->HandlerData = 0; }}
|
