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-c/Analysis.h>
42 #include <llvm-c/Transforms/Scalar.h>
43 #if HAVE_LLVM >= 0x0700
44 #include <llvm-c/Transforms/Utils.h>
46 #include <llvm-c/BitWriter.h>
49 /* Only MCJIT is available as of LLVM SVN r216982 */
50 #if HAVE_LLVM >= 0x0306
52 #elif defined(PIPE_ARCH_PPC_64) || defined(PIPE_ARCH_S390) || defined(PIPE_ARCH_ARM) || defined(PIPE_ARCH_AARCH64)
56 #if defined(USE_MCJIT)
57 static const bool use_mcjit
= USE_MCJIT
;
59 static bool use_mcjit
= FALSE
;
64 unsigned gallivm_debug
= 0;
66 static const struct debug_named_value lp_bld_debug_flags
[] = {
67 { "tgsi", GALLIVM_DEBUG_TGSI
, NULL
},
68 { "ir", GALLIVM_DEBUG_IR
, NULL
},
69 { "asm", GALLIVM_DEBUG_ASM
, NULL
},
70 { "nopt", GALLIVM_DEBUG_NO_OPT
, NULL
},
71 { "perf", GALLIVM_DEBUG_PERF
, NULL
},
72 { "no_brilinear", GALLIVM_DEBUG_NO_BRILINEAR
, NULL
},
73 { "no_rho_approx", GALLIVM_DEBUG_NO_RHO_APPROX
, NULL
},
74 { "no_quad_lod", GALLIVM_DEBUG_NO_QUAD_LOD
, NULL
},
75 { "gc", GALLIVM_DEBUG_GC
, NULL
},
76 { "dumpbc", GALLIVM_DEBUG_DUMP_BC
, NULL
},
80 DEBUG_GET_ONCE_FLAGS_OPTION(gallivm_debug
, "GALLIVM_DEBUG", lp_bld_debug_flags
, 0)
84 static boolean gallivm_initialized
= FALSE
;
86 unsigned lp_native_vector_width
;
90 * Optimization values are:
93 * - 2: Default (-O2, -Os)
94 * - 3: Aggressive (-O3)
96 * See also CodeGenOpt::Level in llvm/Target/TargetMachine.h
98 enum LLVM_CodeGenOpt_Level
{
107 * Create the LLVM (optimization) pass manager and install
108 * relevant optimization passes.
109 * \return TRUE for success, FALSE for failure
112 create_pass_manager(struct gallivm_state
*gallivm
)
114 assert(!gallivm
->passmgr
);
115 assert(gallivm
->target
);
117 gallivm
->passmgr
= LLVMCreateFunctionPassManagerForModule(gallivm
->module
);
118 if (!gallivm
->passmgr
)
121 * TODO: some per module pass manager with IPO passes might be helpful -
122 * the generated texture functions may benefit from inlining if they are
123 * simple, or constant propagation into them, etc.
126 #if HAVE_LLVM < 0x0309
127 // Old versions of LLVM get the DataLayout from the pass manager.
128 LLVMAddTargetData(gallivm
->target
, gallivm
->passmgr
);
133 // New ones from the Module.
134 td_str
= LLVMCopyStringRepOfTargetData(gallivm
->target
);
135 LLVMSetDataLayout(gallivm
->module
, td_str
);
139 if ((gallivm_debug
& GALLIVM_DEBUG_NO_OPT
) == 0) {
141 * TODO: Evaluate passes some more - keeping in mind
142 * both quality of generated code and compile times.
144 LLVMAddScalarReplAggregatesPass(gallivm
->passmgr
);
145 LLVMAddEarlyCSEPass(gallivm
->passmgr
);
146 LLVMAddCFGSimplificationPass(gallivm
->passmgr
);
147 LLVMAddLICMPass(gallivm
->passmgr
);
148 LLVMAddReassociatePass(gallivm
->passmgr
);
149 LLVMAddPromoteMemoryToRegisterPass(gallivm
->passmgr
);
150 LLVMAddConstantPropagationPass(gallivm
->passmgr
);
151 LLVMAddInstructionCombiningPass(gallivm
->passmgr
);
152 LLVMAddGVNPass(gallivm
->passmgr
);
155 /* We need at least this pass to prevent the backends to fail in
158 LLVMAddPromoteMemoryToRegisterPass(gallivm
->passmgr
);
166 * Free gallivm object's LLVM allocations, but not any generated code
167 * nor the gallivm object itself.
170 gallivm_free_ir(struct gallivm_state
*gallivm
)
172 if (gallivm
->passmgr
) {
173 LLVMDisposePassManager(gallivm
->passmgr
);
176 if (gallivm
->engine
) {
177 /* This will already destroy any associated module */
178 LLVMDisposeExecutionEngine(gallivm
->engine
);
179 } else if (gallivm
->module
) {
180 LLVMDisposeModule(gallivm
->module
);
183 FREE(gallivm
->module_name
);
186 /* Don't free the TargetData, it's owned by the exec engine */
188 if (gallivm
->target
) {
189 LLVMDisposeTargetData(gallivm
->target
);
193 if (gallivm
->builder
)
194 LLVMDisposeBuilder(gallivm
->builder
);
196 /* The LLVMContext should be owned by the parent of gallivm. */
198 gallivm
->engine
= NULL
;
199 gallivm
->target
= NULL
;
200 gallivm
->module
= NULL
;
201 gallivm
->module_name
= NULL
;
202 gallivm
->passmgr
= NULL
;
203 gallivm
->context
= NULL
;
204 gallivm
->builder
= NULL
;
209 * Free LLVM-generated code. Should be done AFTER gallivm_free_ir().
212 gallivm_free_code(struct gallivm_state
*gallivm
)
214 assert(!gallivm
->module
);
215 assert(!gallivm
->engine
);
216 lp_free_generated_code(gallivm
->code
);
217 gallivm
->code
= NULL
;
218 lp_free_memory_manager(gallivm
->memorymgr
);
219 gallivm
->memorymgr
= NULL
;
224 init_gallivm_engine(struct gallivm_state
*gallivm
)
227 enum LLVM_CodeGenOpt_Level optlevel
;
231 if (gallivm_debug
& GALLIVM_DEBUG_NO_OPT
) {
238 ret
= lp_build_create_jit_compiler_for_module(&gallivm
->engine
,
246 _debug_printf("%s\n", error
);
247 LLVMDisposeMessage(error
);
253 gallivm
->target
= LLVMGetExecutionEngineTargetData(gallivm
->engine
);
254 if (!gallivm
->target
)
259 * Dump the data layout strings.
262 LLVMTargetDataRef target
= LLVMGetExecutionEngineTargetData(gallivm
->engine
);
264 char *engine_data_layout
;
266 data_layout
= LLVMCopyStringRepOfTargetData(gallivm
->target
);
267 engine_data_layout
= LLVMCopyStringRepOfTargetData(target
);
270 debug_printf("module target data = %s\n", data_layout
);
271 debug_printf("engine target data = %s\n", engine_data_layout
);
275 free(engine_data_layout
);
287 * Allocate gallivm LLVM objects.
288 * \return TRUE for success, FALSE for failure
291 init_gallivm_state(struct gallivm_state
*gallivm
, const char *name
,
292 LLVMContextRef context
)
294 assert(!gallivm
->context
);
295 assert(!gallivm
->module
);
297 if (!lp_build_init())
300 gallivm
->context
= context
;
302 if (!gallivm
->context
)
305 gallivm
->module_name
= NULL
;
307 size_t size
= strlen(name
) + 1;
308 gallivm
->module_name
= MALLOC(size
);
309 if (gallivm
->module_name
) {
310 memcpy(gallivm
->module_name
, name
, size
);
314 gallivm
->module
= LLVMModuleCreateWithNameInContext(name
,
316 if (!gallivm
->module
)
319 gallivm
->builder
= LLVMCreateBuilderInContext(gallivm
->context
);
320 if (!gallivm
->builder
)
323 gallivm
->memorymgr
= lp_get_default_memory_manager();
324 if (!gallivm
->memorymgr
)
327 /* FIXME: MC-JIT only allows compiling one module at a time, and it must be
328 * complete when MC-JIT is created. So defer the MC-JIT engine creation for
332 if (!init_gallivm_engine(gallivm
)) {
337 * MC-JIT engine compiles the module immediately on creation, so we can't
338 * obtain the target data from it. Instead we create a target data layout
341 * The produced layout strings are not precisely the same, but should make
342 * no difference for the kind of optimization passes we run.
344 * For reference this is the layout string on x64:
346 * 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
349 * - http://llvm.org/docs/LangRef.html#datalayout
353 const unsigned pointer_size
= 8 * sizeof(void *);
355 util_snprintf(layout
, sizeof layout
, "%c-p:%u:%u:%u-i64:64:64-a0:0:%u-s0:%u:%u",
356 #ifdef PIPE_ARCH_LITTLE_ENDIAN
357 'e', // little endian
361 pointer_size
, pointer_size
, pointer_size
, // pointer size, abi alignment, preferred alignment
362 pointer_size
, // aggregate preferred alignment
363 pointer_size
, pointer_size
); // stack objects abi alignment, preferred alignment
365 gallivm
->target
= LLVMCreateTargetData(layout
);
366 if (!gallivm
->target
) {
372 if (!create_pass_manager(gallivm
))
378 gallivm_free_ir(gallivm
);
379 gallivm_free_code(gallivm
);
387 if (gallivm_initialized
)
391 /* LLVMLinkIn* are no-ops at runtime. They just ensure the respective
392 * component is linked at buildtime, which is sufficient for its static
393 * constructors to be called at load time.
395 #if defined(USE_MCJIT)
402 use_mcjit
= debug_get_bool_option("GALLIVM_MCJIT", FALSE
);
408 gallivm_debug
= debug_get_option_gallivm_debug();
411 lp_set_target_options();
415 /* For simulating less capable machines */
417 if (debug_get_bool_option("LP_FORCE_SSE2", FALSE
)) {
418 assert(util_cpu_caps
.has_sse2
);
419 util_cpu_caps
.has_sse3
= 0;
420 util_cpu_caps
.has_ssse3
= 0;
421 util_cpu_caps
.has_sse4_1
= 0;
422 util_cpu_caps
.has_sse4_2
= 0;
423 util_cpu_caps
.has_avx
= 0;
424 util_cpu_caps
.has_avx2
= 0;
425 util_cpu_caps
.has_f16c
= 0;
426 util_cpu_caps
.has_fma
= 0;
430 /* AMD Bulldozer AVX's throughput is the same as SSE2; and because using
431 * 8-wide vector needs more floating ops than 4-wide (due to padding), it is
432 * actually more efficient to use 4-wide vectors on this processor.
435 * - http://www.anandtech.com/show/4955/the-bulldozer-review-amd-fx8150-tested/2
437 if (util_cpu_caps
.has_avx
&&
438 util_cpu_caps
.has_intel
) {
439 lp_native_vector_width
= 256;
441 /* Leave it at 128, even when no SIMD extensions are available.
442 * Really needs to be a multiple of 128 so can fit 4 floats.
444 lp_native_vector_width
= 128;
447 lp_native_vector_width
= debug_get_num_option("LP_NATIVE_VECTOR_WIDTH",
448 lp_native_vector_width
);
450 if (lp_native_vector_width
<= 128) {
451 /* Hide AVX support, as often LLVM AVX intrinsics are only guarded by
452 * "util_cpu_caps.has_avx" predicate, and lack the
453 * "lp_native_vector_width > 128" predicate. And also to ensure a more
454 * consistent behavior, allowing one to test SSE2 on AVX machines.
455 * XXX: should not play games with util_cpu_caps directly as it might
456 * get used for other things outside llvm too.
458 util_cpu_caps
.has_avx
= 0;
459 util_cpu_caps
.has_avx2
= 0;
460 util_cpu_caps
.has_f16c
= 0;
461 util_cpu_caps
.has_fma
= 0;
463 if (HAVE_LLVM
< 0x0304 || !use_mcjit
) {
464 /* AVX2 support has only been tested with LLVM 3.4, and it requires
466 util_cpu_caps
.has_avx2
= 0;
469 #ifdef PIPE_ARCH_PPC_64
470 /* Set the NJ bit in VSCR to 0 so denormalized values are handled as
471 * specified by IEEE standard (PowerISA 2.06 - Section 6.3). This guarantees
472 * that some rounding and half-float to float handling does not round
474 * XXX: should eventually follow same logic on all platforms.
475 * Right now denorms get explicitly disabled (but elsewhere) for x86,
476 * whereas ppc64 explicitly enables them...
478 if (util_cpu_caps
.has_altivec
) {
479 unsigned short mask
[] = { 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
480 0xFFFF, 0xFFFF, 0xFFFE, 0xFFFF };
491 gallivm_initialized
= TRUE
;
499 * Create a new gallivm_state object.
501 struct gallivm_state
*
502 gallivm_create(const char *name
, LLVMContextRef context
)
504 struct gallivm_state
*gallivm
;
506 gallivm
= CALLOC_STRUCT(gallivm_state
);
508 if (!init_gallivm_state(gallivm
, name
, context
)) {
519 * Destroy a gallivm_state object.
522 gallivm_destroy(struct gallivm_state
*gallivm
)
524 gallivm_free_ir(gallivm
);
525 gallivm_free_code(gallivm
);
531 * Validate a function.
532 * Verification is only done with debug builds.
535 gallivm_verify_function(struct gallivm_state
*gallivm
,
538 /* Verify the LLVM IR. If invalid, dump and abort */
540 if (LLVMVerifyFunction(func
, LLVMPrintMessageAction
)) {
541 lp_debug_dump_value(func
);
547 if (gallivm_debug
& GALLIVM_DEBUG_IR
) {
548 /* Print the LLVM IR to stderr */
549 lp_debug_dump_value(func
);
557 * This does IR optimization on all functions in the module.
560 gallivm_compile_module(struct gallivm_state
*gallivm
)
563 int64_t time_begin
= 0;
565 assert(!gallivm
->compiled
);
567 if (gallivm
->builder
) {
568 LLVMDisposeBuilder(gallivm
->builder
);
569 gallivm
->builder
= NULL
;
572 if (gallivm_debug
& GALLIVM_DEBUG_PERF
)
573 time_begin
= os_time_get();
575 /* Run optimization passes */
576 LLVMInitializeFunctionPassManager(gallivm
->passmgr
);
577 func
= LLVMGetFirstFunction(gallivm
->module
);
580 debug_printf("optimizing func %s...\n", LLVMGetValueName(func
));
583 /* Disable frame pointer omission on debug/profile builds */
584 /* XXX: And workaround http://llvm.org/PR21435 */
585 #if HAVE_LLVM >= 0x0307 && \
586 (defined(DEBUG) || defined(PROFILE) || \
587 defined(PIPE_ARCH_X86) || defined(PIPE_ARCH_X86_64))
588 LLVMAddTargetDependentFunctionAttr(func
, "no-frame-pointer-elim", "true");
589 LLVMAddTargetDependentFunctionAttr(func
, "no-frame-pointer-elim-non-leaf", "true");
592 LLVMRunFunctionPassManager(gallivm
->passmgr
, func
);
593 func
= LLVMGetNextFunction(func
);
595 LLVMFinalizeFunctionPassManager(gallivm
->passmgr
);
597 if (gallivm_debug
& GALLIVM_DEBUG_PERF
) {
598 int64_t time_end
= os_time_get();
599 int time_msec
= (int)(time_end
- time_begin
) / 1000;
600 assert(gallivm
->module_name
);
601 debug_printf("optimizing module %s took %d msec\n",
602 gallivm
->module_name
, time_msec
);
605 /* Dump byte code to a file */
606 if (gallivm_debug
& GALLIVM_DEBUG_DUMP_BC
) {
608 assert(gallivm
->module_name
);
609 util_snprintf(filename
, sizeof(filename
), "ir_%s.bc", gallivm
->module_name
);
610 LLVMWriteBitcodeToFile(gallivm
->module
, filename
);
611 debug_printf("%s written\n", filename
);
612 debug_printf("Invoke as \"llc %s%s -o - %s\"\n",
613 (HAVE_LLVM
>= 0x0305) ? "[-mcpu=<-mcpu option>] " : "",
614 "[-mattr=<-mattr option(s)>]",
619 /* Setting the module's DataLayout to an empty string will cause the
620 * ExecutionEngine to copy to the DataLayout string from its target
621 * machine to the module. As of LLVM 3.8 the module and the execution
622 * engine are required to have the same DataLayout.
624 * We must make sure we do this after running the optimization passes,
625 * because those passes need a correct datalayout string. For example,
626 * if those optimization passes see an empty datalayout, they will assume
627 * this is a little endian target and will do optimizations that break big
630 * TODO: This is just a temporary work-around. The correct solution is
631 * for gallivm_init_state() to create a TargetMachine and pull the
632 * DataLayout from there. Currently, the TargetMachine used by llvmpipe
633 * is being implicitly created by the EngineBuilder in
634 * lp_build_create_jit_compiler_for_module()
636 LLVMSetDataLayout(gallivm
->module
, "");
637 assert(!gallivm
->engine
);
638 if (!init_gallivm_engine(gallivm
)) {
642 assert(gallivm
->engine
);
646 if (gallivm_debug
& GALLIVM_DEBUG_ASM
) {
647 LLVMValueRef llvm_func
= LLVMGetFirstFunction(gallivm
->module
);
651 * Need to filter out functions which don't have an implementation,
652 * such as the intrinsics. May not be sufficient in case of IPO?
653 * LLVMGetPointerToGlobal() will abort otherwise.
655 if (!LLVMIsDeclaration(llvm_func
)) {
656 void *func_code
= LLVMGetPointerToGlobal(gallivm
->engine
, llvm_func
);
657 lp_disassemble(llvm_func
, func_code
);
659 llvm_func
= LLVMGetNextFunction(llvm_func
);
665 LLVMValueRef llvm_func
= LLVMGetFirstFunction(gallivm
->module
);
668 if (!LLVMIsDeclaration(llvm_func
)) {
669 void *func_code
= LLVMGetPointerToGlobal(gallivm
->engine
, llvm_func
);
670 lp_profile(llvm_func
, func_code
);
672 llvm_func
= LLVMGetNextFunction(llvm_func
);
681 gallivm_jit_function(struct gallivm_state
*gallivm
,
685 func_pointer jit_func
;
686 int64_t time_begin
= 0;
688 assert(gallivm
->compiled
);
689 assert(gallivm
->engine
);
691 if (gallivm_debug
& GALLIVM_DEBUG_PERF
)
692 time_begin
= os_time_get();
694 code
= LLVMGetPointerToGlobal(gallivm
->engine
, func
);
696 jit_func
= pointer_to_func(code
);
698 if (gallivm_debug
& GALLIVM_DEBUG_PERF
) {
699 int64_t time_end
= os_time_get();
700 int time_msec
= (int)(time_end
- time_begin
) / 1000;
701 debug_printf(" jitting func %s took %d msec\n",
702 LLVMGetValueName(func
), time_msec
);