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
18namespace llvm {
19
20class NVPTXFloatMCExpr : public MCTargetExpr {
21public:
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
30private:
31 const VariantKind Kind;
32 const APFloat Flt;
33
34 explicit NVPTXFloatMCExpr(VariantKind Kind, APFloat Flt)
35 : Kind(Kind), Flt(std::move(Flt)) {}
36
37public:
38 /// @name Construction
39 /// @{
40
41 static const NVPTXFloatMCExpr *create(VariantKind Kind, const APFloat &Flt,
42 MCContext &Ctx);
43
44 static const NVPTXFloatMCExpr *createConstantBFPHalf(const APFloat &Flt,
45 MCContext &Ctx) {
46 return create(Kind: VK_NVPTX_BFLOAT_PREC_FLOAT, Flt, Ctx);
47 }
48
49 static const NVPTXFloatMCExpr *createConstantFPHalf(const APFloat &Flt,
50 MCContext &Ctx) {
51 return create(Kind: VK_NVPTX_HALF_PREC_FLOAT, Flt, Ctx);
52 }
53
54 static const NVPTXFloatMCExpr *createConstantFPSingle(const APFloat &Flt,
55 MCContext &Ctx) {
56 return create(Kind: VK_NVPTX_SINGLE_PREC_FLOAT, Flt, Ctx);
57 }
58
59 static const NVPTXFloatMCExpr *createConstantFPDouble(const APFloat &Flt,
60 MCContext &Ctx) {
61 return create(Kind: VK_NVPTX_DOUBLE_PREC_FLOAT, Flt, Ctx);
62 }
63
64 /// @}
65 /// @name Accessors
66 /// @{
67
68 /// getOpcode - Get the kind of this expression.
69 VariantKind getKind() const { return Kind; }
70
71 /// getSubExpr - Get the child of this expression.
72 APFloat getAPFloat() const { return Flt; }
73
74/// @}
75
76 void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
77 bool evaluateAsRelocatableImpl(MCValue &Res,
78 const MCAssembler *Asm) const override {
79 return false;
80 }
81 void visitUsedExpr(MCStreamer &Streamer) const override {};
82 MCFragment *findAssociatedFragment() const override { return nullptr; }
83
84 static bool classof(const MCExpr *E) {
85 return E->getKind() == MCExpr::Target;
86 }
87};
88
89/// A wrapper for MCSymbolRefExpr that tells the assembly printer that the
90/// symbol should be enclosed by generic().
91class NVPTXGenericMCSymbolRefExpr : public MCTargetExpr {
92private:
93 const MCSymbolRefExpr *SymExpr;
94
95 explicit NVPTXGenericMCSymbolRefExpr(const MCSymbolRefExpr *_SymExpr)
96 : SymExpr(_SymExpr) {}
97
98public:
99 /// @name Construction
100 /// @{
101
102 static const NVPTXGenericMCSymbolRefExpr
103 *create(const MCSymbolRefExpr *SymExpr, MCContext &Ctx);
104
105 /// @}
106 /// @name Accessors
107 /// @{
108
109 /// getOpcode - Get the kind of this expression.
110 const MCSymbolRefExpr *getSymbolExpr() const { return SymExpr; }
111
112 /// @}
113
114 void printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const override;
115 bool evaluateAsRelocatableImpl(MCValue &Res,
116 const MCAssembler *Asm) const override {
117 return false;
118 }
119 void visitUsedExpr(MCStreamer &Streamer) const override {};
120 MCFragment *findAssociatedFragment() const override { return nullptr; }
121
122 static bool classof(const MCExpr *E) {
123 return E->getKind() == MCExpr::Target;
124 }
125 };
126} // end namespace llvm
127
128#endif
129