contrib/llvm/lib/Target/MBlaze/MCTargetDesc/MBlazeBaseInfo.h

   1 //===-- MBlazeBaseInfo.h - Top level definitions for MBlaze -- --*- 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 MBlaze 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 MBlazeBASEINFO_H
  18 #define MBlazeBASEINFO_H
  19
  20 #include "MBlazeMCTargetDesc.h"
  21 #include "llvm/Support/ErrorHandling.h"
  22
  23 namespace llvm {
  24
  25 /// MBlazeII - This namespace holds all of the target specific flags that
  26 /// instruction info tracks.
  27 ///
  28 namespace MBlazeII {
  29   enum {
  30     // PseudoFrm - This represents an instruction that is a pseudo instruction
  31     // or one that has not been implemented yet.  It is illegal to code generate
  32     // it, but tolerated for intermediate implementation stages.
  33     FPseudo = 0,
  34     FRRR,
  35     FRRI,
  36     FCRR,
  37     FCRI,
  38     FRCR,
  39     FRCI,
  40     FCCR,
  41     FCCI,
  42     FRRCI,
  43     FRRC,
  44     FRCX,
  45     FRCS,
  46     FCRCS,
  47     FCRCX,
  48     FCX,
  49     FCR,
  50     FRIR,
  51     FRRRR,
  52     FRI,
  53     FC,
  54     FormMask = 63
  55
  56     //===------------------------------------------------------------------===//
  57     // MBlaze Specific MachineOperand flags.
  58     // MO_NO_FLAG,
  59
  60     /// MO_GOT - Represents the offset into the global offset table at which
  61     /// the address the relocation entry symbol resides during execution.
  62     // MO_GOT,
  63
  64     /// MO_GOT_CALL - Represents the offset into the global offset table at
  65     /// which the address of a call site relocation entry symbol resides
  66     /// during execution. This is different from the above since this flag
  67     /// can only be present in call instructions.
  68     // MO_GOT_CALL,
  69
  70     /// MO_GPREL - Represents the offset from the current gp value to be used
  71     /// for the relocatable object file being produced.
  72     // MO_GPREL,
  73
  74     /// MO_ABS_HILO - Represents the hi or low part of an absolute symbol
  75     /// address.
  76     // MO_ABS_HILO
  77
  78   };
  79 }
  80
  81 static inline bool isMBlazeRegister(unsigned Reg) {
  82   return Reg <= 31;
  83 }
  84
  85 static inline bool isSpecialMBlazeRegister(unsigned Reg) {
  86   switch (Reg) {
  87     case 0x0000 : case 0x0001 : case 0x0003 : case 0x0005 :
  88     case 0x0007 : case 0x000B : case 0x000D : case 0x1000 :
  89     case 0x1001 : case 0x1002 : case 0x1003 : case 0x1004 :
  90     case 0x2000 : case 0x2001 : case 0x2002 : case 0x2003 :
  91     case 0x2004 : case 0x2005 : case 0x2006 : case 0x2007 :
  92     case 0x2008 : case 0x2009 : case 0x200A : case 0x200B :
  93       return true;
  94
  95     default:
  96       return false;
  97   }
  98   return false; // Not reached
  99 }
 100
 101 /// getMBlazeRegisterNumbering - Given the enum value for some register, e.g.
 102 /// MBlaze::R0, return the number that it corresponds to (e.g. 0).
 103 static inline unsigned getMBlazeRegisterNumbering(unsigned RegEnum) {
 104   switch (RegEnum) {
 105     case MBlaze::R0     : return 0;
 106     case MBlaze::R1     : return 1;
 107     case MBlaze::R2     : return 2;
 108     case MBlaze::R3     : return 3;
 109     case MBlaze::R4     : return 4;
 110     case MBlaze::R5     : return 5;
 111     case MBlaze::R6     : return 6;
 112     case MBlaze::R7     : return 7;
 113     case MBlaze::R8     : return 8;
 114     case MBlaze::R9     : return 9;
 115     case MBlaze::R10    : return 10;
 116     case MBlaze::R11    : return 11;
 117     case MBlaze::R12    : return 12;
 118     case MBlaze::R13    : return 13;
 119     case MBlaze::R14    : return 14;
 120     case MBlaze::R15    : return 15;
 121     case MBlaze::R16    : return 16;
 122     case MBlaze::R17    : return 17;
 123     case MBlaze::R18    : return 18;
 124     case MBlaze::R19    : return 19;
 125     case MBlaze::R20    : return 20;
 126     case MBlaze::R21    : return 21;
 127     case MBlaze::R22    : return 22;
 128     case MBlaze::R23    : return 23;
 129     case MBlaze::R24    : return 24;
 130     case MBlaze::R25    : return 25;
 131     case MBlaze::R26    : return 26;
 132     case MBlaze::R27    : return 27;
 133     case MBlaze::R28    : return 28;
 134     case MBlaze::R29    : return 29;
 135     case MBlaze::R30    : return 30;
 136     case MBlaze::R31    : return 31;
 137     case MBlaze::RPC    : return 0x0000;
 138     case MBlaze::RMSR   : return 0x0001;
 139     case MBlaze::REAR   : return 0x0003;
 140     case MBlaze::RESR   : return 0x0005;
 141     case MBlaze::RFSR   : return 0x0007;
 142     case MBlaze::RBTR   : return 0x000B;
 143     case MBlaze::REDR   : return 0x000D;
 144     case MBlaze::RPID   : return 0x1000;
 145     case MBlaze::RZPR   : return 0x1001;
 146     case MBlaze::RTLBX  : return 0x1002;
 147     case MBlaze::RTLBLO : return 0x1003;
 148     case MBlaze::RTLBHI : return 0x1004;
 149     case MBlaze::RPVR0  : return 0x2000;
 150     case MBlaze::RPVR1  : return 0x2001;
 151     case MBlaze::RPVR2  : return 0x2002;
 152     case MBlaze::RPVR3  : return 0x2003;
 153     case MBlaze::RPVR4  : return 0x2004;
 154     case MBlaze::RPVR5  : return 0x2005;
 155     case MBlaze::RPVR6  : return 0x2006;
 156     case MBlaze::RPVR7  : return 0x2007;
 157     case MBlaze::RPVR8  : return 0x2008;
 158     case MBlaze::RPVR9  : return 0x2009;
 159     case MBlaze::RPVR10 : return 0x200A;
 160     case MBlaze::RPVR11 : return 0x200B;
 161     default: llvm_unreachable("Unknown register number!");
 162   }
 163   return 0; // Not reached
 164 }
 165
 166 /// getRegisterFromNumbering - Given the enum value for some register, e.g.
 167 /// MBlaze::R0, return the number that it corresponds to (e.g. 0).
 168 static inline unsigned getMBlazeRegisterFromNumbering(unsigned Reg) {
 169   switch (Reg) {
 170     case 0  : return MBlaze::R0;
 171     case 1  : return MBlaze::R1;
 172     case 2  : return MBlaze::R2;
 173     case 3  : return MBlaze::R3;
 174     case 4  : return MBlaze::R4;
 175     case 5  : return MBlaze::R5;
 176     case 6  : return MBlaze::R6;
 177     case 7  : return MBlaze::R7;
 178     case 8  : return MBlaze::R8;
 179     case 9  : return MBlaze::R9;
 180     case 10 : return MBlaze::R10;
 181     case 11 : return MBlaze::R11;
 182     case 12 : return MBlaze::R12;
 183     case 13 : return MBlaze::R13;
 184     case 14 : return MBlaze::R14;
 185     case 15 : return MBlaze::R15;
 186     case 16 : return MBlaze::R16;
 187     case 17 : return MBlaze::R17;
 188     case 18 : return MBlaze::R18;
 189     case 19 : return MBlaze::R19;
 190     case 20 : return MBlaze::R20;
 191     case 21 : return MBlaze::R21;
 192     case 22 : return MBlaze::R22;
 193     case 23 : return MBlaze::R23;
 194     case 24 : return MBlaze::R24;
 195     case 25 : return MBlaze::R25;
 196     case 26 : return MBlaze::R26;
 197     case 27 : return MBlaze::R27;
 198     case 28 : return MBlaze::R28;
 199     case 29 : return MBlaze::R29;
 200     case 30 : return MBlaze::R30;
 201     case 31 : return MBlaze::R31;
 202     default: llvm_unreachable("Unknown register number!");
 203   }
 204   return 0; // Not reached
 205 }
 206
 207 static inline unsigned getSpecialMBlazeRegisterFromNumbering(unsigned Reg) {
 208   switch (Reg) {
 209     case 0x0000 : return MBlaze::RPC;
 210     case 0x0001 : return MBlaze::RMSR;
 211     case 0x0003 : return MBlaze::REAR;
 212     case 0x0005 : return MBlaze::RESR;
 213     case 0x0007 : return MBlaze::RFSR;
 214     case 0x000B : return MBlaze::RBTR;
 215     case 0x000D : return MBlaze::REDR;
 216     case 0x1000 : return MBlaze::RPID;
 217     case 0x1001 : return MBlaze::RZPR;
 218     case 0x1002 : return MBlaze::RTLBX;
 219     case 0x1003 : return MBlaze::RTLBLO;
 220     case 0x1004 : return MBlaze::RTLBHI;
 221     case 0x2000 : return MBlaze::RPVR0;
 222     case 0x2001 : return MBlaze::RPVR1;
 223     case 0x2002 : return MBlaze::RPVR2;
 224     case 0x2003 : return MBlaze::RPVR3;
 225     case 0x2004 : return MBlaze::RPVR4;
 226     case 0x2005 : return MBlaze::RPVR5;
 227     case 0x2006 : return MBlaze::RPVR6;
 228     case 0x2007 : return MBlaze::RPVR7;
 229     case 0x2008 : return MBlaze::RPVR8;
 230     case 0x2009 : return MBlaze::RPVR9;
 231     case 0x200A : return MBlaze::RPVR10;
 232     case 0x200B : return MBlaze::RPVR11;
 233     default: llvm_unreachable("Unknown register number!");
 234   }
 235   return 0; // Not reached
 236 }
 237
 238 } // end namespace llvm;
 239
 240 #endif