contrib/llvm/tools/lldb/source/Utility/ARM64_DWARF_Registers.cpp

   1 //===-- ARM64_DWARF_Registers.c ---------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <string.h>
  11
  12 #include "ARM64_DWARF_Registers.h"
  13
  14 using namespace lldb;
  15 using namespace lldb_private;
  16 using namespace arm64_dwarf;
  17
  18 const char *
  19 arm64_dwarf::GetRegisterName (unsigned reg_num, bool altnernate_name)
  20 {
  21     if (altnernate_name)
  22     {
  23         switch (reg_num)
  24         {
  25             case fp: return "x29";
  26             case lr: return "x30";
  27             case sp: return "x31";
  28             default:
  29                 break;
  30         }
  31         return nullptr;
  32     }
  33
  34     switch (reg_num)
  35     {
  36         case x0:       return "x0";
  37         case x1:       return "x1";
  38         case x2:       return "x2";
  39         case x3:       return "x3";
  40         case x4:       return "x4";
  41         case x5:       return "x5";
  42         case x6:       return "x6";
  43         case x7:       return "x7";
  44         case x8:       return "x8";
  45         case x9:       return "x9";
  46         case x10:      return "x10";
  47         case x11:      return "x11";
  48         case x12:      return "x12";
  49         case x13:      return "x13";
  50         case x14:      return "x14";
  51         case x15:      return "x15";
  52         case x16:      return "x16";
  53         case x17:      return "x17";
  54         case x18:      return "x18";
  55         case x19:      return "x19";
  56         case x20:      return "x20";
  57         case x21:      return "x21";
  58         case x22:      return "x22";
  59         case x23:      return "x23";
  60         case x24:      return "x24";
  61         case x25:      return "x25";
  62         case x26:      return "x26";
  63         case x27:      return "x27";
  64         case x28:      return "x28";
  65         case fp:       return "fp";
  66         case lr:       return "lr";
  67         case sp:       return "sp";
  68         case pc:       return "pc";
  69         case cpsr:     return "cpsr";
  70         case v0:       return "v0";
  71         case v1:       return "v1";
  72         case v2:       return "v2";
  73         case v3:       return "v3";
  74         case v4:       return "v4";
  75         case v5:       return "v5";
  76         case v6:       return "v6";
  77         case v7:       return "v7";
  78         case v8:       return "v8";
  79         case v9:       return "v9";
  80         case v10:      return "v10";
  81         case v11:      return "v11";
  82         case v12:      return "v12";
  83         case v13:      return "v13";
  84         case v14:      return "v14";
  85         case v15:      return "v15";
  86         case v16:      return "v16";
  87         case v17:      return "v17";
  88         case v18:      return "v18";
  89         case v19:      return "v19";
  90         case v20:      return "v20";
  91         case v21:      return "v21";
  92         case v22:      return "v22";
  93         case v23:      return "v23";
  94         case v24:      return "v24";
  95         case v25:      return "v25";
  96         case v26:      return "v26";
  97         case v27:      return "v27";
  98         case v28:      return "v28";
  99         case v29:      return "v29";
 100         case v30:      return "v30";
 101         case v31:      return "v31";
 102     }
 103     return nullptr;
 104 }
 105
 106 bool
 107 arm64_dwarf::GetRegisterInfo (unsigned reg_num, RegisterInfo &reg_info)
 108 {
 109     ::memset (&reg_info, 0, sizeof(RegisterInfo));
 110     ::memset (reg_info.kinds, LLDB_INVALID_REGNUM, sizeof(reg_info.kinds));
 111
 112     if (reg_num >= x0 && reg_num <= pc)
 113     {
 114         reg_info.byte_size = 8;
 115         reg_info.format = eFormatHex;
 116         reg_info.encoding = eEncodingUint;
 117     }
 118     else if (reg_num >= v0 && reg_num <= v31)
 119     {
 120         reg_info.byte_size = 16;
 121         reg_info.format = eFormatVectorOfFloat32;
 122         reg_info.encoding = eEncodingVector;
 123     }
 124     else if (reg_num == cpsr)
 125     {
 126         reg_info.byte_size = 4;
 127         reg_info.format = eFormatHex;
 128         reg_info.encoding = eEncodingUint;
 129     }
 130     else
 131     {
 132         return false;
 133     }
 134
 135     reg_info.name = arm64_dwarf::GetRegisterName (reg_num, false);
 136     reg_info.alt_name = arm64_dwarf::GetRegisterName (reg_num, true);
 137     reg_info.kinds[eRegisterKindDWARF] = reg_num;
 138
 139     switch (reg_num)
 140     {
 141     case fp: reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; break;
 142     case lr: reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; break;
 143     case sp: reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; break;
 144     case pc: reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; break;
 145     default: break;
 146     }
 147     return true;
 148 }