src/arch/mips/stacktrace.cc

   1 /*
   2  * Copyright (c) 2004-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/mips/isa_traits.hh"
  34 #include "arch/mips/stacktrace.hh"
  35 #include "arch/mips/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 MipsISA;
  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
  75 Addr
  76 ProcessInfo::task(Addr ksp) const
  77 {
  78     Addr base = ksp & ~0x3fff;
  79     if (base == ULL(0xfffffc0000000000))
  80         return 0;
  81
  82     Addr tsk;
  83
  84     VirtualPort *vp;
  85
  86     vp = tc->getVirtPort();
  87     tsk = vp->readGtoH<Addr>(base + task_off);
  88
  89     return tsk;
  90 }
  91
  92 int
  93 ProcessInfo::pid(Addr ksp) const
  94 {
  95     Addr task = this->task(ksp);
  96     if (!task)
  97         return -1;
  98
  99     uint16_t pd;
 100
 101     VirtualPort *vp;
 102
 103     vp = tc->getVirtPort();
 104     pd = vp->readGtoH<uint16_t>(task + pid_off);
 105
 106     return pd;
 107 }
 108
 109 string
 110 ProcessInfo::name(Addr ksp) const
 111 {
 112     Addr task = this->task(ksp);
 113     if (!task)
 114         return "console";
 115
 116     char comm[256];
 117     CopyStringOut(tc, comm, task + name_off, sizeof(comm));
 118     if (!comm[0])
 119         return "startup";
 120
 121     return comm;
 122 }
 123
 124 StackTrace::StackTrace()
 125     : tc(0), stack(64)
 126 {
 127 }
 128
 129 StackTrace::StackTrace(ThreadContext *_tc, StaticInstPtr inst)
 130     : tc(0), stack(64)
 131 {
 132     trace(_tc, inst);
 133 }
 134
 135 StackTrace::~StackTrace()
 136 {
 137 }
 138
 139 void
 140 StackTrace::trace(ThreadContext *_tc, bool is_call)
 141 {
 142     tc = _tc;
 143     /* FIXME - Jaidev - What is IPR_DTB_CM in Alpha? */
 144     bool usermode = 0;
 145       //(tc->readMiscReg(MipsISA::IPR_DTB_CM) & 0x18) != 0;
 146
 147 //     Addr pc = tc->readNextPC();
 148 //     bool kernel = tc->getSystemPtr()->kernelStart <= pc &&
 149 //         pc <= tc->getSystemPtr()->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 = tc->getSystemPtr()->kernelSymtab;
 162 //     Addr ksp = tc->readIntReg(MipsISA::StackPointerReg);
 163 //     Addr bottom = ksp & ~0x3fff;
 164 //     Addr addr;
 165
 166 //     if (is_call) {
 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 //     Addr ra;
 175 //     int size;
 176
 177 //     while (ksp > bottom) {
 178 //         if (!symtab->findNearestAddr(pc, addr))
 179 //             panic("could not find symbol for pc=%#x", pc);
 180 //         assert(pc >= addr && "symbol botch: callpc < func");
 181
 182 //         stack.push_back(addr);
 183
 184 //         if (isEntry(addr))
 185 //             return;
 186
 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 = tc->getSystemPtr()->kernelStart <= pc &&
 204 //             pc <= tc->getSystemPtr()->kernelEnd;
 205 //         if (!kernel)
 206 //             return;
 207
 208 //         if (stack.size() >= 1000)
 209 //             panic("unwinding too far");
 210 //     }
 211
 212 //     panic("unwinding too far");
 213 }
 214
 215 bool
 216 StackTrace::isEntry(Addr addr)
 217 {
 218   /*    if (addr == tc->readMiscReg(MipsISA::IPR_PALtemp2))
 219         return true;*/
 220
 221     return false;
 222 }
 223
 224 bool
 225 StackTrace::decodeStack(MachInst inst, int &disp)
 226 {
 227     // lda $sp, -disp($sp)
 228     //
 229     // Opcode<31:26> == 0x08
 230     // RA<25:21> == 30
 231     // RB<20:16> == 30
 232     // Disp<15:0>
 233     const MachInst mem_mask = 0xffff0000;
 234     const MachInst lda_pattern = 0x23de0000;
 235     const MachInst lda_disp_mask = 0x0000ffff;
 236
 237     // subq $sp, disp, $sp
 238     // addq $sp, disp, $sp
 239     //
 240     // Opcode<31:26> == 0x10
 241     // RA<25:21> == 30
 242     // Lit<20:13>
 243     // One<12> = 1
 244     // Func<11:5> == 0x20 (addq)
 245     // Func<11:5> == 0x29 (subq)
 246     // RC<4:0> == 30
 247     const MachInst intop_mask = 0xffe01fff;
 248     const MachInst addq_pattern = 0x43c0141e;
 249     const MachInst subq_pattern = 0x43c0153e;
 250     const MachInst intop_disp_mask = 0x001fe000;
 251     const int intop_disp_shift = 13;
 252
 253     if ((inst & mem_mask) == lda_pattern)
 254         disp = -sext<16>(inst & lda_disp_mask);
 255     else if ((inst & intop_mask) == addq_pattern)
 256         disp = -int((inst & intop_disp_mask) >> intop_disp_shift);
 257     else if ((inst & intop_mask) == subq_pattern)
 258         disp = int((inst & intop_disp_mask) >> intop_disp_shift);
 259     else
 260         return false;
 261
 262     return true;
 263 }
 264
 265 bool
 266 StackTrace::decodeSave(MachInst inst, int &reg, int &disp)
 267 {
 268     // lda $stq, disp($sp)
 269     //
 270     // Opcode<31:26> == 0x08
 271     // RA<25:21> == ?
 272     // RB<20:16> == 30
 273     // Disp<15:0>
 274     const MachInst stq_mask = 0xfc1f0000;
 275     const MachInst stq_pattern = 0xb41e0000;
 276     const MachInst stq_disp_mask = 0x0000ffff;
 277     const MachInst reg_mask = 0x03e00000;
 278     const int reg_shift = 21;
 279
 280     if ((inst & stq_mask) == stq_pattern) {
 281         reg = (inst & reg_mask) >> reg_shift;
 282         disp = sext<16>(inst & stq_disp_mask);
 283     } else {
 284         return false;
 285     }
 286
 287     return true;
 288 }
 289
 290 /*
 291  * Decode the function prologue for the function we're in, and note
 292  * which registers are stored where, and how large the stack frame is.
 293  */
 294 bool
 295 StackTrace::decodePrologue(Addr sp, Addr callpc, Addr func,
 296                            int &size, Addr &ra)
 297 {
 298     size = 0;
 299     ra = 0;
 300
 301     for (Addr pc = func; pc < callpc; pc += sizeof(MachInst)) {
 302         MachInst inst;
 303         CopyOut(tc, (uint8_t *)&inst, pc, sizeof(MachInst));
 304
 305         int reg, disp;
 306         if (decodeStack(inst, disp)) {
 307             if (size) {
 308                 // panic("decoding frame size again");
 309                 return true;
 310             }
 311             size += disp;
 312         } else if (decodeSave(inst, reg, disp)) {
 313             if (!ra && reg == ReturnAddressReg) {
 314                 CopyOut(tc, (uint8_t *)&ra, sp + disp, sizeof(Addr));
 315                 if (!ra) {
 316                     // panic("no return address value pc=%#x\n", pc);
 317                     return false;
 318                 }
 319             }
 320         }
 321     }
 322
 323     return true;
 324 }
 325
 326 #if TRACING_ON
 327 void
 328 StackTrace::dump()
 329 {
 330     StringWrap name(tc->getCpuPtr()->name());
 331 //     SymbolTable *symtab = tc->getSystemPtr()->kernelSymtab;
 332
 333     DPRINTFN("------ Stack ------\n");
 334
 335 //     string symbol;
 336 //     for (int i = 0, size = stack.size(); i < size; ++i) {
 337 //         Addr addr = stack[size - i - 1];
 338 //         if (addr == user)
 339 //             symbol = "user";
 340 //         else if (addr == console)
 341 //             symbol = "console";
 342 //         else if (addr == unknown)
 343 //             symbol = "unknown";
 344 //         else
 345 //             symtab->findSymbol(addr, symbol);
 346
 347 //         DPRINTFN("%#x: %s\n", addr, symbol);
 348 //     }
 349 }
 350 #endif