arch/alpha/stacktrace.cc

   1 /*
   2  * Copyright (c) 2005 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <string>
  30
  31 #include "arch/alpha/isa_traits.hh"
  32 #include "arch/alpha/stacktrace.hh"
  33 #include "arch/alpha/vtophys.hh"
  34 #include "base/bitfield.hh"
  35 #include "base/trace.hh"
  36 #include "cpu/base.hh"
  37 #include "cpu/exec_context.hh"
  38
  39 using namespace std;
  40 using namespace AlphaISA;
  41
  42 ProcessInfo::ProcessInfo(ExecContext *_xc)
  43     : xc(_xc)
  44 {
  45     Addr addr = 0;
  46
  47     if (!xc->system->kernelSymtab->findAddress("thread_info_size", addr))
  48         panic("thread info not compiled into kernel\n");
  49     thread_info_size = *(int32_t *)vtomem(xc, addr, sizeof(int32_t));
  50
  51     if (!xc->system->kernelSymtab->findAddress("task_struct_size", addr))
  52         panic("thread info not compiled into kernel\n");
  53     task_struct_size = *(int32_t *)vtomem(xc, addr, sizeof(int32_t));
  54
  55     if (!xc->system->kernelSymtab->findAddress("thread_info_task", addr))
  56         panic("thread info not compiled into kernel\n");
  57     task_off = *(int32_t *)vtomem(xc, addr, sizeof(int32_t));
  58
  59     if (!xc->system->kernelSymtab->findAddress("task_struct_pid", addr))
  60         panic("thread info not compiled into kernel\n");
  61     pid_off = *(int32_t *)vtomem(xc, addr, sizeof(int32_t));
  62
  63     if (!xc->system->kernelSymtab->findAddress("task_struct_comm", addr))
  64         panic("thread info not compiled into kernel\n");
  65     name_off = *(int32_t *)vtomem(xc, addr, sizeof(int32_t));
  66 }
  67
  68 Addr
  69 ProcessInfo::task(Addr ksp) const
  70 {
  71     Addr base = ksp & ~0x3fff;
  72     if (base == ULL(0xfffffc0000000000))
  73         return 0;
  74
  75     Addr task;
  76     CopyOut(xc, &task, base + task_off, sizeof(task));
  77     return task;
  78 }
  79
  80 int
  81 ProcessInfo::pid(Addr ksp) const
  82 {
  83     Addr task = this->task(ksp);
  84     if (!task)
  85         return -1;
  86
  87     uint16_t pid;
  88     CopyOut(xc, &pid, task + pid_off, sizeof(pid));
  89     return pid;
  90 }
  91
  92 string
  93 ProcessInfo::name(Addr ksp) const
  94 {
  95     Addr task = this->task(ksp);
  96     if (!task)
  97         return "console";
  98
  99     char comm[256];
 100     CopyString(xc, comm, task + name_off, sizeof(comm));
 101     if (!comm[0])
 102         return "startup";
 103
 104     return comm;
 105 }
 106
 107 StackTrace::StackTrace()
 108     : xc(0), stack(64)
 109 {
 110 }
 111
 112 StackTrace::StackTrace(ExecContext *_xc, StaticInstPtr inst)
 113     : xc(0), stack(64)
 114 {
 115     trace(_xc, inst);
 116 }
 117
 118 StackTrace::~StackTrace()
 119 {
 120 }
 121
 122 void
 123 StackTrace::trace(ExecContext *_xc, bool is_call)
 124 {
 125     xc = _xc;
 126
 127     bool usermode = (xc->readMiscReg(AlphaISA::IPR_DTB_CM) & 0x18) != 0;
 128
 129     Addr pc = xc->regs.npc;
 130     bool kernel = xc->system->kernelStart <= pc && pc <= xc->system->kernelEnd;
 131
 132     if (usermode) {
 133         stack.push_back(user);
 134         return;
 135     }
 136
 137     if (!kernel) {
 138         stack.push_back(console);
 139         return;
 140     }
 141
 142     SymbolTable *symtab = xc->system->kernelSymtab;
 143     Addr ksp = xc->regs.intRegFile[TheISA::StackPointerReg];
 144     Addr bottom = ksp & ~0x3fff;
 145     Addr addr;
 146
 147     if (is_call) {
 148         if (!symtab->findNearestAddr(pc, addr))
 149             panic("could not find address %#x", pc);
 150
 151         stack.push_back(addr);
 152         pc = xc->regs.pc;
 153     }
 154
 155     Addr ra;
 156     int size;
 157
 158     while (ksp > bottom) {
 159         if (!symtab->findNearestAddr(pc, addr))
 160             panic("could not find symbol for pc=%#x", pc);
 161         assert(pc >= addr && "symbol botch: callpc < func");
 162
 163         stack.push_back(addr);
 164
 165         if (isEntry(addr))
 166             return;
 167
 168         if (decodePrologue(ksp, pc, addr, size, ra)) {
 169             if (!ra)
 170                 return;
 171
 172             if (size <= 0) {
 173                 stack.push_back(unknown);
 174                 return;
 175             }
 176
 177             pc = ra;
 178             ksp += size;
 179         } else {
 180             stack.push_back(unknown);
 181             return;
 182         }
 183
 184         bool kernel = xc->system->kernelStart <= pc &&
 185             pc <= xc->system->kernelEnd;
 186         if (!kernel)
 187             return;
 188
 189         if (stack.size() >= 1000)
 190             panic("unwinding too far");
 191     }
 192
 193     panic("unwinding too far");
 194 }
 195
 196 bool
 197 StackTrace::isEntry(Addr addr)
 198 {
 199     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp12))
 200         return true;
 201
 202     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp7))
 203         return true;
 204
 205     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp11))
 206         return true;
 207
 208     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp21))
 209         return true;
 210
 211     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp9))
 212         return true;
 213
 214     if (addr == xc->readMiscReg(AlphaISA::IPR_PALtemp2))
 215         return true;
 216
 217     return false;
 218 }
 219
 220 bool
 221 StackTrace::decodeStack(MachInst inst, int &disp)
 222 {
 223     // lda $sp, -disp($sp)
 224     //
 225     // Opcode<31:26> == 0x08
 226     // RA<25:21> == 30
 227     // RB<20:16> == 30
 228     // Disp<15:0>
 229     const MachInst mem_mask = 0xffff0000;
 230     const MachInst lda_pattern = 0x23de0000;
 231     const MachInst lda_disp_mask = 0x0000ffff;
 232
 233     // subq $sp, disp, $sp
 234     // addq $sp, disp, $sp
 235     //
 236     // Opcode<31:26> == 0x10
 237     // RA<25:21> == 30
 238     // Lit<20:13>
 239     // One<12> = 1
 240     // Func<11:5> == 0x20 (addq)
 241     // Func<11:5> == 0x29 (subq)
 242     // RC<4:0> == 30
 243     const MachInst intop_mask = 0xffe01fff;
 244     const MachInst addq_pattern = 0x43c0141e;
 245     const MachInst subq_pattern = 0x43c0153e;
 246     const MachInst intop_disp_mask = 0x001fe000;
 247     const int intop_disp_shift = 13;
 248
 249     if ((inst & mem_mask) == lda_pattern)
 250         disp = -sext<16>(inst & lda_disp_mask);
 251     else if ((inst & intop_mask) == addq_pattern)
 252         disp = -int((inst & intop_disp_mask) >> intop_disp_shift);
 253     else if ((inst & intop_mask) == subq_pattern)
 254         disp = int((inst & intop_disp_mask) >> intop_disp_shift);
 255     else
 256         return false;
 257
 258     return true;
 259 }
 260
 261 bool
 262 StackTrace::decodeSave(MachInst inst, int &reg, int &disp)
 263 {
 264     // lda $stq, disp($sp)
 265     //
 266     // Opcode<31:26> == 0x08
 267     // RA<25:21> == ?
 268     // RB<20:16> == 30
 269     // Disp<15:0>
 270     const MachInst stq_mask = 0xfc1f0000;
 271     const MachInst stq_pattern = 0xb41e0000;
 272     const MachInst stq_disp_mask = 0x0000ffff;
 273     const MachInst reg_mask = 0x03e00000;
 274     const int reg_shift = 21;
 275
 276     if ((inst & stq_mask) == stq_pattern) {
 277         reg = (inst & reg_mask) >> reg_shift;
 278         disp = sext<16>(inst & stq_disp_mask);
 279     } else {
 280         return false;
 281     }
 282
 283     return true;
 284 }
 285
 286 /*
 287  * Decode the function prologue for the function we're in, and note
 288  * which registers are stored where, and how large the stack frame is.
 289  */
 290 bool
 291 StackTrace::decodePrologue(Addr sp, Addr callpc, Addr func,
 292                            int &size, Addr &ra)
 293 {
 294     size = 0;
 295     ra = 0;
 296
 297     for (Addr pc = func; pc < callpc; pc += sizeof(MachInst)) {
 298         MachInst inst;
 299         CopyOut(xc, (uint8_t *)&inst, pc, sizeof(MachInst));
 300
 301         int reg, disp;
 302         if (decodeStack(inst, disp)) {
 303             if (size) {
 304                 // panic("decoding frame size again");
 305                 return true;
 306             }
 307             size += disp;
 308         } else if (decodeSave(inst, reg, disp)) {
 309             if (!ra && reg == ReturnAddressReg) {
 310                 CopyOut(xc, (uint8_t *)&ra, sp + disp, sizeof(Addr));
 311                 if (!ra) {
 312                     // panic("no return address value pc=%#x\n", pc);
 313                     return false;
 314                 }
 315             }
 316         }
 317     }
 318
 319     return true;
 320 }
 321
 322 #if TRACING_ON
 323 void
 324 StackTrace::dump()
 325 {
 326     StringWrap name(xc->cpu->name());
 327     SymbolTable *symtab = xc->system->kernelSymtab;
 328
 329     DPRINTFN("------ Stack ------\n");
 330
 331     string symbol;
 332     for (int i = 0, size = stack.size(); i < size; ++i) {
 333         Addr addr = stack[size - i - 1];
 334         if (addr == user)
 335             symbol = "user";
 336         else if (addr == console)
 337             symbol = "console";
 338         else if (addr == unknown)
 339             symbol = "unknown";
 340         else
 341             symtab->findSymbol(addr, symbol);
 342
 343         DPRINTFN("%#x: %s\n", addr, symbol);
 344     }
 345 }
 346 #endif