intel Pin：分析例程检测到 ah 寄存器而不是 rsp (REG_STACK_PTR)

Question

几天前我问了问题。

我想获得堆栈分配大小（在函数创建之后）。答案建议做：

if((INS_Opcode(ins) == XED_ICLASS_ADD || INS_Opcode(ins) == XED_ICLASS_SUB) && 
   REG(INS_OperandReg(ins, 0)) == REG_STACK_PTR && INS_OperandIsImmediate(ins, 1)

这在理论上是正确的并且确实有道理。但是，它在实践中不起作用（如果我错了，请纠正我）。如果我删除 REG(INS_OperandReg(ins, 0)) == REG_STACK_PTR 检查，它工作得很好。为什么？因为当使用 REG(INS_OperandReg(ins, 0)) 检测它时，pin 不会检测到 REG_STACK_PTR 寄存器。相反，它检测到 ah（我认为是 RAX），当我检查 add rsp, 0xffffffffffffff80 指令时（因此，每次它给出：register: ah），如我的输出所示下面：

in
register: rbp
40051e  push rbp
register: *invalid*
value: -128
40051f  mov rbp, rsp
register: ah
400522  add rsp, 0xffffffffffffff80
register: *invalid*
400526  mov dword ptr [rbp-0x28], 0x7
register: *invalid*
40052d  mov dword ptr [rbp-0x64], 0x9
register: eax
400534  mov eax, 0x0
register: *invalid*
400539  call 0x4004e6
register: rbp
4004e6  push rbp
register: *invalid*
value: 64
4004e7  mov rbp, rsp
register: ah
4004ea  sub rsp, 0x40
register: *invalid*
4004ee  mov dword ptr [rbp-0xc], 0x4
register: rax
4004f5  lea rax, ptr [rbp-0xc]
register: *invalid*
4004f9  mov qword ptr [rbp-0x8], rax
register: rax
4004fd  mov rax, qword ptr [rbp-0x8]
register: eax
400501  mov eax, dword ptr [rax]
register: *invalid*
400503  mov esi, eax
register: edi
400505  mov edi, 0x4005d0
register: eax
40050a  mov eax, 0x0
register: rdi
40050f  call 0x4003f0
register: rdi
4003f0  jmp qword ptr [rip+0x200c22]
register: *invalid*
4003f6  push 0x0
register: *invalid*
4003fb  jmp 0x4003e0
register: *invalid*
4003e0  push qword ptr [rip+0x200c22]
register: rdi
4003e6  jmp qword ptr [rip+0x200c24]
4
register: *invalid*
400514  mov dword ptr [rbp-0x3c], 0x3
40051b  nop
register: *invalid*
40051c  leave 
register: *invalid*
40051d  ret 
register: eax
40053e  mov eax, 0x0
register: *invalid*
400543  leave 
out

好吧，有趣的是它对每次出现的 rsp 都这样做（即它检测到 ah 而不是 rsp）。此外，它总是打印指令 400522 add rsp, 0xffffffffffffff80，包括 rsp（那么，为什么这里不打印 ah？）

如果 ah 以某种方式代表 rsp，那么我总是可以使用 REG(INS_OperandReg(ins, 0)) == REG_AH 来检测 ah。但是，我想了解这里发生了什么。

我的代码：

#include <iostream>
#include <fstream>
#include "pin.H"
#include <unordered_map>

// key to open the main Routine
static uint32_t key = 0;

// Ins object mapping
class Insr
{
private:
  // Disassembled instruction
    string insDis;
  INS ins;

public:
    Insr(string insDis, INS ins) { this->insDis = insDis; this->ins = ins;}
    string get_insDis() { return insDis;}
  INS get_ins() { return ins;}
};

// Stack for the Insr structure
static std::unordered_map<ADDRINT, Insr*> insstack;

// This function is called before every instruction is executed
VOID protect(uint64_t addr)
{
  if (addr > 0x700000000000)
        return;
    if (!key)
        return;
  // Initialize the diassembled instruction
  string insdis = insstack[addr]->get_insDis();
  INS ins = insstack[addr]->get_ins();
    if (INS_OperandCount(ins) > 0)
    {
        if (REG(INS_OperandReg(ins, 0)) == REG_AH)
            std::cout << "register: " << REG_StringShort(REG(INS_OperandReg(ins, 0))) << '\n';
    }

  if((INS_Opcode(ins) == XED_ICLASS_ADD || INS_Opcode(ins) == XED_ICLASS_SUB) &&
   INS_OperandIsImmediate(ins, 1))
    {
      int value = INS_OperandImmediate(ins, 1);
        std::cout << "value: " << dec<<value << '\n';
    }
  std::cout << hex <<addr << "\t" << insdis << std::endl;
}

// Pin calls this function every time a new instruction is encountered
VOID Instruction(INS ins, VOID *v)
{
        if (INS_Address(ins) > 0x700000000000)
        return;

    insstack.insert(std::make_pair(INS_Address(ins), new Insr(string(INS_Disassemble(ins)),
    ins)));
    // if (REG_valid_for_iarg_reg_value(INS_MemoryIndexReg(ins)))
    //   std::cout << "true" << '\n';
    // Insert a call to docount before every instruction, no arguments are passed
    INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)protect, IARG_ADDRINT, INS_Address(ins),
  IARG_END);
}

// Lock Routine
void mutex_lock()
{
key = 0;
std::cout<<"out\n";
}
void mutex_unlock()
{
    key = 1;
    std::cout<<"in\n";
}

void Routine(RTN rtn, VOID *V)
{
    if (RTN_Name(rtn) == "main")
    {
        RTN_Open(rtn);
        RTN_InsertCall(rtn, IPOINT_BEFORE, (AFUNPTR)mutex_unlock, IARG_END);
        RTN_InsertCall(rtn, IPOINT_AFTER, (AFUNPTR)mutex_lock, IARG_END);
        RTN_Close(rtn);
    }
}

INT32 Usage()
{
    cerr << "This tool counts the number of dynamic instructions executed" << endl;
    cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
    return -1;
}

int main(int argc, char * argv[])
{
    // Initialize the symbol table
    PIN_InitSymbols();

    // Initialize pin
    if (PIN_Init(argc, argv)) return Usage();

    PIN_SetSyntaxIntel();

    // Routine instrumentation
    RTN_AddInstrumentFunction(Routine, 0);

    // Register Instruction to be called to instrument instructions
    INS_AddInstrumentFunction(Instruction, 0);

    // Start the program, never returns
    PIN_StartProgram();

    return 0;
}

我对此没有什么问题。

我如何理解这种行为？如果我愿意，如何检测 rsp？最后，指令如何打印rsp，但REG(INS_OperandReg(ins, 0)) == REG_STACK_PTR却检测不到？

Answer 1

INS 对象仅在检测例程内部有效，例如您的 Instruction 例程。 INS 类型只不过是一个标识指令的 32 位整数。 Pin 运行时在内部维护一个 table 将这些 32 位整数映射到特定的静态指令。每当它要调用检测例程时，它都会创建这样一个 table 。当检测例程 returns 时，无法保证这些标识符中的任何一个映射到相同的静态指令，它们甚至可能无效。因此，当您在以下代码行中保存 INS 对象的副本时：

insstack.insert(std::make_pair(INS_Address(ins), new Insr(string(INS_Disassemble(ins)),
    ins)));

该副本仅在 Instruction 例程的同一实例中有用。下次调用 Instruction 例程（或任何其他检测例程）时，指令标识符可能会重新用于其他指令。

如果你真的想将指令传递给分析例程，你有两个选择：

将指令的实际字节复制到缓冲区并传递缓冲区的地址，然后使用 XED 对其进行解码 API。
传递指令的地址，然后使用 XED API 对其进行解码。如果指令保证稍后在同一位置可用，则此方法有效。

intel Pin：分析例程检测到 ah 寄存器而不是 rsp (REG_STACK_PTR)

intel Pin: analysis routine detects ah register instead of rsp (REG_STACK_PTR)

c

c++

x86

profiling

intel-pin