src/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  * Authors: Nathan Binkert
  29  */
  30
  31 #include <string>
  32
  33 #include "arch/alpha/isa_traits.hh"
  34 #include "arch/alpha/stacktrace.hh"
  35 #include "arch/alpha/vtophys.hh"
  36 #include "base/bitfield.hh"
  37 #include "base/trace.hh"
  38 #include "cpu/base.hh"
  39 #include "cpu/thread_context.hh"
  40 #include "sim/system.hh"
  41
  42 using namespace std;
  43 using namespace AlphaISA;
  44
  45 ProcessInfo::ProcessInfo(ThreadContext *_tc)
  46     : tc(_tc)
  47 {
  48     Addr addr = 0;
  49
  50     VirtualPort *vp;
  51
  52     vp = tc->getVirtPort();
  53
  54     if (!tc->getSystemPtr()->kernelSymtab->findAddress("thread_info_size", addr))
  55         panic("thread info not compiled into kernel\n");
  56     thread_info_size = vp->readGtoH<int32_t>(addr);
  57
  58     if (!tc->getSystemPtr()->kernelSymtab->findAddress("task_struct_size", addr))
  59         panic("thread info not compiled into kernel\n");
  60     task_struct_size = vp->readGtoH<int32_t>(addr);
  61
  62     if (!tc->getSystemPtr()->kernelSymtab->findAddress("thread_info_task", addr))
  63         panic("thread info not compiled into kernel\n");
  64     task_off = vp->readGtoH<int32_t>(addr);
  65
  66     if (!tc->getSystemPtr()->kernelSymtab->findAddress("task_struct_pid", addr))
  67         panic("thread info not compiled into kernel\n");
  68     pid_off = vp->readGtoH<int32_t>(addr);
  69
  70     if (!tc->getSystemPtr()->kernelSymtab->findAddress("task_struct_comm", addr))
  71         panic("thread info not compiled into kernel\n");
  72     name_off = vp->readGtoH<int32_t>(addr);
  73
  74     tc->delVirtPort(vp);
  75 }
  76
  77 Addr
  78 ProcessInfo::task(Addr ksp) const
  79 {
  80     Addr base = ksp & ~0x3fff;
  81     if (base == ULL(0xfffffc0000000000))
  82         return 0;
  83
  84     Addr tsk;
  85
  86     VirtualPort *vp;
  87
  88     vp = tc->getVirtPort();
  89     tsk = vp->readGtoH<Addr>(base + task_off);
  90     tc->delVirtPort(vp);
  91
  92     return tsk;
  93 }
  94
  95 int
  96 ProcessInfo::pid(Addr ksp) const
  97 {
  98     Addr task = this->task(ksp);
  99     if (!task)
 100         return -1;
 101
 102     uint16_t pd;
 103
 104     VirtualPort *vp;
 105
 106     vp = tc->getVirtPort();
 107     pd = vp->readGtoH<uint16_t>(task + pid_off);
 108     tc->delVirtPort(vp);
 109
 110     return pd;
 111 }
 112
 113 string
 114 ProcessInfo::name(Addr ksp) const
 115 {
 116     Addr task = this->task(ksp);
 117     if (!task)
 118         return "console";
 119
 120     char comm[256];
 121     CopyStringOut(tc, comm, task + name_off, sizeof(comm));
 122     if (!comm[0])
 123         return "startup";
 124
 125     return comm;
 126 }
 127
 128 StackTrace::StackTrace()
 129     : tc(0), stack(64)
 130 {
 131 }
 132
 133 StackTrace::StackTrace(ThreadContext *_tc, StaticInstPtr inst)
 134     : tc(0), stack(64)
 135 {
 136     trace(_tc, inst);
 137 }
 138
 139 StackTrace::~StackTrace()
 140 {
 141 }
 142
 143 void
 144 StackTrace::trace(ThreadContext *_tc, bool is_call)
 145 {
 146     tc = _tc;
 147
 148     bool usermode = (tc->readMiscReg(AlphaISA::IPR_DTB_CM) & 0x18) != 0;
 149
 150     Addr pc = tc->readNextPC();
 151     bool kernel = tc->getSystemPtr()->kernelStart <= pc &&
 152         pc <= tc->getSystemPtr()->kernelEnd;
 153
 154     if (usermode) {
 155         stack.push_back(user);
 156         return;
 157     }
 158
 159     if (!kernel) {
 160         stack.push_back(console);
 161         return;
 162     }
 163
 164     SymbolTable *symtab = tc->getSystemPtr()->kernelSymtab;
 165     Addr ksp = tc->readIntReg(TheISA::StackPointerReg);
 166     Addr bottom = ksp & ~0x3fff;
 167     Addr addr;
 168
 169     if (is_call) {
 170         if (!symtab->findNearestAddr(pc, addr))
 171             panic("could not find address %#x", pc);
 172
 173         stack.push_back(addr);
 174         pc = tc->readPC();
 175     }
 176
 177     Addr ra;
 178     int size;
 179
 180     while (ksp > bottom) {
 181         if (!symtab->findNearestAddr(pc, addr))
 182             panic("could not find symbol for pc=%#x", pc);
 183         assert(pc >= addr && "symbol botch: callpc < func");
 184
 185         stack.push_back(addr);
 186
 187         if (isEntry(addr))
 188             return;
 189
 190         if (decodePrologue(ksp, pc, addr, size, ra)) {
 191             if (!ra)
 192                 return;
 193
 194             if (size <= 0) {
 195                 stack.push_back(unknown);
 196                 return;
 197             }
 198
 199             pc = ra;
 200             ksp += size;
 201         } else {
 202             stack.push_back(unknown);
 203             return;
 204         }
 205
 206         bool kernel = tc->getSystemPtr()->kernelStart <= pc &&
 207             pc <= tc->getSystemPtr()->kernelEnd;
 208         if (!kernel)
 209             return;
 210
 211         if (stack.size() >= 1000)
 212             panic("unwinding too far");
 213     }
 214
 215     panic("unwinding too far");
 216 }
 217
 218 bool
 219 StackTrace::isEntry(Addr addr)
 220 {
 221     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp12))
 222         return true;
 223
 224     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp7))
 225         return true;
 226
 227     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp11))
 228         return true;
 229
 230     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp21))
 231         return true;
 232
 233     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp9))
 234         return true;
 235
 236     if (addr == tc->readMiscReg(AlphaISA::IPR_PALtemp2))
 237         return true;
 238
 239     return false;
 240 }
 241
 242 bool
 243 StackTrace::decodeStack(MachInst inst, int &disp)
 244 {
 245     // lda $sp, -disp($sp)
 246     //
 247     // Opcode<31:26> == 0x08
 248     // RA<25:21> == 30
 249     // RB<20:16> == 30
 250     // Disp<15:0>
 251     const MachInst mem_mask = 0xffff0000;
 252     const MachInst lda_pattern = 0x23de0000;
 253     const MachInst lda_disp_mask = 0x0000ffff;
 254
 255     // subq $sp, disp, $sp
 256     // addq $sp, disp, $sp
 257     //
 258     // Opcode<31:26> == 0x10
 259     // RA<25:21> == 30
 260     // Lit<20:13>
 261     // One<12> = 1
 262     // Func<11:5> == 0x20 (addq)
 263     // Func<11:5> == 0x29 (subq)
 264     // RC<4:0> == 30
 265     const MachInst intop_mask = 0xffe01fff;
 266     const MachInst addq_pattern = 0x43c0141e;
 267     const MachInst subq_pattern = 0x43c0153e;
 268     const MachInst intop_disp_mask = 0x001fe000;
 269     const int intop_disp_shift = 13;
 270
 271     if ((inst & mem_mask) == lda_pattern)
 272         disp = -sext<16>(inst & lda_disp_mask);
 273     else if ((inst & intop_mask) == addq_pattern)
 274         disp = -int((inst & intop_disp_mask) >> intop_disp_shift);
 275     else if ((inst & intop_mask) == subq_pattern)
 276         disp = int((inst & intop_disp_mask) >> intop_disp_shift);
 277     else
 278         return false;
 279
 280     return true;
 281 }
 282
 283 bool
 284 StackTrace::decodeSave(MachInst inst, int &reg, int &disp)
 285 {
 286     // lda $stq, disp($sp)
 287     //
 288     // Opcode<31:26> == 0x08
 289     // RA<25:21> == ?
 290     // RB<20:16> == 30
 291     // Disp<15:0>
 292     const MachInst stq_mask = 0xfc1f0000;
 293     const MachInst stq_pattern = 0xb41e0000;
 294     const MachInst stq_disp_mask = 0x0000ffff;
 295     const MachInst reg_mask = 0x03e00000;
 296     const int reg_shift = 21;
 297
 298     if ((inst & stq_mask) == stq_pattern) {
 299         reg = (inst & reg_mask) >> reg_shift;
 300         disp = sext<16>(inst & stq_disp_mask);
 301     } else {
 302         return false;
 303     }
 304
 305     return true;
 306 }
 307
 308 /*
 309  * Decode the function prologue for the function we're in, and note
 310  * which registers are stored where, and how large the stack frame is.
 311  */
 312 bool
 313 StackTrace::decodePrologue(Addr sp, Addr callpc, Addr func,
 314                            int &size, Addr &ra)
 315 {
 316     size = 0;
 317     ra = 0;
 318
 319     for (Addr pc = func; pc < callpc; pc += sizeof(MachInst)) {
 320         MachInst inst;
 321         CopyOut(tc, (uint8_t *)&inst, pc, sizeof(MachInst));
 322
 323         int reg, disp;
 324         if (decodeStack(inst, disp)) {
 325             if (size) {
 326                 // panic("decoding frame size again");
 327                 return true;
 328             }
 329             size += disp;
 330         } else if (decodeSave(inst, reg, disp)) {
 331             if (!ra && reg == ReturnAddressReg) {
 332                 CopyOut(tc, (uint8_t *)&ra, sp + disp, sizeof(Addr));
 333                 if (!ra) {
 334                     // panic("no return address value pc=%#x\n", pc);
 335                     return false;
 336                 }
 337             }
 338         }
 339     }
 340
 341     return true;
 342 }
 343
 344 #if TRACING_ON
 345 void
 346 StackTrace::dump()
 347 {
 348     StringWrap name(tc->getCpuPtr()->name());
 349     SymbolTable *symtab = tc->getSystemPtr()->kernelSymtab;
 350
 351     DPRINTFN("------ Stack ------\n");
 352
 353     string symbol;
 354     for (int i = 0, size = stack.size(); i < size; ++i) {
 355         Addr addr = stack[size - i - 1];
 356         if (addr == user)
 357             symbol = "user";
 358         else if (addr == console)
 359             symbol = "console";
 360         else if (addr == unknown)
 361             symbol = "unknown";
 362         else
 363             symtab->findSymbol(addr, symbol);
 364
 365         DPRINTFN("%#x: %s\n", addr, symbol);
 366     }
 367 }
 368 #endif