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
  21 /// MCExpr - Base class for the full range of assembler expressions which are
  22 /// needed for parsing.
  23 class MCExpr {
  24 public:
  25   enum ExprKind {
  26     Binary,    ///< Binary expressions.
  27     Constant,  ///< Constant expressions.
  28     SymbolRef, ///< References to labels and assigned expressions.
  29     Unary      ///< Unary expressions.
  30   };
  31
  32 private:
  33   ExprKind Kind;
  34
  35 protected:
  36   MCExpr(ExprKind _Kind) : Kind(_Kind) {}
  37
  38 public:
  39   virtual ~MCExpr();
  40
  41   ExprKind getKind() const { return Kind; }
  42
  43   /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value.
  44   ///
  45   /// @param Res - The absolute value, if evaluation succeeds.
  46   /// @result - True on success.
  47   bool EvaluateAsAbsolute(MCContext &Ctx, int64_t &Res) const;
  48
  49   /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable
  50   /// value, i.e. an expression of the fixed form (a - b + constant).
  51   ///
  52   /// @param Res - The relocatable value, if evaluation succeeds.
  53   /// @result - True on success.
  54   bool EvaluateAsRelocatable(MCContext &Ctx, MCValue &Res) const;
  55
  56   static bool classof(const MCExpr *) { return true; }
  57 };
  58
  59 //// MCConstantExpr - Represent a constant integer expression.
  60 class MCConstantExpr : public MCExpr {
  61   int64_t Value;
  62
  63 public:
  64   MCConstantExpr(int64_t _Value)
  65     : MCExpr(MCExpr::Constant), Value(_Value) {}
  66
  67   int64_t getValue() const { return Value; }
  68
  69   static bool classof(const MCExpr *E) {
  70     return E->getKind() == MCExpr::Constant;
  71   }
  72   static bool classof(const MCConstantExpr *) { return true; }
  73 };
  74
  75 /// MCSymbolRefExpr - Represent a reference to a symbol from inside an
  76 /// expression.
  77 ///
  78 /// A symbol reference in an expression may be a use of a label, a use of an
  79 /// assembler variable (defined constant), or constitute an implicit definition
  80 /// of the symbol as external.
  81 class MCSymbolRefExpr : public MCExpr {
  82   MCSymbol *Symbol;
  83
  84 public:
  85   MCSymbolRefExpr(MCSymbol *_Symbol)
  86     : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol) {}
  87
  88   MCSymbol *getSymbol() const { return Symbol; }
  89
  90   static bool classof(const MCExpr *E) {
  91     return E->getKind() == MCExpr::SymbolRef;
  92   }
  93   static bool classof(const MCSymbolRefExpr *) { return true; }
  94 };
  95
  96 /// MCUnaryExpr - Unary assembler expressions.
  97 class MCUnaryExpr : public MCExpr {
  98 public:
  99   enum Opcode {
 100     LNot,  ///< Logical negation.
 101     Minus, ///< Unary minus.
 102     Not,   ///< Bitwise negation.
 103     Plus   ///< Unary plus.
 104   };
 105
 106 private:
 107   Opcode Op;
 108   MCExpr *Expr;
 109
 110 public:
 111   MCUnaryExpr(Opcode _Op, MCExpr *_Expr)
 112     : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {}
 113   ~MCUnaryExpr() {
 114     delete Expr;
 115   }
 116
 117   Opcode getOpcode() const { return Op; }
 118
 119   MCExpr *getSubExpr() const { return Expr; }
 120
 121   static bool classof(const MCExpr *E) {
 122     return E->getKind() == MCExpr::Unary;
 123   }
 124   static bool classof(const MCUnaryExpr *) { return true; }
 125 };
 126
 127 /// MCBinaryExpr - Binary assembler expressions.
 128 class MCBinaryExpr : public MCExpr {
 129 public:
 130   enum Opcode {
 131     Add,  ///< Addition.
 132     And,  ///< Bitwise and.
 133     Div,  ///< Division.
 134     EQ,   ///< Equality comparison.
 135     GT,   ///< Greater than comparison.
 136     GTE,  ///< Greater than or equal comparison.
 137     LAnd, ///< Logical and.
 138     LOr,  ///< Logical or.
 139     LT,   ///< Less than comparison.
 140     LTE,  ///< Less than or equal comparison.
 141     Mod,  ///< Modulus.
 142     Mul,  ///< Multiplication.
 143     NE,   ///< Inequality comparison.
 144     Or,   ///< Bitwise or.
 145     Shl,  ///< Bitwise shift left.
 146     Shr,  ///< Bitwise shift right.
 147     Sub,  ///< Subtraction.
 148     Xor   ///< Bitwise exclusive or.
 149   };
 150
 151 private:
 152   Opcode Op;
 153   MCExpr *LHS, *RHS;
 154
 155 public:
 156   MCBinaryExpr(Opcode _Op, MCExpr *_LHS, MCExpr *_RHS)
 157     : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
 158   ~MCBinaryExpr() {
 159     delete LHS;
 160     delete RHS;
 161   }
 162
 163   Opcode getOpcode() const { return Op; }
 164
 165   /// getLHS - Get the left-hand side expression of the binary operator.
 166   MCExpr *getLHS() const { return LHS; }
 167
 168   /// getRHS - Get the right-hand side expression of the binary operator.
 169   MCExpr *getRHS() const { return RHS; }
 170
 171   static bool classof(const MCExpr *E) {
 172     return E->getKind() == MCExpr::Binary;
 173   }
 174   static bool classof(const MCBinaryExpr *) { return true; }
 175 };
 176
 177 } // end namespace llvm
 178
 179 #endif