include/llvm/MC/MCExpr.h

   1 //===- MCExpr.h - Assembly Level Expressions --------------------*- 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 #ifndef LLVM_MC_MCEXPR_H
  11 #define LLVM_MC_MCEXPR_H
  12
  13 #include "llvm/Support/Casting.h"
  14 #include "llvm/Support/DataTypes.h"
  15
  16 namespace llvm {
  17 class MCContext;
  18 class MCSymbol;
  19 class MCValue;
  20 class raw_ostream;
  21
  22 /// MCExpr - Base class for the full range of assembler expressions which are
  23 /// needed for parsing.
  24 class MCExpr {
  25 public:
  26   enum ExprKind {
  27     Binary,    ///< Binary expressions.
  28     Constant,  ///< Constant expressions.
  29     SymbolRef, ///< References to labels and assigned expressions.
  30     Unary      ///< Unary expressions.
  31   };
  32
  33 private:
  34   ExprKind Kind;
  35
  36   MCExpr(const MCExpr&); // DO NOT IMPLEMENT
  37   void operator=(const MCExpr&); // DO NOT IMPLEMENT
  38
  39 protected:
  40   MCExpr(ExprKind _Kind) : Kind(_Kind) {}
  41
  42 public:
  43   /// @name Accessors
  44   /// @{
  45
  46   ExprKind getKind() const { return Kind; }
  47
  48   /// @}
  49   /// @name Utility Methods
  50   /// @{
  51
  52   void print(raw_ostream &OS) const;
  53   void dump() const;
  54
  55   /// @}
  56   /// @name Expression Evaluation
  57   /// @{
  58
  59   /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value.
  60   ///
  61   /// @param Res - The absolute value, if evaluation succeeds.
  62   /// @result - True on success.
  63   bool EvaluateAsAbsolute(MCContext &Ctx, int64_t &Res) const;
  64
  65   /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable
  66   /// value, i.e. an expression of the fixed form (a - b + constant).
  67   ///
  68   /// @param Res - The relocatable value, if evaluation succeeds.
  69   /// @result - True on success.
  70   bool EvaluateAsRelocatable(MCContext &Ctx, MCValue &Res) const;
  71
  72   /// @}
  73
  74   static bool classof(const MCExpr *) { return true; }
  75 };
  76
  77 //// MCConstantExpr - Represent a constant integer expression.
  78 class MCConstantExpr : public MCExpr {
  79   int64_t Value;
  80
  81   MCConstantExpr(int64_t _Value)
  82     : MCExpr(MCExpr::Constant), Value(_Value) {}
  83
  84 public:
  85   /// @name Construction
  86   /// @{
  87
  88   static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx);
  89
  90   /// @}
  91   /// @name Accessors
  92   /// @{
  93
  94   int64_t getValue() const { return Value; }
  95
  96   /// @}
  97
  98   static bool classof(const MCExpr *E) {
  99     return E->getKind() == MCExpr::Constant;
 100   }
 101   static bool classof(const MCConstantExpr *) { return true; }
 102 };
 103
 104 /// MCSymbolRefExpr - Represent a reference to a symbol from inside an
 105 /// expression.
 106 ///
 107 /// A symbol reference in an expression may be a use of a label, a use of an
 108 /// assembler variable (defined constant), or constitute an implicit definition
 109 /// of the symbol as external.
 110 class MCSymbolRefExpr : public MCExpr {
 111   const MCSymbol *Symbol;
 112
 113   MCSymbolRefExpr(const MCSymbol *_Symbol)
 114     : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol) {}
 115
 116 public:
 117   /// @name Construction
 118   /// @{
 119
 120   static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx);
 121
 122   /// @}
 123   /// @name Accessors
 124   /// @{
 125
 126   const MCSymbol &getSymbol() const { return *Symbol; }
 127
 128   /// @}
 129
 130   static bool classof(const MCExpr *E) {
 131     return E->getKind() == MCExpr::SymbolRef;
 132   }
 133   static bool classof(const MCSymbolRefExpr *) { return true; }
 134 };
 135
 136 /// MCUnaryExpr - Unary assembler expressions.
 137 class MCUnaryExpr : public MCExpr {
 138 public:
 139   enum Opcode {
 140     LNot,  ///< Logical negation.
 141     Minus, ///< Unary minus.
 142     Not,   ///< Bitwise negation.
 143     Plus   ///< Unary plus.
 144   };
 145
 146 private:
 147   Opcode Op;
 148   const MCExpr *Expr;
 149
 150   MCUnaryExpr(Opcode _Op, const MCExpr *_Expr)
 151     : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {}
 152
 153 public:
 154   /// @name Construction
 155   /// @{
 156
 157   static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr,
 158                                    MCContext &Ctx);
 159   static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) {
 160     return Create(LNot, Expr, Ctx);
 161   }
 162   static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) {
 163     return Create(Minus, Expr, Ctx);
 164   }
 165   static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) {
 166     return Create(Not, Expr, Ctx);
 167   }
 168   static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) {
 169     return Create(Plus, Expr, Ctx);
 170   }
 171
 172   /// @}
 173   /// @name Accessors
 174   /// @{
 175
 176   /// getOpcode - Get the kind of this unary expression.
 177   Opcode getOpcode() const { return Op; }
 178
 179   /// getSubExpr - Get the child of this unary expression.
 180   const MCExpr *getSubExpr() const { return Expr; }
 181
 182   /// @}
 183
 184   static bool classof(const MCExpr *E) {
 185     return E->getKind() == MCExpr::Unary;
 186   }
 187   static bool classof(const MCUnaryExpr *) { return true; }
 188 };
 189
 190 /// MCBinaryExpr - Binary assembler expressions.
 191 class MCBinaryExpr : public MCExpr {
 192 public:
 193   enum Opcode {
 194     Add,  ///< Addition.
 195     And,  ///< Bitwise and.
 196     Div,  ///< Division.
 197     EQ,   ///< Equality comparison.
 198     GT,   ///< Greater than comparison.
 199     GTE,  ///< Greater than or equal comparison.
 200     LAnd, ///< Logical and.
 201     LOr,  ///< Logical or.
 202     LT,   ///< Less than comparison.
 203     LTE,  ///< Less than or equal comparison.
 204     Mod,  ///< Modulus.
 205     Mul,  ///< Multiplication.
 206     NE,   ///< Inequality comparison.
 207     Or,   ///< Bitwise or.
 208     Shl,  ///< Bitwise shift left.
 209     Shr,  ///< Bitwise shift right.
 210     Sub,  ///< Subtraction.
 211     Xor   ///< Bitwise exclusive or.
 212   };
 213
 214 private:
 215   Opcode Op;
 216   const MCExpr *LHS, *RHS;
 217
 218   MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS)
 219     : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
 220
 221 public:
 222   /// @name Construction
 223   /// @{
 224
 225   static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS,
 226                                     const MCExpr *RHS, MCContext &Ctx);
 227   static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS,
 228                                        MCContext &Ctx) {
 229     return Create(Add, LHS, RHS, Ctx);
 230   }
 231   static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS,
 232                                        MCContext &Ctx) {
 233     return Create(And, LHS, RHS, Ctx);
 234   }
 235   static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS,
 236                                        MCContext &Ctx) {
 237     return Create(Div, LHS, RHS, Ctx);
 238   }
 239   static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS,
 240                                       MCContext &Ctx) {
 241     return Create(EQ, LHS, RHS, Ctx);
 242   }
 243   static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS,
 244                                       MCContext &Ctx) {
 245     return Create(GT, LHS, RHS, Ctx);
 246   }
 247   static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS,
 248                                        MCContext &Ctx) {
 249     return Create(GTE, LHS, RHS, Ctx);
 250   }
 251   static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS,
 252                                         MCContext &Ctx) {
 253     return Create(LAnd, LHS, RHS, Ctx);
 254   }
 255   static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS,
 256                                        MCContext &Ctx) {
 257     return Create(LOr, LHS, RHS, Ctx);
 258   }
 259   static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS,
 260                                       MCContext &Ctx) {
 261     return Create(LT, LHS, RHS, Ctx);
 262   }
 263   static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS,
 264                                        MCContext &Ctx) {
 265     return Create(LTE, LHS, RHS, Ctx);
 266   }
 267   static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS,
 268                                        MCContext &Ctx) {
 269     return Create(Mod, LHS, RHS, Ctx);
 270   }
 271   static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS,
 272                                        MCContext &Ctx) {
 273     return Create(Mul, LHS, RHS, Ctx);
 274   }
 275   static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS,
 276                                       MCContext &Ctx) {
 277     return Create(NE, LHS, RHS, Ctx);
 278   }
 279   static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS,
 280                                       MCContext &Ctx) {
 281     return Create(Or, LHS, RHS, Ctx);
 282   }
 283   static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS,
 284                                        MCContext &Ctx) {
 285     return Create(Shl, LHS, RHS, Ctx);
 286   }
 287   static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS,
 288                                        MCContext &Ctx) {
 289     return Create(Shr, LHS, RHS, Ctx);
 290   }
 291   static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS,
 292                                        MCContext &Ctx) {
 293     return Create(Sub, LHS, RHS, Ctx);
 294   }
 295   static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS,
 296                                        MCContext &Ctx) {
 297     return Create(Xor, LHS, RHS, Ctx);
 298   }
 299
 300   /// @}
 301   /// @name Accessors
 302   /// @{
 303
 304   /// getOpcode - Get the kind of this binary expression.
 305   Opcode getOpcode() const { return Op; }
 306
 307   /// getLHS - Get the left-hand side expression of the binary operator.
 308   const MCExpr *getLHS() const { return LHS; }
 309
 310   /// getRHS - Get the right-hand side expression of the binary operator.
 311   const MCExpr *getRHS() const { return RHS; }
 312
 313   /// @}
 314
 315   static bool classof(const MCExpr *E) {
 316     return E->getKind() == MCExpr::Binary;
 317   }
 318   static bool classof(const MCBinaryExpr *) { return true; }
 319 };
 320
 321 } // end namespace llvm
 322
 323 #endif