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