2 * Copyright 2014 Advanced Micro Devices, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
17 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
18 * USE OR OTHER DEALINGS IN THE SOFTWARE.
20 * The above copyright notice and this permission notice (including the
21 * next paragraph) shall be included in all copies or substantial portions
25 /* based on pieces from si_pipe.c and radeon_llvm_emit.c */
26 #include "ac_llvm_util.h"
27 #include "ac_llvm_build.h"
28 #include "util/bitscan.h"
29 #include <llvm-c/Core.h>
30 #include <llvm-c/Support.h>
31 #include <llvm-c/Transforms/IPO.h>
32 #include <llvm-c/Transforms/Scalar.h>
33 #if HAVE_LLVM >= 0x0700
34 #include <llvm-c/Transforms/Utils.h>
36 #include "c11/threads.h"
37 #include "util/u_math.h"
43 static void ac_init_llvm_target()
45 LLVMInitializeAMDGPUTargetInfo();
46 LLVMInitializeAMDGPUTarget();
47 LLVMInitializeAMDGPUTargetMC();
48 LLVMInitializeAMDGPUAsmPrinter();
50 /* For inline assembly. */
51 LLVMInitializeAMDGPUAsmParser();
53 /* Workaround for bug in llvm 4.0 that causes image intrinsics
55 * https://reviews.llvm.org/D26348
57 * "mesa" is the prefix for error messages.
59 const char *argv
[2] = { "mesa", "-simplifycfg-sink-common=false" };
60 LLVMParseCommandLineOptions(2, argv
, NULL
);
63 static once_flag ac_init_llvm_target_once_flag
= ONCE_FLAG_INIT
;
65 void ac_init_llvm_once(void)
67 call_once(&ac_init_llvm_target_once_flag
, ac_init_llvm_target
);
70 LLVMTargetRef
ac_get_llvm_target(const char *triple
)
72 LLVMTargetRef target
= NULL
;
73 char *err_message
= NULL
;
75 if (LLVMGetTargetFromTriple(triple
, &target
, &err_message
)) {
76 fprintf(stderr
, "Cannot find target for triple %s ", triple
);
78 fprintf(stderr
, "%s\n", err_message
);
80 LLVMDisposeMessage(err_message
);
86 const char *ac_get_llvm_processor_name(enum radeon_family family
)
130 return HAVE_LLVM
>= 0x0700 ? "gfx904" : "gfx902";
136 LLVMTargetMachineRef
ac_create_target_machine(enum radeon_family family
,
137 enum ac_target_machine_options tm_options
,
138 const char **out_triple
)
140 assert(family
>= CHIP_TAHITI
);
142 const char *triple
= (tm_options
& AC_TM_SUPPORTS_SPILL
) ? "amdgcn-mesa-mesa3d" : "amdgcn--";
143 LLVMTargetRef target
= ac_get_llvm_target(triple
);
144 bool barrier_does_waitcnt
= true; /* TODO: not for Vega20 */
146 snprintf(features
, sizeof(features
),
147 "+DumpCode,+vgpr-spilling,-fp32-denormals,+fp64-denormals%s%s%s%s%s",
148 tm_options
& AC_TM_SISCHED
? ",+si-scheduler" : "",
149 tm_options
& AC_TM_FORCE_ENABLE_XNACK
? ",+xnack" : "",
150 tm_options
& AC_TM_FORCE_DISABLE_XNACK
? ",-xnack" : "",
151 tm_options
& AC_TM_PROMOTE_ALLOCA_TO_SCRATCH
? ",-promote-alloca" : "",
152 barrier_does_waitcnt
? ",+auto-waitcnt-before-barrier" : "");
154 LLVMTargetMachineRef tm
= LLVMCreateTargetMachine(
157 ac_get_llvm_processor_name(family
),
159 LLVMCodeGenLevelDefault
,
161 LLVMCodeModelDefault
);
164 *out_triple
= triple
;
168 LLVMPassManagerRef
ac_create_passmgr(LLVMTargetLibraryInfoRef target_library_info
,
171 LLVMPassManagerRef passmgr
= LLVMCreatePassManager();
175 if (target_library_info
)
176 LLVMAddTargetLibraryInfo(target_library_info
,
180 LLVMAddVerifierPass(passmgr
);
181 LLVMAddAlwaysInlinerPass(passmgr
);
182 /* This pass should eliminate all the load and store instructions. */
183 LLVMAddPromoteMemoryToRegisterPass(passmgr
);
184 LLVMAddScalarReplAggregatesPass(passmgr
);
185 LLVMAddLICMPass(passmgr
);
186 LLVMAddAggressiveDCEPass(passmgr
);
187 LLVMAddCFGSimplificationPass(passmgr
);
188 /* This is recommended by the instruction combining pass. */
189 LLVMAddEarlyCSEMemSSAPass(passmgr
);
190 LLVMAddInstructionCombiningPass(passmgr
);
194 static const char *attr_to_str(enum ac_func_attr attr
)
197 case AC_FUNC_ATTR_ALWAYSINLINE
: return "alwaysinline";
198 case AC_FUNC_ATTR_INREG
: return "inreg";
199 case AC_FUNC_ATTR_NOALIAS
: return "noalias";
200 case AC_FUNC_ATTR_NOUNWIND
: return "nounwind";
201 case AC_FUNC_ATTR_READNONE
: return "readnone";
202 case AC_FUNC_ATTR_READONLY
: return "readonly";
203 case AC_FUNC_ATTR_WRITEONLY
: return "writeonly";
204 case AC_FUNC_ATTR_INACCESSIBLE_MEM_ONLY
: return "inaccessiblememonly";
205 case AC_FUNC_ATTR_CONVERGENT
: return "convergent";
207 fprintf(stderr
, "Unhandled function attribute: %x\n", attr
);
213 ac_add_function_attr(LLVMContextRef ctx
, LLVMValueRef function
,
214 int attr_idx
, enum ac_func_attr attr
)
216 const char *attr_name
= attr_to_str(attr
);
217 unsigned kind_id
= LLVMGetEnumAttributeKindForName(attr_name
,
219 LLVMAttributeRef llvm_attr
= LLVMCreateEnumAttribute(ctx
, kind_id
, 0);
221 if (LLVMIsAFunction(function
))
222 LLVMAddAttributeAtIndex(function
, attr_idx
, llvm_attr
);
224 LLVMAddCallSiteAttribute(function
, attr_idx
, llvm_attr
);
227 void ac_add_func_attributes(LLVMContextRef ctx
, LLVMValueRef function
,
228 unsigned attrib_mask
)
230 attrib_mask
|= AC_FUNC_ATTR_NOUNWIND
;
231 attrib_mask
&= ~AC_FUNC_ATTR_LEGACY
;
233 while (attrib_mask
) {
234 enum ac_func_attr attr
= 1u << u_bit_scan(&attrib_mask
);
235 ac_add_function_attr(ctx
, function
, -1, attr
);
240 ac_dump_module(LLVMModuleRef module
)
242 char *str
= LLVMPrintModuleToString(module
);
243 fprintf(stderr
, "%s", str
);
244 LLVMDisposeMessage(str
);
248 ac_llvm_add_target_dep_function_attr(LLVMValueRef F
,
249 const char *name
, unsigned value
)
253 snprintf(str
, sizeof(str
), "0x%x", value
);
254 LLVMAddTargetDependentFunctionAttr(F
, name
, str
);
258 ac_count_scratch_private_memory(LLVMValueRef function
)
260 unsigned private_mem_vgprs
= 0;
262 /* Process all LLVM instructions. */
263 LLVMBasicBlockRef bb
= LLVMGetFirstBasicBlock(function
);
265 LLVMValueRef next
= LLVMGetFirstInstruction(bb
);
268 LLVMValueRef inst
= next
;
269 next
= LLVMGetNextInstruction(next
);
271 if (LLVMGetInstructionOpcode(inst
) != LLVMAlloca
)
274 LLVMTypeRef type
= LLVMGetElementType(LLVMTypeOf(inst
));
275 /* No idea why LLVM aligns allocas to 4 elements. */
276 unsigned alignment
= LLVMGetAlignment(inst
);
277 unsigned dw_size
= align(ac_get_type_size(type
) / 4, alignment
);
278 private_mem_vgprs
+= dw_size
;
280 bb
= LLVMGetNextBasicBlock(bb
);
283 return private_mem_vgprs
;
287 ac_init_llvm_compiler(struct ac_llvm_compiler
*compiler
,
288 bool okay_to_leak_target_library_info
,
289 enum radeon_family family
,
290 enum ac_target_machine_options tm_options
)
293 memset(compiler
, 0, sizeof(*compiler
));
295 compiler
->tm
= ac_create_target_machine(family
,
296 tm_options
, &triple
);
300 if (okay_to_leak_target_library_info
|| (HAVE_LLVM
>= 0x0700)) {
301 compiler
->target_library_info
=
302 ac_create_target_library_info(triple
);
303 if (!compiler
->target_library_info
)
307 compiler
->passmgr
= ac_create_passmgr(compiler
->target_library_info
,
308 tm_options
& AC_TM_CHECK_IR
);
309 if (!compiler
->passmgr
)
314 ac_destroy_llvm_compiler(compiler
);
319 ac_destroy_llvm_compiler(struct ac_llvm_compiler
*compiler
)
321 if (compiler
->passmgr
)
322 LLVMDisposePassManager(compiler
->passmgr
);
323 #if HAVE_LLVM >= 0x0700
324 /* This crashes on LLVM 5.0 and 6.0 and Ubuntu 18.04, so leak it there. */
325 if (compiler
->target_library_info
)
326 ac_dispose_target_library_info(compiler
->target_library_info
);
329 LLVMDisposeTargetMachine(compiler
->tm
);