1 //===-- AMDGPUTargetStreamer.cpp - Mips Target Streamer Methods -----------===//
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 // This file provides AMDGPU specific target streamer methods.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "AMDGPUTargetStreamer.h"
15 #include "AMDGPU.h"
16 #include "SIDefines.h"
17 #include "Utils/AMDGPUBaseInfo.h"
18 #include "Utils/AMDKernelCodeTUtils.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/BinaryFormat/ELF.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/IR/Metadata.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/MC/MCContext.h"
26 #include "llvm/MC/MCELFStreamer.h"
27 #include "llvm/MC/MCObjectFileInfo.h"
28 #include "llvm/MC/MCSectionELF.h"
29 #include "llvm/Support/FormattedStream.h"
30 
31 namespace llvm {
32 #include "AMDGPUPTNote.h"
33 }
34 
35 using namespace llvm;
36 using namespace llvm::AMDGPU;
37 
38 //===----------------------------------------------------------------------===//
39 // AMDGPUTargetStreamer
40 //===----------------------------------------------------------------------===//
41 
42 bool AMDGPUTargetStreamer::EmitHSAMetadata(StringRef HSAMetadataString) {
43   HSAMD::Metadata HSAMetadata;
44   if (HSAMD::fromString(HSAMetadataString, HSAMetadata))
45     return false;
46 
47   return EmitHSAMetadata(HSAMetadata);
48 }
49 
50 //===----------------------------------------------------------------------===//
51 // AMDGPUTargetAsmStreamer
52 //===----------------------------------------------------------------------===//
53 
54 AMDGPUTargetAsmStreamer::AMDGPUTargetAsmStreamer(MCStreamer &S,
55                                                  formatted_raw_ostream &OS)
56     : AMDGPUTargetStreamer(S), OS(OS) { }
57 
58 void
59 AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectVersion(uint32_t Major,
60                                                            uint32_t Minor) {
61   OS << "\t.hsa_code_object_version " <<
62         Twine(Major) << "," << Twine(Minor) << '\n';
63 }
64 
65 void
66 AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectISA(uint32_t Major,
67                                                        uint32_t Minor,
68                                                        uint32_t Stepping,
69                                                        StringRef VendorName,
70                                                        StringRef ArchName) {
71   OS << "\t.hsa_code_object_isa " <<
72         Twine(Major) << "," << Twine(Minor) << "," << Twine(Stepping) <<
73         ",\"" << VendorName << "\",\"" << ArchName << "\"\n";
74 
75 }
76 
77 void
78 AMDGPUTargetAsmStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) {
79   OS << "\t.amd_kernel_code_t\n";
80   dumpAmdKernelCode(&Header, OS, "\t\t");
81   OS << "\t.end_amd_kernel_code_t\n";
82 }
83 
84 void AMDGPUTargetAsmStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
85                                                    unsigned Type) {
86   switch (Type) {
87     default: llvm_unreachable("Invalid AMDGPU symbol type");
88     case ELF::STT_AMDGPU_HSA_KERNEL:
89       OS << "\t.amdgpu_hsa_kernel " << SymbolName << '\n' ;
90       break;
91   }
92 }
93 
94 bool AMDGPUTargetAsmStreamer::EmitISAVersion(StringRef IsaVersionString) {
95   OS << "\t.amd_amdgpu_isa \"" << IsaVersionString << "\"\n";
96   return true;
97 }
98 
99 bool AMDGPUTargetAsmStreamer::EmitHSAMetadata(
100     const AMDGPU::HSAMD::Metadata &HSAMetadata) {
101   std::string HSAMetadataString;
102   if (HSAMD::toString(HSAMetadata, HSAMetadataString))
103     return false;
104 
105   OS << '\t' << HSAMD::AssemblerDirectiveBegin << '\n';
106   OS << HSAMetadataString << '\n';
107   OS << '\t' << HSAMD::AssemblerDirectiveEnd << '\n';
108   return true;
109 }
110 
111 bool AMDGPUTargetAsmStreamer::EmitPALMetadata(
112     const PALMD::Metadata &PALMetadata) {
113   std::string PALMetadataString;
114   if (PALMD::toString(PALMetadata, PALMetadataString))
115     return false;
116 
117   OS << '\t' << PALMD::AssemblerDirective << PALMetadataString << '\n';
118   return true;
119 }
120 
121 //===----------------------------------------------------------------------===//
122 // AMDGPUTargetELFStreamer
123 //===----------------------------------------------------------------------===//
124 
125 AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(MCStreamer &S)
126     : AMDGPUTargetStreamer(S), Streamer(S) {}
127 
128 MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() {
129   return static_cast<MCELFStreamer &>(Streamer);
130 }
131 
132 void AMDGPUTargetELFStreamer::EmitAMDGPUNote(
133     const MCExpr *DescSZ, unsigned NoteType,
134     function_ref<void(MCELFStreamer &)> EmitDesc) {
135   auto &S = getStreamer();
136   auto &Context = S.getContext();
137 
138   auto NameSZ = sizeof(ElfNote::NoteName);
139 
140   S.PushSection();
141   S.SwitchSection(Context.getELFSection(
142     ElfNote::SectionName, ELF::SHT_NOTE, ELF::SHF_ALLOC));
143   S.EmitIntValue(NameSZ, 4);                                  // namesz
144   S.EmitValue(DescSZ, 4);                                     // descz
145   S.EmitIntValue(NoteType, 4);                                // type
146   S.EmitBytes(StringRef(ElfNote::NoteName, NameSZ));          // name
147   S.EmitValueToAlignment(4, 0, 1, 0);                         // padding 0
148   EmitDesc(S);                                                // desc
149   S.EmitValueToAlignment(4, 0, 1, 0);                         // padding 0
150   S.PopSection();
151 }
152 
153 void
154 AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectVersion(uint32_t Major,
155                                                            uint32_t Minor) {
156 
157   EmitAMDGPUNote(
158     MCConstantExpr::create(8, getContext()),
159     ElfNote::NT_AMDGPU_HSA_CODE_OBJECT_VERSION,
160     [&](MCELFStreamer &OS){
161       OS.EmitIntValue(Major, 4);
162       OS.EmitIntValue(Minor, 4);
163     }
164   );
165 }
166 
167 void
168 AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectISA(uint32_t Major,
169                                                        uint32_t Minor,
170                                                        uint32_t Stepping,
171                                                        StringRef VendorName,
172                                                        StringRef ArchName) {
173   uint16_t VendorNameSize = VendorName.size() + 1;
174   uint16_t ArchNameSize = ArchName.size() + 1;
175 
176   unsigned DescSZ = sizeof(VendorNameSize) + sizeof(ArchNameSize) +
177     sizeof(Major) + sizeof(Minor) + sizeof(Stepping) +
178     VendorNameSize + ArchNameSize;
179 
180   EmitAMDGPUNote(
181     MCConstantExpr::create(DescSZ, getContext()),
182     ElfNote::NT_AMDGPU_HSA_ISA,
183     [&](MCELFStreamer &OS) {
184       OS.EmitIntValue(VendorNameSize, 2);
185       OS.EmitIntValue(ArchNameSize, 2);
186       OS.EmitIntValue(Major, 4);
187       OS.EmitIntValue(Minor, 4);
188       OS.EmitIntValue(Stepping, 4);
189       OS.EmitBytes(VendorName);
190       OS.EmitIntValue(0, 1); // NULL terminate VendorName
191       OS.EmitBytes(ArchName);
192       OS.EmitIntValue(0, 1); // NULL terminte ArchName
193     }
194   );
195 }
196 
197 void
198 AMDGPUTargetELFStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) {
199 
200   MCStreamer &OS = getStreamer();
201   OS.PushSection();
202   OS.EmitBytes(StringRef((const char*)&Header, sizeof(Header)));
203   OS.PopSection();
204 }
205 
206 void AMDGPUTargetELFStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
207                                                    unsigned Type) {
208   MCSymbolELF *Symbol = cast<MCSymbolELF>(
209       getStreamer().getContext().getOrCreateSymbol(SymbolName));
210   Symbol->setType(ELF::STT_AMDGPU_HSA_KERNEL);
211 }
212 
213 bool AMDGPUTargetELFStreamer::EmitISAVersion(StringRef IsaVersionString) {
214   // Create two labels to mark the beginning and end of the desc field
215   // and a MCExpr to calculate the size of the desc field.
216   auto &Context = getContext();
217   auto *DescBegin = Context.createTempSymbol();
218   auto *DescEnd = Context.createTempSymbol();
219   auto *DescSZ = MCBinaryExpr::createSub(
220     MCSymbolRefExpr::create(DescEnd, Context),
221     MCSymbolRefExpr::create(DescBegin, Context), Context);
222 
223   EmitAMDGPUNote(
224     DescSZ,
225     ELF::NT_AMD_AMDGPU_ISA,
226     [&](MCELFStreamer &OS) {
227       OS.EmitLabel(DescBegin);
228       OS.EmitBytes(IsaVersionString);
229       OS.EmitLabel(DescEnd);
230     }
231   );
232   return true;
233 }
234 
235 bool AMDGPUTargetELFStreamer::EmitHSAMetadata(
236     const AMDGPU::HSAMD::Metadata &HSAMetadata) {
237   std::string HSAMetadataString;
238   if (HSAMD::toString(HSAMetadata, HSAMetadataString))
239     return false;
240 
241   // Create two labels to mark the beginning and end of the desc field
242   // and a MCExpr to calculate the size of the desc field.
243   auto &Context = getContext();
244   auto *DescBegin = Context.createTempSymbol();
245   auto *DescEnd = Context.createTempSymbol();
246   auto *DescSZ = MCBinaryExpr::createSub(
247     MCSymbolRefExpr::create(DescEnd, Context),
248     MCSymbolRefExpr::create(DescBegin, Context), Context);
249 
250   EmitAMDGPUNote(
251     DescSZ,
252     ELF::NT_AMD_AMDGPU_HSA_METADATA,
253     [&](MCELFStreamer &OS) {
254       OS.EmitLabel(DescBegin);
255       OS.EmitBytes(HSAMetadataString);
256       OS.EmitLabel(DescEnd);
257     }
258   );
259   return true;
260 }
261 
262 bool AMDGPUTargetELFStreamer::EmitPALMetadata(
263     const PALMD::Metadata &PALMetadata) {
264   EmitAMDGPUNote(
265     MCConstantExpr::create(PALMetadata.size() * sizeof(uint32_t), getContext()),
266     ELF::NT_AMD_AMDGPU_PAL_METADATA,
267     [&](MCELFStreamer &OS){
268       for (auto I : PALMetadata)
269         OS.EmitIntValue(I, sizeof(uint32_t));
270     }
271   );
272   return true;
273 }
274