1 /**************************************************************************
3 * Copyright 2009 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
29 #include "pipe/p_config.h"
30 #include "pipe/p_compiler.h"
31 #include "util/u_cpu_detect.h"
32 #include "util/u_debug.h"
33 #include "util/u_memory.h"
34 #include "util/simple_list.h"
35 #include "util/os_time.h"
37 #include "lp_bld_debug.h"
38 #include "lp_bld_misc.h"
39 #include "lp_bld_init.h"
41 #include <llvm/Config/llvm-config.h>
42 #include <llvm-c/Analysis.h>
43 #include <llvm-c/Transforms/Scalar.h>
44 #if LLVM_VERSION_MAJOR >= 7
45 #include <llvm-c/Transforms/Utils.h>
47 #include <llvm-c/BitWriter.h>
49 #if LLVM_VERSION_MAJOR <= 8 && (defined(PIPE_ARCH_AARCH64) || defined (PIPE_ARCH_ARM) || defined(PIPE_ARCH_S390))
50 #include <llvm-c/Transforms/IPO.h>
52 #include <llvm-c/Transforms/Coroutines.h>
55 unsigned gallivm_perf
= 0;
57 static const struct debug_named_value lp_bld_perf_flags
[] = {
58 { "no_brilinear", GALLIVM_PERF_NO_BRILINEAR
, "disable brilinear optimization" },
59 { "no_rho_approx", GALLIVM_PERF_NO_RHO_APPROX
, "disable rho_approx optimization" },
60 { "no_quad_lod", GALLIVM_PERF_NO_QUAD_LOD
, "disable quad_lod optimization" },
61 { "no_aos_sampling", GALLIVM_PERF_NO_AOS_SAMPLING
, "disable aos sampling optimization" },
62 { "nopt", GALLIVM_PERF_NO_OPT
, "disable optimization passes to speed up shader compilation" },
63 { "no_filter_hacks", GALLIVM_PERF_NO_BRILINEAR
| GALLIVM_PERF_NO_RHO_APPROX
|
64 GALLIVM_PERF_NO_QUAD_LOD
, "disable filter optimization hacks" },
69 unsigned gallivm_debug
= 0;
71 static const struct debug_named_value lp_bld_debug_flags
[] = {
72 { "tgsi", GALLIVM_DEBUG_TGSI
, NULL
},
73 { "ir", GALLIVM_DEBUG_IR
, NULL
},
74 { "asm", GALLIVM_DEBUG_ASM
, NULL
},
75 { "perf", GALLIVM_DEBUG_PERF
, NULL
},
76 { "gc", GALLIVM_DEBUG_GC
, NULL
},
77 { "dumpbc", GALLIVM_DEBUG_DUMP_BC
, NULL
},
81 DEBUG_GET_ONCE_FLAGS_OPTION(gallivm_debug
, "GALLIVM_DEBUG", lp_bld_debug_flags
, 0)
85 static boolean gallivm_initialized
= FALSE
;
87 unsigned lp_native_vector_width
;
91 * Optimization values are:
94 * - 2: Default (-O2, -Os)
95 * - 3: Aggressive (-O3)
97 * See also CodeGenOpt::Level in llvm/Target/TargetMachine.h
99 enum LLVM_CodeGenOpt_Level
{
108 * Create the LLVM (optimization) pass manager and install
109 * relevant optimization passes.
110 * \return TRUE for success, FALSE for failure
113 create_pass_manager(struct gallivm_state
*gallivm
)
115 assert(!gallivm
->passmgr
);
116 assert(gallivm
->target
);
118 gallivm
->passmgr
= LLVMCreateFunctionPassManagerForModule(gallivm
->module
);
119 if (!gallivm
->passmgr
)
122 #if GALLIVM_HAVE_CORO
123 gallivm
->cgpassmgr
= LLVMCreatePassManager();
126 * TODO: some per module pass manager with IPO passes might be helpful -
127 * the generated texture functions may benefit from inlining if they are
128 * simple, or constant propagation into them, etc.
133 // New ones from the Module.
134 td_str
= LLVMCopyStringRepOfTargetData(gallivm
->target
);
135 LLVMSetDataLayout(gallivm
->module
, td_str
);
139 #if GALLIVM_HAVE_CORO
140 #if LLVM_VERSION_MAJOR <= 8 && (defined(PIPE_ARCH_AARCH64) || defined (PIPE_ARCH_ARM) || defined(PIPE_ARCH_S390))
141 LLVMAddArgumentPromotionPass(gallivm
->cgpassmgr
);
142 LLVMAddFunctionAttrsPass(gallivm
->cgpassmgr
);
144 LLVMAddCoroEarlyPass(gallivm
->cgpassmgr
);
145 LLVMAddCoroSplitPass(gallivm
->cgpassmgr
);
146 LLVMAddCoroElidePass(gallivm
->cgpassmgr
);
149 if ((gallivm_perf
& GALLIVM_PERF_NO_OPT
) == 0) {
151 * TODO: Evaluate passes some more - keeping in mind
152 * both quality of generated code and compile times.
155 * NOTE: if you change this, don't forget to change the output
156 * with GALLIVM_DEBUG_DUMP_BC in gallivm_compile_module.
158 LLVMAddScalarReplAggregatesPass(gallivm
->passmgr
);
159 LLVMAddEarlyCSEPass(gallivm
->passmgr
);
160 LLVMAddCFGSimplificationPass(gallivm
->passmgr
);
162 * FIXME: LICM is potentially quite useful. However, for some
163 * rather crazy shaders the compile time can reach _hours_ per shader,
164 * due to licm implying lcssa (since llvm 3.5), which can take forever.
165 * Even for sane shaders, the cost of licm is rather high (and not just
166 * due to lcssa, licm itself too), though mostly only in cases when it
167 * can actually move things, so having to disable it is a pity.
168 * LLVMAddLICMPass(gallivm->passmgr);
170 LLVMAddReassociatePass(gallivm
->passmgr
);
171 LLVMAddPromoteMemoryToRegisterPass(gallivm
->passmgr
);
172 #if LLVM_VERSION_MAJOR <= 11
173 LLVMAddConstantPropagationPass(gallivm
->passmgr
);
175 LLVMAddInstructionCombiningPass(gallivm
->passmgr
);
176 LLVMAddGVNPass(gallivm
->passmgr
);
179 /* We need at least this pass to prevent the backends to fail in
182 LLVMAddPromoteMemoryToRegisterPass(gallivm
->passmgr
);
184 #if GALLIVM_HAVE_CORO
185 LLVMAddCoroCleanupPass(gallivm
->passmgr
);
193 * Free gallivm object's LLVM allocations, but not any generated code
194 * nor the gallivm object itself.
197 gallivm_free_ir(struct gallivm_state
*gallivm
)
199 if (gallivm
->passmgr
) {
200 LLVMDisposePassManager(gallivm
->passmgr
);
203 #if GALLIVM_HAVE_CORO
204 if (gallivm
->cgpassmgr
) {
205 LLVMDisposePassManager(gallivm
->cgpassmgr
);
209 if (gallivm
->engine
) {
210 /* This will already destroy any associated module */
211 LLVMDisposeExecutionEngine(gallivm
->engine
);
212 } else if (gallivm
->module
) {
213 LLVMDisposeModule(gallivm
->module
);
216 if (gallivm
->cache
) {
217 lp_free_objcache(gallivm
->cache
->jit_obj_cache
);
218 free(gallivm
->cache
->data
);
220 FREE(gallivm
->module_name
);
222 if (gallivm
->target
) {
223 LLVMDisposeTargetData(gallivm
->target
);
226 if (gallivm
->builder
)
227 LLVMDisposeBuilder(gallivm
->builder
);
229 /* The LLVMContext should be owned by the parent of gallivm. */
231 gallivm
->engine
= NULL
;
232 gallivm
->target
= NULL
;
233 gallivm
->module
= NULL
;
234 gallivm
->module_name
= NULL
;
235 gallivm
->cgpassmgr
= NULL
;
236 gallivm
->passmgr
= NULL
;
237 gallivm
->context
= NULL
;
238 gallivm
->builder
= NULL
;
239 gallivm
->cache
= NULL
;
244 * Free LLVM-generated code. Should be done AFTER gallivm_free_ir().
247 gallivm_free_code(struct gallivm_state
*gallivm
)
249 assert(!gallivm
->module
);
250 assert(!gallivm
->engine
);
251 lp_free_generated_code(gallivm
->code
);
252 gallivm
->code
= NULL
;
253 lp_free_memory_manager(gallivm
->memorymgr
);
254 gallivm
->memorymgr
= NULL
;
259 init_gallivm_engine(struct gallivm_state
*gallivm
)
262 enum LLVM_CodeGenOpt_Level optlevel
;
266 if (gallivm_perf
& GALLIVM_PERF_NO_OPT
) {
273 ret
= lp_build_create_jit_compiler_for_module(&gallivm
->engine
,
281 _debug_printf("%s\n", error
);
282 LLVMDisposeMessage(error
);
289 * Dump the data layout strings.
292 LLVMTargetDataRef target
= LLVMGetExecutionEngineTargetData(gallivm
->engine
);
294 char *engine_data_layout
;
296 data_layout
= LLVMCopyStringRepOfTargetData(gallivm
->target
);
297 engine_data_layout
= LLVMCopyStringRepOfTargetData(target
);
300 debug_printf("module target data = %s\n", data_layout
);
301 debug_printf("engine target data = %s\n", engine_data_layout
);
305 free(engine_data_layout
);
316 * Allocate gallivm LLVM objects.
317 * \return TRUE for success, FALSE for failure
320 init_gallivm_state(struct gallivm_state
*gallivm
, const char *name
,
321 LLVMContextRef context
, struct lp_cached_code
*cache
)
323 assert(!gallivm
->context
);
324 assert(!gallivm
->module
);
326 if (!lp_build_init())
329 gallivm
->context
= context
;
330 gallivm
->cache
= cache
;
331 if (!gallivm
->context
)
334 gallivm
->module_name
= NULL
;
336 size_t size
= strlen(name
) + 1;
337 gallivm
->module_name
= MALLOC(size
);
338 if (gallivm
->module_name
) {
339 memcpy(gallivm
->module_name
, name
, size
);
343 gallivm
->module
= LLVMModuleCreateWithNameInContext(name
,
345 if (!gallivm
->module
)
348 gallivm
->builder
= LLVMCreateBuilderInContext(gallivm
->context
);
349 if (!gallivm
->builder
)
352 gallivm
->memorymgr
= lp_get_default_memory_manager();
353 if (!gallivm
->memorymgr
)
356 /* FIXME: MC-JIT only allows compiling one module at a time, and it must be
357 * complete when MC-JIT is created. So defer the MC-JIT engine creation for
362 * MC-JIT engine compiles the module immediately on creation, so we can't
363 * obtain the target data from it. Instead we create a target data layout
366 * The produced layout strings are not precisely the same, but should make
367 * no difference for the kind of optimization passes we run.
369 * For reference this is the layout string on x64:
371 * e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64
374 * - http://llvm.org/docs/LangRef.html#datalayout
378 const unsigned pointer_size
= 8 * sizeof(void *);
380 snprintf(layout
, sizeof layout
, "%c-p:%u:%u:%u-i64:64:64-a0:0:%u-s0:%u:%u",
381 #if UTIL_ARCH_LITTLE_ENDIAN
382 'e', // little endian
386 pointer_size
, pointer_size
, pointer_size
, // pointer size, abi alignment, preferred alignment
387 pointer_size
, // aggregate preferred alignment
388 pointer_size
, pointer_size
); // stack objects abi alignment, preferred alignment
390 gallivm
->target
= LLVMCreateTargetData(layout
);
391 if (!gallivm
->target
) {
396 if (!create_pass_manager(gallivm
))
402 gallivm_free_ir(gallivm
);
403 gallivm_free_code(gallivm
);
411 if (gallivm_initialized
)
415 /* LLVMLinkIn* are no-ops at runtime. They just ensure the respective
416 * component is linked at buildtime, which is sufficient for its static
417 * constructors to be called at load time.
422 gallivm_debug
= debug_get_option_gallivm_debug();
425 gallivm_perf
= debug_get_flags_option("GALLIVM_PERF", lp_bld_perf_flags
, 0 );
427 lp_set_target_options();
431 /* For simulating less capable machines */
433 if (debug_get_bool_option("LP_FORCE_SSE2", FALSE
)) {
434 assert(util_cpu_caps
.has_sse2
);
435 util_cpu_caps
.has_sse3
= 0;
436 util_cpu_caps
.has_ssse3
= 0;
437 util_cpu_caps
.has_sse4_1
= 0;
438 util_cpu_caps
.has_sse4_2
= 0;
439 util_cpu_caps
.has_avx
= 0;
440 util_cpu_caps
.has_avx2
= 0;
441 util_cpu_caps
.has_f16c
= 0;
442 util_cpu_caps
.has_fma
= 0;
446 if (util_cpu_caps
.has_avx2
|| util_cpu_caps
.has_avx
) {
447 lp_native_vector_width
= 256;
449 /* Leave it at 128, even when no SIMD extensions are available.
450 * Really needs to be a multiple of 128 so can fit 4 floats.
452 lp_native_vector_width
= 128;
455 lp_native_vector_width
= debug_get_num_option("LP_NATIVE_VECTOR_WIDTH",
456 lp_native_vector_width
);
458 #if LLVM_VERSION_MAJOR < 4
459 if (lp_native_vector_width
<= 128) {
460 /* Hide AVX support, as often LLVM AVX intrinsics are only guarded by
461 * "util_cpu_caps.has_avx" predicate, and lack the
462 * "lp_native_vector_width > 128" predicate. And also to ensure a more
463 * consistent behavior, allowing one to test SSE2 on AVX machines.
464 * XXX: should not play games with util_cpu_caps directly as it might
465 * get used for other things outside llvm too.
467 util_cpu_caps
.has_avx
= 0;
468 util_cpu_caps
.has_avx2
= 0;
469 util_cpu_caps
.has_f16c
= 0;
470 util_cpu_caps
.has_fma
= 0;
474 #ifdef PIPE_ARCH_PPC_64
475 /* Set the NJ bit in VSCR to 0 so denormalized values are handled as
476 * specified by IEEE standard (PowerISA 2.06 - Section 6.3). This guarantees
477 * that some rounding and half-float to float handling does not round
479 * XXX: should eventually follow same logic on all platforms.
480 * Right now denorms get explicitly disabled (but elsewhere) for x86,
481 * whereas ppc64 explicitly enables them...
483 if (util_cpu_caps
.has_altivec
) {
484 unsigned short mask
[] = { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
485 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF };
496 gallivm_initialized
= TRUE
;
504 * Create a new gallivm_state object.
506 struct gallivm_state
*
507 gallivm_create(const char *name
, LLVMContextRef context
,
508 struct lp_cached_code
*cache
)
510 struct gallivm_state
*gallivm
;
512 gallivm
= CALLOC_STRUCT(gallivm_state
);
514 if (!init_gallivm_state(gallivm
, name
, context
, cache
)) {
520 assert(gallivm
!= NULL
);
526 * Destroy a gallivm_state object.
529 gallivm_destroy(struct gallivm_state
*gallivm
)
531 gallivm_free_ir(gallivm
);
532 gallivm_free_code(gallivm
);
538 * Validate a function.
539 * Verification is only done with debug builds.
542 gallivm_verify_function(struct gallivm_state
*gallivm
,
545 /* Verify the LLVM IR. If invalid, dump and abort */
547 if (LLVMVerifyFunction(func
, LLVMPrintMessageAction
)) {
548 lp_debug_dump_value(func
);
554 if (gallivm_debug
& GALLIVM_DEBUG_IR
) {
555 /* Print the LLVM IR to stderr */
556 lp_debug_dump_value(func
);
564 * This does IR optimization on all functions in the module.
567 gallivm_compile_module(struct gallivm_state
*gallivm
)
570 int64_t time_begin
= 0;
572 assert(!gallivm
->compiled
);
574 if (gallivm
->builder
) {
575 LLVMDisposeBuilder(gallivm
->builder
);
576 gallivm
->builder
= NULL
;
579 if (gallivm
->cache
&& gallivm
->cache
->data_size
) {
583 /* Dump bitcode to a file */
584 if (gallivm_debug
& GALLIVM_DEBUG_DUMP_BC
) {
586 assert(gallivm
->module_name
);
587 snprintf(filename
, sizeof(filename
), "ir_%s.bc", gallivm
->module_name
);
588 LLVMWriteBitcodeToFile(gallivm
->module
, filename
);
589 debug_printf("%s written\n", filename
);
590 debug_printf("Invoke as \"opt %s %s | llc -O%d %s%s\"\n",
591 gallivm_debug
& GALLIVM_PERF_NO_OPT
? "-mem2reg" :
592 "-sroa -early-cse -simplifycfg -reassociate "
593 "-mem2reg -constprop -instcombine -gvn",
594 filename
, gallivm_debug
& GALLIVM_PERF_NO_OPT
? 0 : 2,
595 "[-mcpu=<-mcpu option>] ",
596 "[-mattr=<-mattr option(s)>]");
599 if (gallivm_debug
& GALLIVM_DEBUG_PERF
)
600 time_begin
= os_time_get();
602 #if GALLIVM_HAVE_CORO
603 LLVMRunPassManager(gallivm
->cgpassmgr
, gallivm
->module
);
605 /* Run optimization passes */
606 LLVMInitializeFunctionPassManager(gallivm
->passmgr
);
607 func
= LLVMGetFirstFunction(gallivm
->module
);
610 debug_printf("optimizing func %s...\n", LLVMGetValueName(func
));
613 /* Disable frame pointer omission on debug/profile builds */
614 /* XXX: And workaround http://llvm.org/PR21435 */
615 #if defined(DEBUG) || defined(PROFILE) || defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64)
616 LLVMAddTargetDependentFunctionAttr(func
, "no-frame-pointer-elim", "true");
617 LLVMAddTargetDependentFunctionAttr(func
, "no-frame-pointer-elim-non-leaf", "true");
620 LLVMRunFunctionPassManager(gallivm
->passmgr
, func
);
621 func
= LLVMGetNextFunction(func
);
623 LLVMFinalizeFunctionPassManager(gallivm
->passmgr
);
625 if (gallivm_debug
& GALLIVM_DEBUG_PERF
) {
626 int64_t time_end
= os_time_get();
627 int time_msec
= (int)((time_end
- time_begin
) / 1000);
628 assert(gallivm
->module_name
);
629 debug_printf("optimizing module %s took %d msec\n",
630 gallivm
->module_name
, time_msec
);
633 /* Setting the module's DataLayout to an empty string will cause the
634 * ExecutionEngine to copy to the DataLayout string from its target machine
635 * to the module. As of LLVM 3.8 the module and the execution engine are
636 * required to have the same DataLayout.
638 * We must make sure we do this after running the optimization passes,
639 * because those passes need a correct datalayout string. For example, if
640 * those optimization passes see an empty datalayout, they will assume this
641 * is a little endian target and will do optimizations that break big endian
644 * TODO: This is just a temporary work-around. The correct solution is for
645 * gallivm_init_state() to create a TargetMachine and pull the DataLayout
646 * from there. Currently, the TargetMachine used by llvmpipe is being
647 * implicitly created by the EngineBuilder in
648 * lp_build_create_jit_compiler_for_module()
651 LLVMSetDataLayout(gallivm
->module
, "");
652 assert(!gallivm
->engine
);
653 if (!init_gallivm_engine(gallivm
)) {
656 assert(gallivm
->engine
);
660 if (gallivm
->debug_printf_hook
)
661 LLVMAddGlobalMapping(gallivm
->engine
, gallivm
->debug_printf_hook
, debug_printf
);
663 if (gallivm_debug
& GALLIVM_DEBUG_ASM
) {
664 LLVMValueRef llvm_func
= LLVMGetFirstFunction(gallivm
->module
);
668 * Need to filter out functions which don't have an implementation,
669 * such as the intrinsics. May not be sufficient in case of IPO?
670 * LLVMGetPointerToGlobal() will abort otherwise.
672 if (!LLVMIsDeclaration(llvm_func
)) {
673 void *func_code
= LLVMGetPointerToGlobal(gallivm
->engine
, llvm_func
);
674 lp_disassemble(llvm_func
, func_code
);
676 llvm_func
= LLVMGetNextFunction(llvm_func
);
682 LLVMValueRef llvm_func
= LLVMGetFirstFunction(gallivm
->module
);
685 if (!LLVMIsDeclaration(llvm_func
)) {
686 void *func_code
= LLVMGetPointerToGlobal(gallivm
->engine
, llvm_func
);
687 lp_profile(llvm_func
, func_code
);
689 llvm_func
= LLVMGetNextFunction(llvm_func
);
698 gallivm_jit_function(struct gallivm_state
*gallivm
,
702 func_pointer jit_func
;
703 int64_t time_begin
= 0;
705 assert(gallivm
->compiled
);
706 assert(gallivm
->engine
);
708 if (gallivm_debug
& GALLIVM_DEBUG_PERF
)
709 time_begin
= os_time_get();
711 code
= LLVMGetPointerToGlobal(gallivm
->engine
, func
);
713 jit_func
= pointer_to_func(code
);
715 if (gallivm_debug
& GALLIVM_DEBUG_PERF
) {
716 int64_t time_end
= os_time_get();
717 int time_msec
= (int)(time_end
- time_begin
) / 1000;
718 debug_printf(" jitting func %s took %d msec\n",
719 LLVMGetValueName(func
), time_msec
);