Line data    Source code

       1             : //===-- AVRMCExpr.h - AVR specific MC expression classes --------*- 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_AVR_MCEXPR_H
      11             : #define LLVM_AVR_MCEXPR_H
      12             : 
      13             : #include "llvm/MC/MCExpr.h"
      14             : 
      15             : #include "MCTargetDesc/AVRFixupKinds.h"
      16             : 
      17             : namespace llvm {
      18             : 
      19             : /// A expression in AVR machine code.
      20             : class AVRMCExpr : public MCTargetExpr {
      21             : public:
      22             :   /// Specifies the type of an expression.
      23             :   enum VariantKind {
      24             :     VK_AVR_None,
      25             : 
      26             :     VK_AVR_HI8,  ///< Corresponds to `hi8()`.
      27             :     VK_AVR_LO8,  ///< Corresponds to `lo8()`.
      28             :     VK_AVR_HH8,  ///< Corresponds to `hlo8() and hh8()`.
      29             :     VK_AVR_HHI8, ///< Corresponds to `hhi8()`.
      30             : 
      31             :     VK_AVR_PM_LO8, ///< Corresponds to `pm_lo8()`.
      32             :     VK_AVR_PM_HI8, ///< Corresponds to `pm_hi8()`.
      33             :     VK_AVR_PM_HH8, ///< Corresponds to `pm_hh8()`.
      34             : 
      35             :     VK_AVR_LO8_GS, ///< Corresponds to `lo8(gs())`.
      36             :     VK_AVR_HI8_GS, ///< Corresponds to `hi8(gs())`.
      37             :     VK_AVR_GS, ///< Corresponds to `gs()`.
      38             :   };
      39             : 
      40             : public:
      41             :   /// Creates an AVR machine code expression.
      42             :   static const AVRMCExpr *create(VariantKind Kind, const MCExpr *Expr,
      43             :                                  bool isNegated, MCContext &Ctx);
      44             : 
      45             :   /// Gets the type of the expression.
      46           0 :   VariantKind getKind() const { return Kind; }
      47             :   /// Gets the name of the expression.
      48             :   const char *getName() const;
      49           0 :   const MCExpr *getSubExpr() const { return SubExpr; }
      50             :   /// Gets the fixup which corresponds to the expression.
      51             :   AVR::Fixups getFixupKind() const;
      52             :   /// Evaluates the fixup as a constant value.
      53             :   bool evaluateAsConstant(int64_t &Result) const;
      54             : 
      55           0 :   bool isNegated() const { return Negated; }
      56             :   void setNegated(bool negated = true) { Negated = negated; }
      57             : 
      58             :   void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
      59             :   bool evaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
      60             :                                  const MCFixup *Fixup) const override;
      61             : 
      62             :   void visitUsedExpr(MCStreamer &streamer) const override;
      63             : 
      64           0 :   MCFragment *findAssociatedFragment() const override {
      65           0 :     return getSubExpr()->findAssociatedFragment();
      66             :   }
      67             : 
      68          42 :   void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override {}
      69             : 
      70             :   static bool classof(const MCExpr *E) {
      71         117 :     return E->getKind() == MCExpr::Target;
      72             :   }
      73             : 
      74             : public:
      75             :   static VariantKind getKindByName(StringRef Name);
      76             : 
      77             : private:
      78             :   int64_t evaluateAsInt64(int64_t Value) const;
      79             : 
      80             :   const VariantKind Kind;
      81             :   const MCExpr *SubExpr;
      82             :   bool Negated;
      83             : 
      84             : private:
      85             :   explicit AVRMCExpr(VariantKind Kind, const MCExpr *Expr, bool Negated)
      86         202 :       : Kind(Kind), SubExpr(Expr), Negated(Negated) {}
      87           0 :   ~AVRMCExpr() {}
      88             : };
      89             : 
      90             : } // end namespace llvm
      91             : 
      92             : #endif // LLVM_AVR_MCEXPR_H