MCExpr.h revision 7597212abced110723f2fee985a7d60557c092ec
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/ADT/DenseMap.h" 14#include "llvm/Support/Casting.h" 15#include "llvm/Support/DataTypes.h" 16 17namespace llvm { 18class MCAsmInfo; 19class MCAsmLayout; 20class MCAssembler; 21class MCContext; 22class MCSectionData; 23class MCSymbol; 24class MCValue; 25class raw_ostream; 26class StringRef; 27typedef DenseMap<const MCSectionData*, uint64_t> SectionAddrMap; 28 29/// MCExpr - Base class for the full range of assembler expressions which are 30/// needed for parsing. 31class MCExpr { 32public: 33 enum ExprKind { 34 Binary, ///< Binary expressions. 35 Constant, ///< Constant expressions. 36 SymbolRef, ///< References to labels and assigned expressions. 37 Unary, ///< Unary expressions. 38 Target ///< Target specific expression. 39 }; 40 41private: 42 ExprKind Kind; 43 44 MCExpr(const MCExpr&); // DO NOT IMPLEMENT 45 void operator=(const MCExpr&); // DO NOT IMPLEMENT 46 47 bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm, 48 const MCAsmLayout *Layout, 49 const SectionAddrMap *Addrs) const; 50protected: 51 explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {} 52 53 bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, 54 const MCAsmLayout *Layout, 55 const SectionAddrMap *Addrs, 56 bool InSet) const; 57public: 58 /// @name Accessors 59 /// @{ 60 61 ExprKind getKind() const { return Kind; } 62 63 /// @} 64 /// @name Utility Methods 65 /// @{ 66 67 void print(raw_ostream &OS) const; 68 void dump() const; 69 70 /// @} 71 /// @name Expression Evaluation 72 /// @{ 73 74 /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value. 75 /// 76 /// @param Res - The absolute value, if evaluation succeeds. 77 /// @param Layout - The assembler layout object to use for evaluating symbol 78 /// values. If not given, then only non-symbolic expressions will be 79 /// evaluated. 80 /// @result - True on success. 81 bool EvaluateAsAbsolute(int64_t &Res) const; 82 bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const; 83 bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout) const; 84 bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout, 85 const SectionAddrMap &Addrs) const; 86 87 /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable 88 /// value, i.e. an expression of the fixed form (a - b + constant). 89 /// 90 /// @param Res - The relocatable value, if evaluation succeeds. 91 /// @param Layout - The assembler layout object to use for evaluating values. 92 /// @result - True on success. 93 bool EvaluateAsRelocatable(MCValue &Res, const MCAsmLayout &Layout) const; 94 95 /// @} 96 97 static bool classof(const MCExpr *) { return true; } 98}; 99 100inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) { 101 E.print(OS); 102 return OS; 103} 104 105//// MCConstantExpr - Represent a constant integer expression. 106class MCConstantExpr : public MCExpr { 107 int64_t Value; 108 109 explicit MCConstantExpr(int64_t _Value) 110 : MCExpr(MCExpr::Constant), Value(_Value) {} 111 112public: 113 /// @name Construction 114 /// @{ 115 116 static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx); 117 118 /// @} 119 /// @name Accessors 120 /// @{ 121 122 int64_t getValue() const { return Value; } 123 124 /// @} 125 126 static bool classof(const MCExpr *E) { 127 return E->getKind() == MCExpr::Constant; 128 } 129 static bool classof(const MCConstantExpr *) { return true; } 130}; 131 132/// MCSymbolRefExpr - Represent a reference to a symbol from inside an 133/// expression. 134/// 135/// A symbol reference in an expression may be a use of a label, a use of an 136/// assembler variable (defined constant), or constitute an implicit definition 137/// of the symbol as external. 138class MCSymbolRefExpr : public MCExpr { 139public: 140 enum VariantKind { 141 VK_None, 142 VK_Invalid, 143 144 VK_GOT, 145 VK_GOTOFF, 146 VK_GOTPCREL, 147 VK_GOTTPOFF, 148 VK_INDNTPOFF, 149 VK_NTPOFF, 150 VK_GOTNTPOFF, 151 VK_PLT, 152 VK_TLSGD, 153 VK_TLSLD, 154 VK_TLSLDM, 155 VK_TPOFF, 156 VK_DTPOFF, 157 VK_TLVP, // Mach-O thread local variable relocation 158 // FIXME: We'd really like to use the generic Kinds listed above for these. 159 VK_ARM_PLT, // ARM-style PLT references. i.e., (PLT) instead of @PLT 160 VK_ARM_TLSGD, // ditto for TLSGD, GOT, GOTOFF, TPOFF and GOTTPOFF 161 VK_ARM_GOT, 162 VK_ARM_GOTOFF, 163 VK_ARM_TPOFF, 164 VK_ARM_GOTTPOFF, 165 166 VK_PPC_TOC, 167 VK_PPC_HA16, // ha16(symbol) 168 VK_PPC_LO16 // lo16(symbol) 169 }; 170 171private: 172 /// The symbol being referenced. 173 const MCSymbol *Symbol; 174 175 /// The symbol reference modifier. 176 const VariantKind Kind; 177 178 explicit MCSymbolRefExpr(const MCSymbol *_Symbol, VariantKind _Kind) 179 : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol), Kind(_Kind) {} 180 181public: 182 /// @name Construction 183 /// @{ 184 185 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx) { 186 return MCSymbolRefExpr::Create(Symbol, VK_None, Ctx); 187 } 188 189 static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, VariantKind Kind, 190 MCContext &Ctx); 191 static const MCSymbolRefExpr *Create(StringRef Name, VariantKind Kind, 192 MCContext &Ctx); 193 194 /// @} 195 /// @name Accessors 196 /// @{ 197 198 const MCSymbol &getSymbol() const { return *Symbol; } 199 200 VariantKind getKind() const { return Kind; } 201 202 /// @} 203 /// @name Static Utility Functions 204 /// @{ 205 206 static StringRef getVariantKindName(VariantKind Kind); 207 208 static VariantKind getVariantKindForName(StringRef Name); 209 210 /// @} 211 212 static bool classof(const MCExpr *E) { 213 return E->getKind() == MCExpr::SymbolRef; 214 } 215 static bool classof(const MCSymbolRefExpr *) { return true; } 216}; 217 218/// MCUnaryExpr - Unary assembler expressions. 219class MCUnaryExpr : public MCExpr { 220public: 221 enum Opcode { 222 LNot, ///< Logical negation. 223 Minus, ///< Unary minus. 224 Not, ///< Bitwise negation. 225 Plus ///< Unary plus. 226 }; 227 228private: 229 Opcode Op; 230 const MCExpr *Expr; 231 232 MCUnaryExpr(Opcode _Op, const MCExpr *_Expr) 233 : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {} 234 235public: 236 /// @name Construction 237 /// @{ 238 239 static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr, 240 MCContext &Ctx); 241 static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) { 242 return Create(LNot, Expr, Ctx); 243 } 244 static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) { 245 return Create(Minus, Expr, Ctx); 246 } 247 static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) { 248 return Create(Not, Expr, Ctx); 249 } 250 static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) { 251 return Create(Plus, Expr, Ctx); 252 } 253 254 /// @} 255 /// @name Accessors 256 /// @{ 257 258 /// getOpcode - Get the kind of this unary expression. 259 Opcode getOpcode() const { return Op; } 260 261 /// getSubExpr - Get the child of this unary expression. 262 const MCExpr *getSubExpr() const { return Expr; } 263 264 /// @} 265 266 static bool classof(const MCExpr *E) { 267 return E->getKind() == MCExpr::Unary; 268 } 269 static bool classof(const MCUnaryExpr *) { return true; } 270}; 271 272/// MCBinaryExpr - Binary assembler expressions. 273class MCBinaryExpr : public MCExpr { 274public: 275 enum Opcode { 276 Add, ///< Addition. 277 And, ///< Bitwise and. 278 Div, ///< Signed division. 279 EQ, ///< Equality comparison. 280 GT, ///< Signed greater than comparison (result is either 0 or some 281 ///< target-specific non-zero value) 282 GTE, ///< Signed greater than or equal comparison (result is either 0 or 283 ///< some target-specific non-zero value). 284 LAnd, ///< Logical and. 285 LOr, ///< Logical or. 286 LT, ///< Signed less than comparison (result is either 0 or 287 ///< some target-specific non-zero value). 288 LTE, ///< Signed less than or equal comparison (result is either 0 or 289 ///< some target-specific non-zero value). 290 Mod, ///< Signed remainder. 291 Mul, ///< Multiplication. 292 NE, ///< Inequality comparison. 293 Or, ///< Bitwise or. 294 Shl, ///< Shift left. 295 Shr, ///< Shift right (arithmetic or logical, depending on target) 296 Sub, ///< Subtraction. 297 Xor ///< Bitwise exclusive or. 298 }; 299 300private: 301 Opcode Op; 302 const MCExpr *LHS, *RHS; 303 304 MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS) 305 : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} 306 307public: 308 /// @name Construction 309 /// @{ 310 311 static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS, 312 const MCExpr *RHS, MCContext &Ctx); 313 static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS, 314 MCContext &Ctx) { 315 return Create(Add, LHS, RHS, Ctx); 316 } 317 static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS, 318 MCContext &Ctx) { 319 return Create(And, LHS, RHS, Ctx); 320 } 321 static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS, 322 MCContext &Ctx) { 323 return Create(Div, LHS, RHS, Ctx); 324 } 325 static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS, 326 MCContext &Ctx) { 327 return Create(EQ, LHS, RHS, Ctx); 328 } 329 static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS, 330 MCContext &Ctx) { 331 return Create(GT, LHS, RHS, Ctx); 332 } 333 static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS, 334 MCContext &Ctx) { 335 return Create(GTE, LHS, RHS, Ctx); 336 } 337 static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS, 338 MCContext &Ctx) { 339 return Create(LAnd, LHS, RHS, Ctx); 340 } 341 static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS, 342 MCContext &Ctx) { 343 return Create(LOr, LHS, RHS, Ctx); 344 } 345 static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS, 346 MCContext &Ctx) { 347 return Create(LT, LHS, RHS, Ctx); 348 } 349 static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS, 350 MCContext &Ctx) { 351 return Create(LTE, LHS, RHS, Ctx); 352 } 353 static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS, 354 MCContext &Ctx) { 355 return Create(Mod, LHS, RHS, Ctx); 356 } 357 static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS, 358 MCContext &Ctx) { 359 return Create(Mul, LHS, RHS, Ctx); 360 } 361 static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS, 362 MCContext &Ctx) { 363 return Create(NE, LHS, RHS, Ctx); 364 } 365 static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS, 366 MCContext &Ctx) { 367 return Create(Or, LHS, RHS, Ctx); 368 } 369 static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS, 370 MCContext &Ctx) { 371 return Create(Shl, LHS, RHS, Ctx); 372 } 373 static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS, 374 MCContext &Ctx) { 375 return Create(Shr, LHS, RHS, Ctx); 376 } 377 static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS, 378 MCContext &Ctx) { 379 return Create(Sub, LHS, RHS, Ctx); 380 } 381 static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS, 382 MCContext &Ctx) { 383 return Create(Xor, LHS, RHS, Ctx); 384 } 385 386 /// @} 387 /// @name Accessors 388 /// @{ 389 390 /// getOpcode - Get the kind of this binary expression. 391 Opcode getOpcode() const { return Op; } 392 393 /// getLHS - Get the left-hand side expression of the binary operator. 394 const MCExpr *getLHS() const { return LHS; } 395 396 /// getRHS - Get the right-hand side expression of the binary operator. 397 const MCExpr *getRHS() const { return RHS; } 398 399 /// @} 400 401 static bool classof(const MCExpr *E) { 402 return E->getKind() == MCExpr::Binary; 403 } 404 static bool classof(const MCBinaryExpr *) { return true; } 405}; 406 407/// MCTargetExpr - This is an extension point for target-specific MCExpr 408/// subclasses to implement. 409/// 410/// NOTE: All subclasses are required to have trivial destructors because 411/// MCExprs are bump pointer allocated and not destructed. 412class MCTargetExpr : public MCExpr { 413 virtual void Anchor(); 414protected: 415 MCTargetExpr() : MCExpr(Target) {} 416 virtual ~MCTargetExpr() {} 417public: 418 419 virtual void PrintImpl(raw_ostream &OS) const = 0; 420 virtual bool EvaluateAsRelocatableImpl(MCValue &Res, 421 const MCAsmLayout *Layout) const = 0; 422 virtual void AddValueSymbols(MCAssembler *) const = 0; 423 424 static bool classof(const MCExpr *E) { 425 return E->getKind() == MCExpr::Target; 426 } 427 static bool classof(const MCTargetExpr *) { return true; } 428}; 429 430} // end namespace llvm 431 432#endif 433