lib/Target/ARM/ARMBaseInfo.h

   1 //===-- ARMBaseInfo.h - Top level definitions for ARM -------- --*- 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 // This file contains small standalone helper functions and enum definitions for
  11 // the ARM target useful for the compiler back-end and the MC libraries.
  12 // As such, it deliberately does not include references to LLVM core
  13 // code gen types, passes, etc..
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef ARMBASEINFO_H
  18 #define ARMBASEINFO_H
  19
  20 #include "llvm/Support/ErrorHandling.h"
  21
  22 // Note that the following auto-generated files only defined enum types, and
  23 // so are safe to include here.
  24
  25 // Defines symbolic names for ARM registers.  This defines a mapping from
  26 // register name to register number.
  27 //
  28 #include "ARMGenRegisterNames.inc"
  29
  30 // Defines symbolic names for the ARM instructions.
  31 //
  32 #include "ARMGenInstrNames.inc"
  33
  34 namespace llvm {
  35
  36 // Enums corresponding to ARM condition codes
  37 namespace ARMCC {
  38   // The CondCodes constants map directly to the 4-bit encoding of the
  39   // condition field for predicated instructions.
  40   enum CondCodes { // Meaning (integer)          Meaning (floating-point)
  41     EQ,            // Equal                      Equal
  42     NE,            // Not equal                  Not equal, or unordered
  43     HS,            // Carry set                  >, ==, or unordered
  44     LO,            // Carry clear                Less than
  45     MI,            // Minus, negative            Less than
  46     PL,            // Plus, positive or zero     >, ==, or unordered
  47     VS,            // Overflow                   Unordered
  48     VC,            // No overflow                Not unordered
  49     HI,            // Unsigned higher            Greater than, or unordered
  50     LS,            // Unsigned lower or same     Less than or equal
  51     GE,            // Greater than or equal      Greater than or equal
  52     LT,            // Less than                  Less than, or unordered
  53     GT,            // Greater than               Greater than
  54     LE,            // Less than or equal         <, ==, or unordered
  55     AL             // Always (unconditional)     Always (unconditional)
  56   };
  57
  58   inline static CondCodes getOppositeCondition(CondCodes CC) {
  59     switch (CC) {
  60     default: llvm_unreachable("Unknown condition code");
  61     case EQ: return NE;
  62     case NE: return EQ;
  63     case HS: return LO;
  64     case LO: return HS;
  65     case MI: return PL;
  66     case PL: return MI;
  67     case VS: return VC;
  68     case VC: return VS;
  69     case HI: return LS;
  70     case LS: return HI;
  71     case GE: return LT;
  72     case LT: return GE;
  73     case GT: return LE;
  74     case LE: return GT;
  75     }
  76   }
  77 } // namespace ARMCC
  78
  79 inline static const char *ARMCondCodeToString(ARMCC::CondCodes CC) {
  80   switch (CC) {
  81   default: llvm_unreachable("Unknown condition code");
  82   case ARMCC::EQ:  return "eq";
  83   case ARMCC::NE:  return "ne";
  84   case ARMCC::HS:  return "hs";
  85   case ARMCC::LO:  return "lo";
  86   case ARMCC::MI:  return "mi";
  87   case ARMCC::PL:  return "pl";
  88   case ARMCC::VS:  return "vs";
  89   case ARMCC::VC:  return "vc";
  90   case ARMCC::HI:  return "hi";
  91   case ARMCC::LS:  return "ls";
  92   case ARMCC::GE:  return "ge";
  93   case ARMCC::LT:  return "lt";
  94   case ARMCC::GT:  return "gt";
  95   case ARMCC::LE:  return "le";
  96   case ARMCC::AL:  return "al";
  97   }
  98 }
  99
 100 namespace ARM_PROC {
 101   enum IMod {
 102     IE = 2,
 103     ID = 3
 104   };
 105
 106   enum IFlags {
 107     F = 1,
 108     I = 2,
 109     A = 4
 110   };
 111
 112   inline static const char *IFlagsToString(unsigned val) {
 113     switch (val) {
 114     default: llvm_unreachable("Unknown iflags operand");
 115     case F: return "f";
 116     case I: return "i";
 117     case A: return "a";
 118     }
 119   }
 120
 121   inline static const char *IModToString(unsigned val) {
 122     switch (val) {
 123     default: llvm_unreachable("Unknown imod operand");
 124     case IE: return "ie";
 125     case ID: return "id";
 126     }
 127   }
 128 }
 129
 130 namespace ARM_MB {
 131   // The Memory Barrier Option constants map directly to the 4-bit encoding of
 132   // the option field for memory barrier operations.
 133   enum MemBOpt {
 134     SY    = 15,
 135     ST    = 14,
 136     ISH   = 11,
 137     ISHST = 10,
 138     NSH   = 7,
 139     NSHST = 6,
 140     OSH   = 3,
 141     OSHST = 2
 142   };
 143
 144   inline static const char *MemBOptToString(unsigned val) {
 145     switch (val) {
 146     default: llvm_unreachable("Unknown memory operation");
 147     case SY:    return "sy";
 148     case ST:    return "st";
 149     case ISH:   return "ish";
 150     case ISHST: return "ishst";
 151     case NSH:   return "nsh";
 152     case NSHST: return "nshst";
 153     case OSH:   return "osh";
 154     case OSHST: return "oshst";
 155     }
 156   }
 157 } // namespace ARM_MB
 158
 159 /// getARMRegisterNumbering - Given the enum value for some register, e.g.
 160 /// ARM::LR, return the number that it corresponds to (e.g. 14).
 161 inline static unsigned getARMRegisterNumbering(unsigned Reg) {
 162   using namespace ARM;
 163   switch (Reg) {
 164   default:
 165     llvm_unreachable("Unknown ARM register!");
 166   case R0:  case S0:  case D0:  case Q0:  return 0;
 167   case R1:  case S1:  case D1:  case Q1:  return 1;
 168   case R2:  case S2:  case D2:  case Q2:  return 2;
 169   case R3:  case S3:  case D3:  case Q3:  return 3;
 170   case R4:  case S4:  case D4:  case Q4:  return 4;
 171   case R5:  case S5:  case D5:  case Q5:  return 5;
 172   case R6:  case S6:  case D6:  case Q6:  return 6;
 173   case R7:  case S7:  case D7:  case Q7:  return 7;
 174   case R8:  case S8:  case D8:  case Q8:  return 8;
 175   case R9:  case S9:  case D9:  case Q9:  return 9;
 176   case R10: case S10: case D10: case Q10: return 10;
 177   case R11: case S11: case D11: case Q11: return 11;
 178   case R12: case S12: case D12: case Q12: return 12;
 179   case SP:  case S13: case D13: case Q13: return 13;
 180   case LR:  case S14: case D14: case Q14: return 14;
 181   case PC:  case S15: case D15: case Q15: return 15;
 182
 183   case S16: case D16: return 16;
 184   case S17: case D17: return 17;
 185   case S18: case D18: return 18;
 186   case S19: case D19: return 19;
 187   case S20: case D20: return 20;
 188   case S21: case D21: return 21;
 189   case S22: case D22: return 22;
 190   case S23: case D23: return 23;
 191   case S24: case D24: return 24;
 192   case S25: case D25: return 25;
 193   case S26: case D26: return 26;
 194   case S27: case D27: return 27;
 195   case S28: case D28: return 28;
 196   case S29: case D29: return 29;
 197   case S30: case D30: return 30;
 198   case S31: case D31: return 31;
 199   }
 200 }
 201
 202 namespace ARMII {
 203   /// Target Operand Flag enum.
 204   enum TOF {
 205     //===------------------------------------------------------------------===//
 206     // ARM Specific MachineOperand flags.
 207
 208     MO_NO_FLAG,
 209
 210     /// MO_LO16 - On a symbol operand, this represents a relocation containing
 211     /// lower 16 bit of the address. Used only via movw instruction.
 212     MO_LO16,
 213
 214     /// MO_HI16 - On a symbol operand, this represents a relocation containing
 215     /// higher 16 bit of the address. Used only via movt instruction.
 216     MO_HI16,
 217
 218     /// MO_LO16_NONLAZY - On a symbol operand "FOO", this represents a
 219     /// relocation containing lower 16 bit of the non-lazy-ptr indirect symbol,
 220     /// i.e. "FOO$non_lazy_ptr".
 221     /// Used only via movw instruction.
 222     MO_LO16_NONLAZY,
 223
 224     /// MO_HI16_NONLAZY - On a symbol operand "FOO", this represents a
 225     /// relocation containing lower 16 bit of the non-lazy-ptr indirect symbol,
 226     /// i.e. "FOO$non_lazy_ptr". Used only via movt instruction.
 227     MO_HI16_NONLAZY,
 228
 229     /// MO_LO16_NONLAZY_PIC - On a symbol operand "FOO", this represents a
 230     /// relocation containing lower 16 bit of the PC relative address of the
 231     /// non-lazy-ptr indirect symbol, i.e. "FOO$non_lazy_ptr - LABEL".
 232     /// Used only via movw instruction.
 233     MO_LO16_NONLAZY_PIC,
 234
 235     /// MO_HI16_NONLAZY_PIC - On a symbol operand "FOO", this represents a
 236     /// relocation containing lower 16 bit of the PC relative address of the
 237     /// non-lazy-ptr indirect symbol, i.e. "FOO$non_lazy_ptr - LABEL".
 238     /// Used only via movt instruction.
 239     MO_HI16_NONLAZY_PIC,
 240
 241     /// MO_PLT - On a symbol operand, this represents an ELF PLT reference on a
 242     /// call operand.
 243     MO_PLT
 244   };
 245 } // end namespace ARMII
 246
 247 } // end namespace llvm;
 248
 249 #endif