diff options
Diffstat (limited to 'multilib-testing/lib32-mesa/fix-build-with-llvm-3.0.patch')
| -rw-r--r-- | multilib-testing/lib32-mesa/fix-build-with-llvm-3.0.patch | 330 |
1 files changed, 330 insertions, 0 deletions
diff --git a/multilib-testing/lib32-mesa/fix-build-with-llvm-3.0.patch b/multilib-testing/lib32-mesa/fix-build-with-llvm-3.0.patch new file mode 100644 index 000000000..ceb5aa129 --- /dev/null +++ b/multilib-testing/lib32-mesa/fix-build-with-llvm-3.0.patch @@ -0,0 +1,330 @@ +diff --git a/src/gallium/auxiliary/draw/draw_llvm.c b/src/gallium/auxiliary/draw/draw_llvm.c +index 56c26f5..d477c40 100644 +--- a/src/gallium/auxiliary/draw/draw_llvm.c ++++ b/src/gallium/auxiliary/draw/draw_llvm.c +@@ -96,7 +96,7 @@ draw_llvm_generate_elts(struct draw_llvm *llvm, struct draw_llvm_variant *var); + * Create LLVM type for struct draw_jit_texture + */ + static LLVMTypeRef +-create_jit_texture_type(struct gallivm_state *gallivm) ++create_jit_texture_type(struct gallivm_state *gallivm, const char *struct_name) + { + LLVMTargetDataRef target = gallivm->target; + LLVMTypeRef texture_type; +@@ -120,13 +120,21 @@ create_jit_texture_type(struct gallivm_state *gallivm) + elem_types[DRAW_JIT_TEXTURE_BORDER_COLOR] = + LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); + ++#if HAVE_LLVM >= 0x0300 ++ texture_type = LLVMStructCreateNamed(gallivm->context, struct_name); ++ LLVMStructSetBody(texture_type, elem_types, ++ Elements(elem_types), 0); ++#else + texture_type = LLVMStructTypeInContext(gallivm->context, elem_types, + Elements(elem_types), 0); + ++ LLVMAddTypeName(gallivm->module, struct_name, texture_type); ++ + /* Make sure the target's struct layout cache doesn't return + * stale/invalid data. + */ + LLVMInvalidateStructLayout(gallivm->target, texture_type); ++#endif + + LP_CHECK_MEMBER_OFFSET(struct draw_jit_texture, width, + target, texture_type, +@@ -176,7 +184,7 @@ create_jit_texture_type(struct gallivm_state *gallivm) + */ + static LLVMTypeRef + create_jit_context_type(struct gallivm_state *gallivm, +- LLVMTypeRef texture_type) ++ LLVMTypeRef texture_type, const char *struct_name) + { + LLVMTargetDataRef target = gallivm->target; + LLVMTypeRef float_type = LLVMFloatTypeInContext(gallivm->context); +@@ -189,11 +197,17 @@ create_jit_context_type(struct gallivm_state *gallivm, + elem_types[3] = LLVMPointerType(float_type, 0); /* viewport */ + elem_types[4] = LLVMArrayType(texture_type, + PIPE_MAX_VERTEX_SAMPLERS); /* textures */ +- ++#if HAVE_LLVM >= 0x0300 ++ context_type = LLVMStructCreateNamed(gallivm->context, struct_name); ++ LLVMStructSetBody(context_type, elem_types, ++ Elements(elem_types), 0); ++#else + context_type = LLVMStructTypeInContext(gallivm->context, elem_types, + Elements(elem_types), 0); ++ LLVMAddTypeName(gallivm->module, struct_name, context_type); + + LLVMInvalidateStructLayout(gallivm->target, context_type); ++#endif + + LP_CHECK_MEMBER_OFFSET(struct draw_jit_context, vs_constants, + target, context_type, 0); +@@ -215,7 +229,7 @@ create_jit_context_type(struct gallivm_state *gallivm, + * Create LLVM type for struct pipe_vertex_buffer + */ + static LLVMTypeRef +-create_jit_vertex_buffer_type(struct gallivm_state *gallivm) ++create_jit_vertex_buffer_type(struct gallivm_state *gallivm, const char *struct_name) + { + LLVMTargetDataRef target = gallivm->target; + LLVMTypeRef elem_types[3]; +@@ -225,10 +239,17 @@ create_jit_vertex_buffer_type(struct gallivm_state *gallivm) + elem_types[1] = LLVMInt32TypeInContext(gallivm->context); + elem_types[2] = LLVMPointerType(LLVMInt8TypeInContext(gallivm->context), 0); /* vs_constants */ + ++#if HAVE_LLVM >= 0x0300 ++ vb_type = LLVMStructCreateNamed(gallivm->context, struct_name); ++ LLVMStructSetBody(vb_type, elem_types, ++ Elements(elem_types), 0); ++#else + vb_type = LLVMStructTypeInContext(gallivm->context, elem_types, + Elements(elem_types), 0); ++ LLVMAddTypeName(gallivm->module, struct_name, vb_type); + + LLVMInvalidateStructLayout(gallivm->target, vb_type); ++#endif + + LP_CHECK_MEMBER_OFFSET(struct pipe_vertex_buffer, stride, + target, vb_type, 0); +@@ -258,10 +279,17 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems) + elem_types[1] = LLVMArrayType(LLVMFloatTypeInContext(gallivm->context), 4); + elem_types[2] = LLVMArrayType(elem_types[1], data_elems); + ++#if HAVE_LLVM >= 0x0300 ++ vertex_header = LLVMStructCreateNamed(gallivm->context, struct_name); ++ LLVMStructSetBody(vertex_header, elem_types, ++ Elements(elem_types), 0); ++#else + vertex_header = LLVMStructTypeInContext(gallivm->context, elem_types, + Elements(elem_types), 0); ++ LLVMAddTypeName(gallivm->module, struct_name, vertex_header); + + LLVMInvalidateStructLayout(gallivm->target, vertex_header); ++#endif + + /* these are bit-fields and we can't take address of them + LP_CHECK_MEMBER_OFFSET(struct vertex_header, clipmask, +@@ -284,8 +312,6 @@ create_jit_vertex_header(struct gallivm_state *gallivm, int data_elems) + target, vertex_header, + DRAW_JIT_VERTEX_DATA); + +- LLVMAddTypeName(gallivm->module, struct_name, vertex_header); +- + return vertex_header; + } + +@@ -299,19 +325,15 @@ create_jit_types(struct draw_llvm *llvm) + struct gallivm_state *gallivm = llvm->gallivm; + LLVMTypeRef texture_type, context_type, buffer_type, vb_type; + +- texture_type = create_jit_texture_type(gallivm); +- LLVMAddTypeName(gallivm->module, "texture", texture_type); ++ texture_type = create_jit_texture_type(gallivm, "texture"); + +- context_type = create_jit_context_type(gallivm, texture_type); +- LLVMAddTypeName(gallivm->module, "draw_jit_context", context_type); ++ context_type = create_jit_context_type(gallivm, texture_type, "draw_jit_context"); + llvm->context_ptr_type = LLVMPointerType(context_type, 0); + + buffer_type = LLVMPointerType(LLVMIntTypeInContext(gallivm->context, 8), 0); +- LLVMAddTypeName(gallivm->module, "buffer", buffer_type); + llvm->buffer_ptr_type = LLVMPointerType(buffer_type, 0); + +- vb_type = create_jit_vertex_buffer_type(gallivm); +- LLVMAddTypeName(gallivm->module, "pipe_vertex_buffer", vb_type); ++ vb_type = create_jit_vertex_buffer_type(gallivm, "pipe_vertex_buffer"); + llvm->vb_ptr_type = LLVMPointerType(vb_type, 0); + } + +diff --git a/src/gallium/auxiliary/gallivm/lp_bld_debug.cpp b/src/gallium/auxiliary/gallivm/lp_bld_debug.cpp +index 8636cd6..f44749d 100644 +--- a/src/gallium/auxiliary/gallivm/lp_bld_debug.cpp ++++ b/src/gallium/auxiliary/gallivm/lp_bld_debug.cpp +@@ -27,17 +27,23 @@ + + #include <llvm-c/Core.h> + #include <llvm/Target/TargetMachine.h> +-#include <llvm/Target/TargetRegistry.h> +-#include <llvm/Target/TargetSelect.h> + #include <llvm/Target/TargetInstrInfo.h> + #include <llvm/Support/raw_ostream.h> + #include <llvm/Support/MemoryObject.h> + ++#if HAVE_LLVM >= 0x0300 ++#include <llvm/Support/TargetRegistry.h> ++#include <llvm/Support/TargetSelect.h> ++#else /* HAVE_LLVM < 0x0300 */ ++#include <llvm/Target/TargetRegistry.h> ++#include <llvm/Target/TargetSelect.h> ++#endif /* HAVE_LLVM < 0x0300 */ ++ + #if HAVE_LLVM >= 0x0209 + #include <llvm/Support/Host.h> +-#else ++#else /* HAVE_LLVM < 0x0209 */ + #include <llvm/System/Host.h> +-#endif ++#endif /* HAVE_LLVM < 0x0209 */ + + #if HAVE_LLVM >= 0x0207 + #include <llvm/MC/MCDisassembler.h> +@@ -193,14 +199,23 @@ lp_disassemble(const void* func) + + InitializeAllDisassemblers(); + ++#if HAVE_LLVM >= 0x0300 ++ OwningPtr<const MCAsmInfo> AsmInfo(T->createMCAsmInfo(Triple)); ++#else + OwningPtr<const MCAsmInfo> AsmInfo(T->createAsmInfo(Triple)); ++#endif + + if (!AsmInfo) { + debug_printf("error: no assembly info for target %s\n", Triple.c_str()); + return; + } + ++#if HAVE_LLVM >= 0x0300 ++ const MCSubtargetInfo *STI = T->createMCSubtargetInfo(Triple, sys::getHostCPUName(), ""); ++ OwningPtr<const MCDisassembler> DisAsm(T->createMCDisassembler(*STI)); ++#else + OwningPtr<const MCDisassembler> DisAsm(T->createMCDisassembler()); ++#endif + if (!DisAsm) { + debug_printf("error: no disassembler for target %s\n", Triple.c_str()); + return; +@@ -213,7 +228,11 @@ lp_disassemble(const void* func) + #else + int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); + #endif +-#if HAVE_LLVM >= 0x0208 ++ ++#if HAVE_LLVM >= 0x0300 ++ OwningPtr<MCInstPrinter> Printer( ++ T->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *STI)); ++#elif HAVE_LLVM >= 0x0208 + OwningPtr<MCInstPrinter> Printer( + T->createMCInstPrinter(AsmPrinterVariant, *AsmInfo)); + #else +@@ -253,7 +272,11 @@ lp_disassemble(const void* func) + + if (!DisAsm->getInstruction(Inst, Size, memoryObject, + pc, +- nulls())) { ++#if HAVE_LLVM >= 0x0300 ++ nulls(), nulls())) { ++#else ++ nulls())) { ++#endif + debug_printf("invalid\n"); + pc += 1; + } +@@ -276,7 +299,9 @@ lp_disassemble(const void* func) + * Print the instruction. + */ + +-#if HAVE_LLVM >= 0x208 ++#if HAVE_LLVM >= 0x0300 ++ Printer->printInst(&Inst, Out, ""); ++#elif HAVE_LLVM >= 0x208 + Printer->printInst(&Inst, Out); + #else + Printer->printInst(&Inst); +@@ -289,7 +314,11 @@ lp_disassemble(const void* func) + + pc += Size; + ++#if HAVE_LLVM >= 0x0300 ++ const MCInstrDesc &TID = TII->get(Inst.getOpcode()); ++#else + const TargetInstrDesc &TID = TII->get(Inst.getOpcode()); ++#endif + + /* + * Keep track of forward jumps to a nearby address. +diff --git a/src/gallium/auxiliary/gallivm/lp_bld_type.c b/src/gallium/auxiliary/gallivm/lp_bld_type.c +index c5cf6d4..efd159f 100644 +--- a/src/gallium/auxiliary/gallivm/lp_bld_type.c ++++ b/src/gallium/auxiliary/gallivm/lp_bld_type.c +@@ -325,16 +325,18 @@ lp_typekind_name(LLVMTypeKind t) + return "LLVMArrayTypeKind"; + case LLVMPointerTypeKind: + return "LLVMPointerTypeKind"; ++#if HAVE_LLVM < 0x0300 + case LLVMOpaqueTypeKind: + return "LLVMOpaqueTypeKind"; ++#endif + case LLVMVectorTypeKind: + return "LLVMVectorTypeKind"; + case LLVMMetadataTypeKind: + return "LLVMMetadataTypeKind"; +- /* Only in LLVM 2.7 and later??? ++#if HAVE_LLVM == 0x0207 + case LLVMUnionTypeKind: + return "LLVMUnionTypeKind"; +- */ ++#endif + default: + return "unknown LLVMTypeKind"; + } +diff --git a/src/gallium/drivers/llvmpipe/lp_jit.c b/src/gallium/drivers/llvmpipe/lp_jit.c +index 268f0fa..ce92a80 100644 +--- a/src/gallium/drivers/llvmpipe/lp_jit.c ++++ b/src/gallium/drivers/llvmpipe/lp_jit.c +@@ -68,10 +68,17 @@ lp_jit_create_types(struct llvmpipe_context *lp) + elem_types[LP_JIT_TEXTURE_BORDER_COLOR] = + LLVMArrayType(LLVMFloatTypeInContext(lc), 4); + ++#if HAVE_LLVM >= 0x0300 ++ texture_type = LLVMStructCreateNamed(gallivm->context, "texture"); ++ LLVMStructSetBody(texture_type, elem_types, ++ Elements(elem_types), 0); ++#else + texture_type = LLVMStructTypeInContext(lc, elem_types, + Elements(elem_types), 0); ++ LLVMAddTypeName(gallivm->module, "texture", texture_type); + + LLVMInvalidateStructLayout(gallivm->target, texture_type); ++#endif + + LP_CHECK_MEMBER_OFFSET(struct lp_jit_texture, width, + gallivm->target, texture_type, +@@ -112,8 +119,6 @@ lp_jit_create_types(struct llvmpipe_context *lp) + + LP_CHECK_STRUCT_SIZE(struct lp_jit_texture, + gallivm->target, texture_type); +- +- LLVMAddTypeName(gallivm->module, "texture", texture_type); + } + + /* struct lp_jit_context */ +@@ -129,11 +134,19 @@ lp_jit_create_types(struct llvmpipe_context *lp) + elem_types[LP_JIT_CTX_TEXTURES] = LLVMArrayType(texture_type, + PIPE_MAX_SAMPLERS); + ++#if HAVE_LLVM >= 0x0300 ++ context_type = LLVMStructCreateNamed(gallivm->context, "context"); ++ LLVMStructSetBody(context_type, elem_types, ++ Elements(elem_types), 0); ++#else + context_type = LLVMStructTypeInContext(lc, elem_types, + Elements(elem_types), 0); + + LLVMInvalidateStructLayout(gallivm->target, context_type); + ++ LLVMAddTypeName(gallivm->module, "context", context_type); ++#endif ++ + LP_CHECK_MEMBER_OFFSET(struct lp_jit_context, constants, + gallivm->target, context_type, + LP_JIT_CTX_CONSTANTS); +@@ -155,8 +168,6 @@ lp_jit_create_types(struct llvmpipe_context *lp) + LP_CHECK_STRUCT_SIZE(struct lp_jit_context, + gallivm->target, context_type); + +- LLVMAddTypeName(gallivm->module, "context", context_type); +- + lp->jit_context_ptr_type = LLVMPointerType(context_type, 0); + } + |