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

   1 //===-- ARM64_DWARF_Registers.cpp -------------------------------*- 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 *arm64_dwarf::GetRegisterName(unsigned reg_num,
  19                                          bool altnernate_name) {
  20   if (altnernate_name) {
  21     switch (reg_num) {
  22     case fp:
  23       return "x29";
  24     case lr:
  25       return "x30";
  26     case sp:
  27       return "x31";
  28     default:
  29       break;
  30     }
  31     return nullptr;
  32   }
  33
  34   switch (reg_num) {
  35   case x0:
  36     return "x0";
  37   case x1:
  38     return "x1";
  39   case x2:
  40     return "x2";
  41   case x3:
  42     return "x3";
  43   case x4:
  44     return "x4";
  45   case x5:
  46     return "x5";
  47   case x6:
  48     return "x6";
  49   case x7:
  50     return "x7";
  51   case x8:
  52     return "x8";
  53   case x9:
  54     return "x9";
  55   case x10:
  56     return "x10";
  57   case x11:
  58     return "x11";
  59   case x12:
  60     return "x12";
  61   case x13:
  62     return "x13";
  63   case x14:
  64     return "x14";
  65   case x15:
  66     return "x15";
  67   case x16:
  68     return "x16";
  69   case x17:
  70     return "x17";
  71   case x18:
  72     return "x18";
  73   case x19:
  74     return "x19";
  75   case x20:
  76     return "x20";
  77   case x21:
  78     return "x21";
  79   case x22:
  80     return "x22";
  81   case x23:
  82     return "x23";
  83   case x24:
  84     return "x24";
  85   case x25:
  86     return "x25";
  87   case x26:
  88     return "x26";
  89   case x27:
  90     return "x27";
  91   case x28:
  92     return "x28";
  93   case fp:
  94     return "fp";
  95   case lr:
  96     return "lr";
  97   case sp:
  98     return "sp";
  99   case pc:
 100     return "pc";
 101   case cpsr:
 102     return "cpsr";
 103   case v0:
 104     return "v0";
 105   case v1:
 106     return "v1";
 107   case v2:
 108     return "v2";
 109   case v3:
 110     return "v3";
 111   case v4:
 112     return "v4";
 113   case v5:
 114     return "v5";
 115   case v6:
 116     return "v6";
 117   case v7:
 118     return "v7";
 119   case v8:
 120     return "v8";
 121   case v9:
 122     return "v9";
 123   case v10:
 124     return "v10";
 125   case v11:
 126     return "v11";
 127   case v12:
 128     return "v12";
 129   case v13:
 130     return "v13";
 131   case v14:
 132     return "v14";
 133   case v15:
 134     return "v15";
 135   case v16:
 136     return "v16";
 137   case v17:
 138     return "v17";
 139   case v18:
 140     return "v18";
 141   case v19:
 142     return "v19";
 143   case v20:
 144     return "v20";
 145   case v21:
 146     return "v21";
 147   case v22:
 148     return "v22";
 149   case v23:
 150     return "v23";
 151   case v24:
 152     return "v24";
 153   case v25:
 154     return "v25";
 155   case v26:
 156     return "v26";
 157   case v27:
 158     return "v27";
 159   case v28:
 160     return "v28";
 161   case v29:
 162     return "v29";
 163   case v30:
 164     return "v30";
 165   case v31:
 166     return "v31";
 167   }
 168   return nullptr;
 169 }
 170
 171 bool arm64_dwarf::GetRegisterInfo(unsigned reg_num, RegisterInfo &reg_info) {
 172   ::memset(&reg_info, 0, sizeof(RegisterInfo));
 173   ::memset(reg_info.kinds, LLDB_INVALID_REGNUM, sizeof(reg_info.kinds));
 174
 175   if (reg_num >= x0 && reg_num <= pc) {
 176     reg_info.byte_size = 8;
 177     reg_info.format = eFormatHex;
 178     reg_info.encoding = eEncodingUint;
 179   } else if (reg_num >= v0 && reg_num <= v31) {
 180     reg_info.byte_size = 16;
 181     reg_info.format = eFormatVectorOfFloat32;
 182     reg_info.encoding = eEncodingVector;
 183   } else if (reg_num == cpsr) {
 184     reg_info.byte_size = 4;
 185     reg_info.format = eFormatHex;
 186     reg_info.encoding = eEncodingUint;
 187   } else {
 188     return false;
 189   }
 190
 191   reg_info.name = arm64_dwarf::GetRegisterName(reg_num, false);
 192   reg_info.alt_name = arm64_dwarf::GetRegisterName(reg_num, true);
 193   reg_info.kinds[eRegisterKindDWARF] = reg_num;
 194
 195   switch (reg_num) {
 196   case fp:
 197     reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP;
 198     break;
 199   case lr:
 200     reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA;
 201     break;
 202   case sp:
 203     reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP;
 204     break;
 205   case pc:
 206     reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC;
 207     break;
 208   default:
 209     break;
 210   }
 211   return true;
 212 }