1 //===-- NVPTXMCExpr.h - NVPTX specific MC expression classes ----*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 // Modeled after ARMMCExpr 10 11 #ifndef LLVM_LIB_TARGET_NVPTX_NVPTXMCEXPR_H 12 #define LLVM_LIB_TARGET_NVPTX_NVPTXMCEXPR_H 13 14 #include "llvm/ADT/APFloat.h" 15 #include "llvm/MC/MCExpr.h" 16 #include <utility> 17 18 namespace llvm { 19 20 class NVPTXFloatMCExpr : public MCTargetExpr { 21 public: 22 enum VariantKind { 23 VK_NVPTX_None, 24 VK_NVPTX_BFLOAT_PREC_FLOAT, // FP constant in bfloat-precision 25 VK_NVPTX_HALF_PREC_FLOAT, // FP constant in half-precision 26 VK_NVPTX_SINGLE_PREC_FLOAT, // FP constant in single-precision 27 VK_NVPTX_DOUBLE_PREC_FLOAT // FP constant in double-precision 28 }; 29 30 private: 31 const VariantKind Kind; 32 const APFloat Flt; 33 NVPTXFloatMCExpr(VariantKind Kind,APFloat Flt)34 explicit NVPTXFloatMCExpr(VariantKind Kind, APFloat Flt) 35 : Kind(Kind), Flt(std::move(Flt)) {} 36 37 public: 38 /// @name Construction 39 /// @{ 40 41 static const NVPTXFloatMCExpr *create(VariantKind Kind, const APFloat &Flt, 42 MCContext &Ctx); 43 createConstantBFPHalf(const APFloat & Flt,MCContext & Ctx)44 static const NVPTXFloatMCExpr *createConstantBFPHalf(const APFloat &Flt, 45 MCContext &Ctx) { 46 return create(VK_NVPTX_BFLOAT_PREC_FLOAT, Flt, Ctx); 47 } 48 createConstantFPHalf(const APFloat & Flt,MCContext & Ctx)49 static const NVPTXFloatMCExpr *createConstantFPHalf(const APFloat &Flt, 50 MCContext &Ctx) { 51 return create(VK_NVPTX_HALF_PREC_FLOAT, Flt, Ctx); 52 } 53 createConstantFPSingle(const APFloat & Flt,MCContext & Ctx)54 static const NVPTXFloatMCExpr *createConstantFPSingle(const APFloat &Flt, 55 MCContext &Ctx) { 56 return create(VK_NVPTX_SINGLE_PREC_FLOAT, Flt, Ctx); 57 } 58 createConstantFPDouble(const APFloat & Flt,MCContext & Ctx)59 static const NVPTXFloatMCExpr *createConstantFPDouble(const APFloat &Flt, 60 MCContext &Ctx) { 61 return create(VK_NVPTX_DOUBLE_PREC_FLOAT, Flt, Ctx); 62 } 63 64 /// @} 65 /// @name Accessors 66 /// @{ 67 68 /// getOpcode - Get the kind of this expression. getKind()69 VariantKind getKind() const { return Kind; } 70 71 /// getSubExpr - Get the child of this expression. getAPFloat()72 APFloat getAPFloat() const { return Flt; } 73 74 /// @} 75 76 void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override; evaluateAsRelocatableImpl(MCValue & Res,const MCAssembler * Asm,const MCFixup * Fixup)77 bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, 78 const MCFixup *Fixup) const override { 79 return false; 80 } visitUsedExpr(MCStreamer & Streamer)81 void visitUsedExpr(MCStreamer &Streamer) const override {}; findAssociatedFragment()82 MCFragment *findAssociatedFragment() const override { return nullptr; } 83 84 // There are no TLS NVPTXMCExprs at the moment. fixELFSymbolsInTLSFixups(MCAssembler & Asm)85 void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override {} 86 classof(const MCExpr * E)87 static bool classof(const MCExpr *E) { 88 return E->getKind() == MCExpr::Target; 89 } 90 }; 91 92 /// A wrapper for MCSymbolRefExpr that tells the assembly printer that the 93 /// symbol should be enclosed by generic(). 94 class NVPTXGenericMCSymbolRefExpr : public MCTargetExpr { 95 private: 96 const MCSymbolRefExpr *SymExpr; 97 NVPTXGenericMCSymbolRefExpr(const MCSymbolRefExpr * _SymExpr)98 explicit NVPTXGenericMCSymbolRefExpr(const MCSymbolRefExpr *_SymExpr) 99 : SymExpr(_SymExpr) {} 100 101 public: 102 /// @name Construction 103 /// @{ 104 105 static const NVPTXGenericMCSymbolRefExpr 106 *create(const MCSymbolRefExpr *SymExpr, MCContext &Ctx); 107 108 /// @} 109 /// @name Accessors 110 /// @{ 111 112 /// getOpcode - Get the kind of this expression. getSymbolExpr()113 const MCSymbolRefExpr *getSymbolExpr() const { return SymExpr; } 114 115 /// @} 116 117 void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override; evaluateAsRelocatableImpl(MCValue & Res,const MCAssembler * Asm,const MCFixup * Fixup)118 bool evaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm, 119 const MCFixup *Fixup) const override { 120 return false; 121 } visitUsedExpr(MCStreamer & Streamer)122 void visitUsedExpr(MCStreamer &Streamer) const override {}; findAssociatedFragment()123 MCFragment *findAssociatedFragment() const override { return nullptr; } 124 125 // There are no TLS NVPTXMCExprs at the moment. fixELFSymbolsInTLSFixups(MCAssembler & Asm)126 void fixELFSymbolsInTLSFixups(MCAssembler &Asm) const override {} 127 classof(const MCExpr * E)128 static bool classof(const MCExpr *E) { 129 return E->getKind() == MCExpr::Target; 130 } 131 }; 132 } // end namespace llvm 133 134 #endif 135