MCExpr.h revision 28c251b54b0b311749f07babe0f6909e71e877bc 
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
16namespace llvm {
17class MCContext;
18class MCSymbol;
19class MCValue;
20
21/// MCExpr - Base class for the full range of assembler expressions which are
22/// needed for parsing.
23class MCExpr {
24public:
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
32private:
33  ExprKind Kind;
34
35protected:
36  MCExpr(ExprKind _Kind) : Kind(_Kind) {}
37
38public:
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.
60class MCConstantExpr : public MCExpr {
61  int64_t Value;
62
63public:
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.
81class MCSymbolRefExpr : public MCExpr {
82  MCSymbol *Symbol;
83
84public:
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.
97class MCUnaryExpr : public MCExpr {
98public:
99  enum Opcode {
100    LNot,  ///< Logical negation.
101    Minus, ///< Unary minus.
102    Not,   ///< Bitwise negation.
103    Plus   ///< Unary plus.
104  };
105
106private:
107  Opcode Op;
108  MCExpr *Expr;
109
110public:
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.
128class MCBinaryExpr : public MCExpr {
129public:
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
151private:
152  Opcode Op;
153  MCExpr *LHS, *RHS;
154
155public:
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
180