[PowerPC] Support @h modifier
[oota-llvm.git] / 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/ADT/DenseMap.h"
14 #include "llvm/Support/Casting.h"
15 #include "llvm/Support/DataTypes.h"
16
17 namespace llvm {
18 class MCAsmLayout;
19 class MCAssembler;
20 class MCContext;
21 class MCSection;
22 class MCSectionData;
23 class MCSymbol;
24 class MCValue;
25 class raw_ostream;
26 class StringRef;
27 typedef DenseMap<const MCSectionData*, uint64_t> SectionAddrMap;
28
29 /// MCExpr - Base class for the full range of assembler expressions which are
30 /// needed for parsing.
31 class MCExpr {
32 public:
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
41 private:
42   ExprKind Kind;
43
44   MCExpr(const MCExpr&) LLVM_DELETED_FUNCTION;
45   void operator=(const MCExpr&) LLVM_DELETED_FUNCTION;
46
47   bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
48                           const MCAsmLayout *Layout,
49                           const SectionAddrMap *Addrs) const;
50 protected:
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;
57 public:
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 MCAsmLayout &Layout,
82                           const SectionAddrMap &Addrs) const;
83   bool EvaluateAsAbsolute(int64_t &Res) const;
84   bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const;
85   bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout) 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   /// FindAssociatedSection - Find the "associated section" for this expression,
96   /// which is currently defined as the absolute section for constants, or
97   /// otherwise the section associated with the first defined symbol in the
98   /// expression.
99   const MCSection *FindAssociatedSection() const;
100
101   /// @}
102 };
103
104 inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) {
105   E.print(OS);
106   return OS;
107 }
108
109 //// MCConstantExpr - Represent a constant integer expression.
110 class MCConstantExpr : public MCExpr {
111   int64_t Value;
112
113   explicit MCConstantExpr(int64_t _Value)
114     : MCExpr(MCExpr::Constant), Value(_Value) {}
115
116 public:
117   /// @name Construction
118   /// @{
119
120   static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx);
121
122   /// @}
123   /// @name Accessors
124   /// @{
125
126   int64_t getValue() const { return Value; }
127
128   /// @}
129
130   static bool classof(const MCExpr *E) {
131     return E->getKind() == MCExpr::Constant;
132   }
133 };
134
135 /// MCSymbolRefExpr - Represent a reference to a symbol from inside an
136 /// expression.
137 ///
138 /// A symbol reference in an expression may be a use of a label, a use of an
139 /// assembler variable (defined constant), or constitute an implicit definition
140 /// of the symbol as external.
141 class MCSymbolRefExpr : public MCExpr {
142 public:
143   enum VariantKind {
144     VK_None,
145     VK_Invalid,
146
147     VK_GOT,
148     VK_GOTOFF,
149     VK_GOTPCREL,
150     VK_GOTTPOFF,
151     VK_INDNTPOFF,
152     VK_NTPOFF,
153     VK_GOTNTPOFF,
154     VK_PLT,
155     VK_TLSGD,
156     VK_TLSLD,
157     VK_TLSLDM,
158     VK_TPOFF,
159     VK_DTPOFF,
160     VK_TLVP,      // Mach-O thread local variable relocation
161     VK_SECREL,
162     // FIXME: We'd really like to use the generic Kinds listed above for these.
163     VK_ARM_NONE,
164     VK_ARM_PLT,   // ARM-style PLT references. i.e., (PLT) instead of @PLT
165     VK_ARM_TLSGD, //   ditto for TLSGD, GOT, GOTOFF, TPOFF and GOTTPOFF
166     VK_ARM_GOT,
167     VK_ARM_GOTOFF,
168     VK_ARM_TPOFF,
169     VK_ARM_GOTTPOFF,
170     VK_ARM_TARGET1,
171     VK_ARM_TARGET2,
172     VK_ARM_PREL31,
173
174     VK_PPC_LO,             // symbol@l
175     VK_PPC_HI,             // symbol@h
176     VK_PPC_HA,             // symbol@ha
177     VK_PPC_TOCBASE,        // symbol@tocbase
178     VK_PPC_TOC,            // symbol@toc
179     VK_PPC_TOC_LO,         // symbol@toc@l
180     VK_PPC_TOC_HA,         // symbol@toc@ha
181     VK_PPC_TPREL_LO,       // symbol@tprel@l
182     VK_PPC_TPREL_HA,       // symbol@tprel@ha
183     VK_PPC_DTPREL_LO,      // symbol@dtprel@l
184     VK_PPC_DTPREL_HA,      // symbol@dtprel@ha
185     VK_PPC_GOT_TPREL_LO,   // symbol@got@tprel@l
186     VK_PPC_GOT_TPREL_HA,   // symbol@got@tprel@ha
187     VK_PPC_TLS,            // symbol@tls
188     VK_PPC_GOT_TLSGD_LO,   // symbol@got@tlsgd@l
189     VK_PPC_GOT_TLSGD_HA,   // symbol@got@tlsgd@ha
190     VK_PPC_TLSGD,          // symbol@tlsgd
191     VK_PPC_GOT_TLSLD_LO,   // symbol@got@tlsld@l
192     VK_PPC_GOT_TLSLD_HA,   // symbol@got@tlsld@ha
193     VK_PPC_TLSLD,          // symbol@tlsld
194
195     VK_Mips_GPREL,
196     VK_Mips_GOT_CALL,
197     VK_Mips_GOT16,
198     VK_Mips_GOT,
199     VK_Mips_ABS_HI,
200     VK_Mips_ABS_LO,
201     VK_Mips_TLSGD,
202     VK_Mips_TLSLDM,
203     VK_Mips_DTPREL_HI,
204     VK_Mips_DTPREL_LO,
205     VK_Mips_GOTTPREL,
206     VK_Mips_TPREL_HI,
207     VK_Mips_TPREL_LO,
208     VK_Mips_GPOFF_HI,
209     VK_Mips_GPOFF_LO,
210     VK_Mips_GOT_DISP,
211     VK_Mips_GOT_PAGE,
212     VK_Mips_GOT_OFST,
213     VK_Mips_HIGHER,
214     VK_Mips_HIGHEST,
215     VK_Mips_GOT_HI16,
216     VK_Mips_GOT_LO16,
217     VK_Mips_CALL_HI16,
218     VK_Mips_CALL_LO16,
219
220     VK_COFF_IMGREL32 // symbol@imgrel (image-relative)
221   };
222
223 private:
224   /// The symbol being referenced.
225   const MCSymbol *Symbol;
226
227   /// The symbol reference modifier.
228   const VariantKind Kind;
229
230   explicit MCSymbolRefExpr(const MCSymbol *_Symbol, VariantKind _Kind)
231     : MCExpr(MCExpr::SymbolRef), Symbol(_Symbol), Kind(_Kind) {
232     assert(Symbol);
233   }
234
235 public:
236   /// @name Construction
237   /// @{
238
239   static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx) {
240     return MCSymbolRefExpr::Create(Symbol, VK_None, Ctx);
241   }
242
243   static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, VariantKind Kind,
244                                        MCContext &Ctx);
245   static const MCSymbolRefExpr *Create(StringRef Name, VariantKind Kind,
246                                        MCContext &Ctx);
247
248   /// @}
249   /// @name Accessors
250   /// @{
251
252   const MCSymbol &getSymbol() const { return *Symbol; }
253
254   VariantKind getKind() const { return Kind; }
255
256   /// @}
257   /// @name Static Utility Functions
258   /// @{
259
260   static StringRef getVariantKindName(VariantKind Kind);
261
262   static VariantKind getVariantKindForName(StringRef Name);
263
264   /// @}
265
266   static bool classof(const MCExpr *E) {
267     return E->getKind() == MCExpr::SymbolRef;
268   }
269 };
270
271 /// MCUnaryExpr - Unary assembler expressions.
272 class MCUnaryExpr : public MCExpr {
273 public:
274   enum Opcode {
275     LNot,  ///< Logical negation.
276     Minus, ///< Unary minus.
277     Not,   ///< Bitwise negation.
278     Plus   ///< Unary plus.
279   };
280
281 private:
282   Opcode Op;
283   const MCExpr *Expr;
284
285   MCUnaryExpr(Opcode _Op, const MCExpr *_Expr)
286     : MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {}
287
288 public:
289   /// @name Construction
290   /// @{
291
292   static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr,
293                                    MCContext &Ctx);
294   static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) {
295     return Create(LNot, Expr, Ctx);
296   }
297   static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) {
298     return Create(Minus, Expr, Ctx);
299   }
300   static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) {
301     return Create(Not, Expr, Ctx);
302   }
303   static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) {
304     return Create(Plus, Expr, Ctx);
305   }
306
307   /// @}
308   /// @name Accessors
309   /// @{
310
311   /// getOpcode - Get the kind of this unary expression.
312   Opcode getOpcode() const { return Op; }
313
314   /// getSubExpr - Get the child of this unary expression.
315   const MCExpr *getSubExpr() const { return Expr; }
316
317   /// @}
318
319   static bool classof(const MCExpr *E) {
320     return E->getKind() == MCExpr::Unary;
321   }
322 };
323
324 /// MCBinaryExpr - Binary assembler expressions.
325 class MCBinaryExpr : public MCExpr {
326 public:
327   enum Opcode {
328     Add,  ///< Addition.
329     And,  ///< Bitwise and.
330     Div,  ///< Signed division.
331     EQ,   ///< Equality comparison.
332     GT,   ///< Signed greater than comparison (result is either 0 or some
333           ///< target-specific non-zero value)
334     GTE,  ///< Signed greater than or equal comparison (result is either 0 or
335           ///< some target-specific non-zero value).
336     LAnd, ///< Logical and.
337     LOr,  ///< Logical or.
338     LT,   ///< Signed less than comparison (result is either 0 or
339           ///< some target-specific non-zero value).
340     LTE,  ///< Signed less than or equal comparison (result is either 0 or
341           ///< some target-specific non-zero value).
342     Mod,  ///< Signed remainder.
343     Mul,  ///< Multiplication.
344     NE,   ///< Inequality comparison.
345     Or,   ///< Bitwise or.
346     Shl,  ///< Shift left.
347     Shr,  ///< Shift right (arithmetic or logical, depending on target)
348     Sub,  ///< Subtraction.
349     Xor   ///< Bitwise exclusive or.
350   };
351
352 private:
353   Opcode Op;
354   const MCExpr *LHS, *RHS;
355
356   MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS)
357     : MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
358
359 public:
360   /// @name Construction
361   /// @{
362
363   static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS,
364                                     const MCExpr *RHS, MCContext &Ctx);
365   static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS,
366                                        MCContext &Ctx) {
367     return Create(Add, LHS, RHS, Ctx);
368   }
369   static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS,
370                                        MCContext &Ctx) {
371     return Create(And, LHS, RHS, Ctx);
372   }
373   static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS,
374                                        MCContext &Ctx) {
375     return Create(Div, LHS, RHS, Ctx);
376   }
377   static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS,
378                                       MCContext &Ctx) {
379     return Create(EQ, LHS, RHS, Ctx);
380   }
381   static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS,
382                                       MCContext &Ctx) {
383     return Create(GT, LHS, RHS, Ctx);
384   }
385   static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS,
386                                        MCContext &Ctx) {
387     return Create(GTE, LHS, RHS, Ctx);
388   }
389   static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS,
390                                         MCContext &Ctx) {
391     return Create(LAnd, LHS, RHS, Ctx);
392   }
393   static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS,
394                                        MCContext &Ctx) {
395     return Create(LOr, LHS, RHS, Ctx);
396   }
397   static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS,
398                                       MCContext &Ctx) {
399     return Create(LT, LHS, RHS, Ctx);
400   }
401   static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS,
402                                        MCContext &Ctx) {
403     return Create(LTE, LHS, RHS, Ctx);
404   }
405   static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS,
406                                        MCContext &Ctx) {
407     return Create(Mod, LHS, RHS, Ctx);
408   }
409   static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS,
410                                        MCContext &Ctx) {
411     return Create(Mul, LHS, RHS, Ctx);
412   }
413   static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS,
414                                       MCContext &Ctx) {
415     return Create(NE, LHS, RHS, Ctx);
416   }
417   static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS,
418                                       MCContext &Ctx) {
419     return Create(Or, LHS, RHS, Ctx);
420   }
421   static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS,
422                                        MCContext &Ctx) {
423     return Create(Shl, LHS, RHS, Ctx);
424   }
425   static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS,
426                                        MCContext &Ctx) {
427     return Create(Shr, LHS, RHS, Ctx);
428   }
429   static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS,
430                                        MCContext &Ctx) {
431     return Create(Sub, LHS, RHS, Ctx);
432   }
433   static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS,
434                                        MCContext &Ctx) {
435     return Create(Xor, LHS, RHS, Ctx);
436   }
437
438   /// @}
439   /// @name Accessors
440   /// @{
441
442   /// getOpcode - Get the kind of this binary expression.
443   Opcode getOpcode() const { return Op; }
444
445   /// getLHS - Get the left-hand side expression of the binary operator.
446   const MCExpr *getLHS() const { return LHS; }
447
448   /// getRHS - Get the right-hand side expression of the binary operator.
449   const MCExpr *getRHS() const { return RHS; }
450
451   /// @}
452
453   static bool classof(const MCExpr *E) {
454     return E->getKind() == MCExpr::Binary;
455   }
456 };
457
458 /// MCTargetExpr - This is an extension point for target-specific MCExpr
459 /// subclasses to implement.
460 ///
461 /// NOTE: All subclasses are required to have trivial destructors because
462 /// MCExprs are bump pointer allocated and not destructed.
463 class MCTargetExpr : public MCExpr {
464   virtual void anchor();
465 protected:
466   MCTargetExpr() : MCExpr(Target) {}
467   virtual ~MCTargetExpr() {}
468 public:
469
470   virtual void PrintImpl(raw_ostream &OS) const = 0;
471   virtual bool EvaluateAsRelocatableImpl(MCValue &Res,
472                                          const MCAsmLayout *Layout) const = 0;
473   virtual void AddValueSymbols(MCAssembler *) const = 0;
474   virtual const MCSection *FindAssociatedSection() const = 0;
475
476   virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0;
477
478   static bool classof(const MCExpr *E) {
479     return E->getKind() == MCExpr::Target;
480   }
481 };
482
483 } // end namespace llvm
484
485 #endif