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 "SIDefines.h"
16 #include "Utils/AMDGPUBaseInfo.h"
17 #include "Utils/AMDKernelCodeTUtils.h"
18 #include "llvm/ADT/Twine.h"
19 #include "llvm/MC/MCContext.h"
20 #include "llvm/MC/MCELFStreamer.h"
21 #include "llvm/MC/MCObjectFileInfo.h"
22 #include "llvm/MC/MCSectionELF.h"
23 #include "llvm/Support/ELF.h"
24 #include "llvm/Support/FormattedStream.h"
25 
26 using namespace llvm;
27 
28 AMDGPUTargetStreamer::AMDGPUTargetStreamer(MCStreamer &S)
29     : MCTargetStreamer(S) { }
30 
31 //===----------------------------------------------------------------------===//
32 // AMDGPUTargetAsmStreamer
33 //===----------------------------------------------------------------------===//
34 
35 AMDGPUTargetAsmStreamer::AMDGPUTargetAsmStreamer(MCStreamer &S,
36                                                  formatted_raw_ostream &OS)
37     : AMDGPUTargetStreamer(S), OS(OS) { }
38 
39 void
40 AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectVersion(uint32_t Major,
41                                                            uint32_t Minor) {
42   OS << "\t.hsa_code_object_version " <<
43         Twine(Major) << "," << Twine(Minor) << '\n';
44 }
45 
46 void
47 AMDGPUTargetAsmStreamer::EmitDirectiveHSACodeObjectISA(uint32_t Major,
48                                                        uint32_t Minor,
49                                                        uint32_t Stepping,
50                                                        StringRef VendorName,
51                                                        StringRef ArchName) {
52   OS << "\t.hsa_code_object_isa " <<
53         Twine(Major) << "," << Twine(Minor) << "," << Twine(Stepping) <<
54         ",\"" << VendorName << "\",\"" << ArchName << "\"\n";
55 
56 }
57 
58 void
59 AMDGPUTargetAsmStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) {
60   OS << "\t.amd_kernel_code_t\n";
61   dumpAmdKernelCode(&Header, OS, "\t\t");
62   OS << "\t.end_amd_kernel_code_t\n";
63 }
64 
65 void AMDGPUTargetAsmStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
66                                                    unsigned Type) {
67   switch (Type) {
68     default: llvm_unreachable("Invalid AMDGPU symbol type");
69     case ELF::STT_AMDGPU_HSA_KERNEL:
70       OS << "\t.amdgpu_hsa_kernel " << SymbolName << '\n' ;
71       break;
72   }
73 }
74 
75 void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaModuleScopeGlobal(
76     StringRef GlobalName) {
77   OS << "\t.amdgpu_hsa_module_global " << GlobalName << '\n';
78 }
79 
80 void AMDGPUTargetAsmStreamer::EmitAMDGPUHsaProgramScopeGlobal(
81     StringRef GlobalName) {
82   OS << "\t.amdgpu_hsa_program_global " << GlobalName << '\n';
83 }
84 
85 //===----------------------------------------------------------------------===//
86 // AMDGPUTargetELFStreamer
87 //===----------------------------------------------------------------------===//
88 
89 const char *AMDGPUTargetELFStreamer::NoteName = "AMD";
90 
91 AMDGPUTargetELFStreamer::AMDGPUTargetELFStreamer(MCStreamer &S)
92     : AMDGPUTargetStreamer(S), Streamer(S) { }
93 
94 MCELFStreamer &AMDGPUTargetELFStreamer::getStreamer() {
95   return static_cast<MCELFStreamer &>(Streamer);
96 }
97 
98 void
99 AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectVersion(uint32_t Major,
100                                                            uint32_t Minor) {
101   MCStreamer &OS = getStreamer();
102   MCSectionELF *Note =
103       OS.getContext().getELFSection(".note", ELF::SHT_NOTE, ELF::SHF_ALLOC);
104 
105   OS.PushSection();
106   OS.SwitchSection(Note);
107   OS.EmitIntValue(strlen(NoteName) + 1, 4);                // namesz
108   OS.EmitIntValue(8, 4);                                   // descz
109   OS.EmitIntValue(NT_AMDGPU_HSA_CODE_OBJECT_VERSION, 4);   // type
110   OS.EmitBytes(StringRef(NoteName, strlen(NoteName) + 1)); // name
111   OS.EmitValueToAlignment(4);
112   OS.EmitIntValue(Major, 4);                               // desc
113   OS.EmitIntValue(Minor, 4);
114   OS.EmitValueToAlignment(4);
115   OS.PopSection();
116 }
117 
118 void
119 AMDGPUTargetELFStreamer::EmitDirectiveHSACodeObjectISA(uint32_t Major,
120                                                        uint32_t Minor,
121                                                        uint32_t Stepping,
122                                                        StringRef VendorName,
123                                                        StringRef ArchName) {
124   MCStreamer &OS = getStreamer();
125   MCSectionELF *Note =
126       OS.getContext().getELFSection(".note", ELF::SHT_NOTE, ELF::SHF_ALLOC);
127 
128   uint16_t VendorNameSize = VendorName.size() + 1;
129   uint16_t ArchNameSize = ArchName.size() + 1;
130   unsigned DescSZ = sizeof(VendorNameSize) + sizeof(ArchNameSize) +
131                     sizeof(Major) + sizeof(Minor) + sizeof(Stepping) +
132                     VendorNameSize + ArchNameSize;
133 
134   OS.PushSection();
135   OS.SwitchSection(Note);
136   OS.EmitIntValue(strlen(NoteName) + 1, 4);                // namesz
137   OS.EmitIntValue(DescSZ, 4);                              // descsz
138   OS.EmitIntValue(NT_AMDGPU_HSA_ISA, 4);                   // type
139   OS.EmitBytes(StringRef(NoteName, strlen(NoteName) + 1)); // name
140   OS.EmitValueToAlignment(4);
141   OS.EmitIntValue(VendorNameSize, 2);                      // desc
142   OS.EmitIntValue(ArchNameSize, 2);
143   OS.EmitIntValue(Major, 4);
144   OS.EmitIntValue(Minor, 4);
145   OS.EmitIntValue(Stepping, 4);
146   OS.EmitBytes(VendorName);
147   OS.EmitIntValue(0, 1); // NULL terminate VendorName
148   OS.EmitBytes(ArchName);
149   OS.EmitIntValue(0, 1); // NULL terminte ArchName
150   OS.EmitValueToAlignment(4);
151   OS.PopSection();
152 }
153 
154 void
155 AMDGPUTargetELFStreamer::EmitAMDKernelCodeT(const amd_kernel_code_t &Header) {
156 
157   MCStreamer &OS = getStreamer();
158   OS.PushSection();
159   OS.EmitBytes(StringRef((const char*)&Header, sizeof(Header)));
160   OS.PopSection();
161 }
162 
163 void AMDGPUTargetELFStreamer::EmitAMDGPUSymbolType(StringRef SymbolName,
164                                                    unsigned Type) {
165   MCSymbolELF *Symbol = cast<MCSymbolELF>(
166       getStreamer().getContext().getOrCreateSymbol(SymbolName));
167   Symbol->setType(ELF::STT_AMDGPU_HSA_KERNEL);
168 }
169 
170 void AMDGPUTargetELFStreamer::EmitAMDGPUHsaModuleScopeGlobal(
171     StringRef GlobalName) {
172 
173   MCSymbolELF *Symbol = cast<MCSymbolELF>(
174       getStreamer().getContext().getOrCreateSymbol(GlobalName));
175   Symbol->setType(ELF::STT_OBJECT);
176   Symbol->setBinding(ELF::STB_LOCAL);
177 }
178 
179 void AMDGPUTargetELFStreamer::EmitAMDGPUHsaProgramScopeGlobal(
180     StringRef GlobalName) {
181 
182   MCSymbolELF *Symbol = cast<MCSymbolELF>(
183       getStreamer().getContext().getOrCreateSymbol(GlobalName));
184   Symbol->setType(ELF::STT_OBJECT);
185   Symbol->setBinding(ELF::STB_GLOBAL);
186 }
187