Date: Mon, 30 Sep 2013 09:01:28 +0800 (CST) From: Jyun-Yan You <jyyou@cs.nctu.edu.tw> To: FreeBSD-gnats-submit@freebsd.org Subject: ports/182497: [MAINTAINER] lang/clay: update for LLVM 3.2 Message-ID: <201309300101.r8U11SaH094176@alumni.cs.nctu.edu.tw> Resent-Message-ID: <201309300110.r8U1A4jB004292@freefall.freebsd.org>
next in thread | raw e-mail | index | archive | help
>Number: 182497 >Category: ports >Synopsis: [MAINTAINER] lang/clay: update for LLVM 3.2 >Confidential: no >Severity: non-critical >Priority: low >Responsible: freebsd-ports-bugs >State: open >Quarter: >Keywords: >Date-Required: >Class: maintainer-update >Submitter-Id: current-users >Arrival-Date: Mon Sep 30 01:10:00 UTC 2013 >Closed-Date: >Last-Modified: >Originator: Jyun-Yan You >Release: FreeBSD 9.1-RELEASE-p5 amd64 >Organization: >Environment: System: FreeBSD plaslab.cs.nctu.edu.tw 9.1-RELEASE-p5 FreeBSD 9.1-RELEASE-p5 #0: Sat Jul 27 01:14:23 UTC 2013 >Description: Add an upstream patch for LLVM 3.2 Generated with FreeBSD Port Tools 0.99_8 (mode: change, diff: ports) >How-To-Repeat: >Fix: --- clay-0.1.2_1.patch begins here --- diff -ruN /usr/ports/lang/clay/Makefile ./Makefile --- /usr/ports/lang/clay/Makefile 2013-09-21 03:53:09.000000000 +0800 +++ ./Makefile 2013-09-28 22:57:27.042064398 +0800 @@ -3,6 +3,7 @@ PORTNAME= clay PORTVERSION= 0.1.2 +PORTREVISION= 1 CATEGORIES= lang MASTER_SITES= https://github.com/jckarter/${PORTNAME}/tarball/v${PORTVERSION}/ DISTNAME= jckarter-${PORTNAME}-v${PORTVERSION}-0-g${GITVERSION} @@ -12,7 +13,7 @@ LICENSE= BSD -BUILD_DEPENDS= llvm31>=3.1:${PORTSDIR}/devel/llvm31 +BUILD_DEPENDS= llvm>=3.2:${PORTSDIR}/devel/llvm OPTIONS_DEFINE= BINDGEN BINDGEN_DESC= Build with binding generator @@ -20,6 +21,7 @@ GITVERSION= 751ebe3 FETCH_ARGS= -pRr +PATCH_STRIP= -p1 WRKSRC= ${WRKDIR}/jckarter-${PORTNAME}-${GITVERSION} ONLY_FOR_ARCHS= i386 amd64 @@ -41,11 +43,11 @@ .endif .if ${OSVERSION} < 900044 || ${PORT_OPTIONS:MBINDGEN} -BUILD_DEPENDS+= clang31>=3.1:${PORTSDIR}/lang/clang31 -RUN_DEPENDS+= clang31>=3.1:${PORTSDIR}/lang/clang31 +BUILD_DEPENDS+= clang>=3.2:${PORTSDIR}/lang/clang +RUN_DEPENDS+= clang>=3.2:${PORTSDIR}/lang/clang .endif -.if defined(NOPORTDOCS) +.if ! ${PORT_OPTIONS:MDOCS} pre-configure: ${REINPLACE_CMD} \ -e 's|install(DIRECTORY doc/ DESTINATION share/doc/clay)||' \ diff -ruN /usr/ports/lang/clay/files/patch-llvm32 ./files/patch-llvm32 --- /usr/ports/lang/clay/files/patch-llvm32 1970-01-01 08:00:00.000000000 +0800 +++ ./files/patch-llvm32 2013-09-27 16:39:37.117857789 +0800 @@ -0,0 +1,489 @@ +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 89930e5..99ef0cc 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -23,8 +23,8 @@ if(UNIX) + OUTPUT_VARIABLE LLVM_VERSION + OUTPUT_STRIP_TRAILING_WHITESPACE + ) +- if(NOT ${LLVM_VERSION} STREQUAL "3.1") +- message(FATAL_ERROR "Clay requires LLVM 3.1.") ++ if(NOT ${LLVM_VERSION} STREQUAL "3.2") ++ message(FATAL_ERROR "Clay requires LLVM 3.2.") + endif() + + execute_process( +diff --git a/README.txt b/README.txt +index 855a4ab..7999b24 100644 +--- a/README.txt ++++ b/README.txt +@@ -9,7 +9,7 @@ Visit http://claylabs.com/clay for more information. + Pre-requisites + -------------- + +-Clay requires LLVM 3.1, Clang 3.1, and CMake version 2.6 or later. ++Clay requires LLVM 3.2, Clang 3.2, and CMake version 2.6 or later. + + CMake Configuration + ------------------- +@@ -20,7 +20,7 @@ be customized by passing cmake arguments of the form + CMake variables such as CMAKE_INSTALL_PREFIX and CMAKE_BUILD_TYPE, Clay's + build system uses the following variables: + +-* LLVM_DIR can be set to the install prefix of an LLVM 3.1 installation. ++* LLVM_DIR can be set to the install prefix of an LLVM 3.2 installation. + If not set, CMake will look for an 'llvm-config' script on the PATH. + * PYTHON_EXECUTABLE can be set to the path of a Python 2.x interpreter. + Clay uses a Python 2 script to drive its test suite. Some platforms +@@ -70,7 +70,7 @@ and the MSVC compiler. There are some issues with Debug builds and + LLVM, so both LLVM and Clay will need to be built as Release. The + default LLVM install directory needs Administrator permissions, so + you may want to set a CMAKE_INSTALL_PREFIX as well. to change it. +-Place the Clang repository in llvm-3.1/tools/clang so that LLVM builds ++Place the Clang repository in llvm-3.2/tools/clang so that LLVM builds + it automatically and compile LLVM with the following commands: + + mkdir build +diff --git a/compiler/src/clay.hpp b/compiler/src/clay.hpp +index 339b262..2c95623 100644 +--- a/compiler/src/clay.hpp ++++ b/compiler/src/clay.hpp +@@ -27,8 +27,6 @@ + #endif + + #include <llvm/ADT/Triple.h> +-#include <llvm/Analysis/DebugInfo.h> +-#include <llvm/Analysis/DIBuilder.h> + #include <llvm/Assembly/Writer.h> + #include <llvm/Assembly/Parser.h> + #include <llvm/Assembly/PrintModulePass.h> +@@ -36,12 +34,16 @@ + #include <llvm/Bitcode/ReaderWriter.h> + #include <llvm/CodeGen/LinkAllAsmWriterComponents.h> + #include <llvm/CodeGen/LinkAllCodegenComponents.h> ++#include <llvm/DataLayout.h> ++#include <llvm/DebugInfo.h> + #include <llvm/DerivedTypes.h> ++#include <llvm/DIBuilder.h> + #include <llvm/ExecutionEngine/ExecutionEngine.h> + #include <llvm/ExecutionEngine/GenericValue.h> + #include <llvm/ExecutionEngine/JIT.h> + #include <llvm/Function.h> + #include <llvm/Intrinsics.h> ++#include <llvm/IRBuilder.h> + #include <llvm/LinkAllVMCore.h> + #include <llvm/LLVMContext.h> + #include <llvm/Module.h> +@@ -50,7 +52,6 @@ + #include <llvm/Support/FileSystem.h> + #include <llvm/Support/FormattedStream.h> + #include <llvm/Support/Host.h> +-#include <llvm/Support/IRBuilder.h> + #include <llvm/Support/MemoryBuffer.h> + #include <llvm/Support/Path.h> + #include <llvm/Support/PathV2.h> +@@ -59,7 +60,6 @@ + #include <llvm/Support/TargetSelect.h> + #include <llvm/Support/TargetSelect.h> + #include <llvm/Support/raw_ostream.h> +-#include <llvm/Target/TargetData.h> + #include <llvm/Target/TargetOptions.h> + #include <llvm/Transforms/IPO/PassManagerBuilder.h> + #include <llvm/Transforms/IPO.h> +@@ -3450,7 +3450,7 @@ static const unsigned short DW_LANG_user_CLAY = 0xC1A4; + + extern llvm::Module *llvmModule; + extern llvm::DIBuilder *llvmDIBuilder; +-extern const llvm::TargetData *llvmTargetData; ++extern const llvm::DataLayout *llvmDataLayout; + + llvm::PointerType *exceptionReturnType(); + llvm::Value *noExceptionReturnValue(); +diff --git a/compiler/src/codegen.cpp b/compiler/src/codegen.cpp +index f6ed737..1fb574e 100644 +--- a/compiler/src/codegen.cpp ++++ b/compiler/src/codegen.cpp +@@ -5,7 +5,7 @@ namespace clay { + llvm::Module *llvmModule = NULL; + llvm::DIBuilder *llvmDIBuilder = NULL; + llvm::ExecutionEngine *llvmEngine; +-const llvm::TargetData *llvmTargetData; ++const llvm::DataLayout *llvmDataLayout; + + static vector<CValuePtr> initializedGlobals; + static CodegenContextPtr constructorsCtx; +@@ -2886,7 +2886,10 @@ void codegenCodeBody(InvokeEntryPtr entry) + llvmModule); + + for (unsigned i = 1; i <= llArgTypes.size(); ++i) { +- llFunc->addAttribute(i, llvm::Attribute::NoAlias); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ llFunc->getContext(), ++ llvm::Attributes::NoAlias); ++ llFunc->addAttribute(i, attrs); + } + + entry->llvmFunc = llFunc; +@@ -2903,15 +2906,22 @@ void codegenCodeBody(InvokeEntryPtr entry) + for (unsigned i = 0; i < entry->argsKey.size(); ++i) { + llvm::DIType argType = llvmTypeDebugInfo(entry->argsKey[i]); + llvm::DIType argRefType +- = llvmDIBuilder->createReferenceType(argType); ++ = llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ argType); + debugParamTypes.push_back(argRefType); + } + for (unsigned i = 0; i < entry->returnTypes.size(); ++i) { + llvm::DIType returnType = llvmTypeDebugInfo(entry->returnTypes[i]); + llvm::DIType returnRefType = entry->returnIsRef[i] + ? llvmDIBuilder->createReferenceType( +- llvmDIBuilder->createReferenceType(returnType)) +- : llvmDIBuilder->createReferenceType(returnType); ++ llvm::dwarf::DW_TAG_reference_type, ++ llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ returnType)) ++ : llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ returnType); + + debugParamTypes.push_back(returnRefType); + } +@@ -2983,6 +2993,7 @@ void codegenCodeBody(InvokeEntryPtr entry) + file, // file + line, // line + llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, + llvmTypeDebugInfo(entry->fixedArgTypes[i])), // type + true, // alwaysPreserve + 0, // flags +@@ -3025,6 +3036,7 @@ void codegenCodeBody(InvokeEntryPtr entry) + file, // file + line, // line + llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, + llvmTypeDebugInfo(entry->varArgTypes[i])), // type + true, // alwaysPreserve + 0, // flags +@@ -3084,6 +3096,7 @@ void codegenCodeBody(InvokeEntryPtr entry) + file, // file + line, // line + llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, + llvmTypeDebugInfo(returns[i].type)), // type + true, // alwaysPreserve + 0, // flags +@@ -4076,6 +4089,7 @@ EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContextPtr ctx) + file, // file + line, // line + llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, + llvmTypeDebugInfo(pv->type)), // type + true, // alwaysPreserve + 0, // flags +@@ -4133,6 +4147,7 @@ EnvPtr codegenBinding(BindingPtr x, EnvPtr env, CodegenContextPtr ctx) + pv->isTemp + ? llvmTypeDebugInfo(pv->type) + : llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, + llvmTypeDebugInfo(pv->type)), // type + true, // alwaysPreserve + 0, // flags +@@ -6464,8 +6479,8 @@ llvm::TargetMachine *initLLVM(std::string const &targetTriple, + targetTriple, "", "", llvm::TargetOptions(), reloc, codeModel); + + if (targetMachine != NULL) { +- llvmTargetData = targetMachine->getTargetData(); +- llvmModule->setDataLayout(llvmTargetData->getStringRepresentation()); ++ llvmDataLayout = targetMachine->getDataLayout(); ++ llvmModule->setDataLayout(llvmDataLayout->getStringRepresentation()); + } + + return targetMachine; +diff --git a/compiler/src/externals.cpp b/compiler/src/externals.cpp +index f7cd333..ba43797 100644 +--- a/compiler/src/externals.cpp ++++ b/compiler/src/externals.cpp +@@ -23,11 +23,12 @@ static llvm::Value *promoteCVarArg(CallingConv conv, + } + case FLOAT_TYPE : { + FloatType *ft = (FloatType *)t.ptr(); +- if (ft->bits == 32) ++ if (ft->bits == 32) { + if(ft->isImaginary) + return ctx->builder->CreateFPExt(llv, llvmType(imag64Type)); + else + return ctx->builder->CreateFPExt(llv, llvmType(float64Type)); ++ } + return llv; + } + default : +@@ -43,8 +44,12 @@ llvm::Type *ExternalTarget::pushReturnType(CallingConv conv, + if (type == NULL) + return llvmVoidType(); + else if (typeReturnsBySretPointer(conv, type)) { +- llArgTypes.push_back(llvmPointerType(type)); +- llAttributes.push_back(make_pair(llArgTypes.size(), llvm::Attribute::StructRet)); ++ llvm::Type *llType = llvmPointerType(type); ++ llArgTypes.push_back(llType); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ llType->getContext(), ++ llvm::Attributes::StructRet); ++ llAttributes.push_back(make_pair(llArgTypes.size(), attrs)); + return llvmVoidType(); + } else { + llvm::Type *bitcastType = typeReturnsAsBitcastType(conv, type); +@@ -61,8 +66,12 @@ void ExternalTarget::pushArgumentType(CallingConv conv, + vector< pair<unsigned, llvm::Attributes> > &llAttributes) + { + if (typePassesByByvalPointer(conv, type, false)) { +- llArgTypes.push_back(llvmPointerType(type)); +- llAttributes.push_back(make_pair(llArgTypes.size(), llvm::Attribute::ByVal)); ++ llvm::Type *llType = llvmPointerType(type); ++ llArgTypes.push_back(llType); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ llType->getContext(), ++ llvm::Attributes::ByVal); ++ llAttributes.push_back(make_pair(llArgTypes.size(), attrs)); + } else { + llvm::Type *bitcastType = typePassesAsBitcastType(conv, type, false); + if (bitcastType != NULL) +@@ -171,7 +180,10 @@ void ExternalTarget::loadStructRetArgument(CallingConv conv, + CValuePtr out0 = out->values[0]; + assert(out0->type == type); + llArgs.push_back(out0->llValue); +- llAttributes.push_back(make_pair(llArgs.size(), llvm::Attribute::StructRet)); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ out0->llValue->getContext(), ++ llvm::Attributes::StructRet); ++ llAttributes.push_back(make_pair(llArgs.size(), attrs)); + } + } + +@@ -183,7 +195,10 @@ void ExternalTarget::loadArgument(CallingConv conv, + { + if (typePassesByByvalPointer(conv, cv->type, false)) { + llArgs.push_back(cv->llValue); +- llAttributes.push_back(make_pair(llArgs.size(), llvm::Attribute::ByVal)); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ cv->llValue->getContext(), ++ llvm::Attributes::ByVal); ++ llAttributes.push_back(make_pair(llArgs.size(), attrs)); + } else { + llvm::Type *bitcastType = typePassesAsBitcastType(conv, cv->type, false); + if (bitcastType != NULL) { +@@ -206,7 +221,10 @@ void ExternalTarget::loadVarArgument(CallingConv conv, + { + if (typePassesByByvalPointer(conv, cv->type, true)) { + llArgs.push_back(cv->llValue); +- llAttributes.push_back(make_pair(llArgs.size(), llvm::Attribute::ByVal)); ++ llvm::Attributes attrs = llvm::Attributes::get( ++ cv->llValue->getContext(), ++ llvm::Attributes::ByVal); ++ llAttributes.push_back(make_pair(llArgs.size(), attrs)); + } else { + llvm::Type *bitcastType = typePassesAsBitcastType(conv, cv->type, true); + if (bitcastType != NULL) { +@@ -845,21 +863,26 @@ llvm::Type *X86_64_ExternalTarget::llvmWordType(TypePtr type) + llvm::StructType *llType = llvm::StructType::create(llvm::getGlobalContext(), "x86-64 " + typeName(type)); + vector<llvm::Type*> llWordTypes; + vector<WordClass>::const_iterator i = wordClasses.begin(); ++ size_t size = typeSize(type); + while (i != wordClasses.end()) { ++ assert(size > 0); + switch (*i) { + // docs don't cover this case. is it possible? + // e.g. struct { __m128 a; __m256 b; }; + case NO_CLASS: + assert(false); + break; +- case INTEGER: +- llWordTypes.push_back(llvmIntType(64)); ++ case INTEGER: { ++ size_t wordSize = size >= 8 ? 64 : size*8; ++ llWordTypes.push_back(llvmIntType(wordSize)); + ++i; + break; ++ } + case SSE_INT_VECTOR: { + int vectorRun = 0; + do { ++vectorRun; ++i; } while (i != wordClasses.end() && *i == SSEUP); +- // 8-byte int vectors are allocated to MMX registers ++ // 8-byte int vectors are allocated to MMX registers, so always generate ++ // a <float x n> vector for 64-bit SSE words. + if (vectorRun == 1) + llWordTypes.push_back(llvm::VectorType::get(llvmFloatType(64), vectorRun)); + else +@@ -913,6 +936,8 @@ llvm::Type *X86_64_ExternalTarget::llvmWordType(TypePtr type) + assert(false); + break; + } ++ assert(size >= 8 || i == wordClasses.end()); ++ size -= 8; + } + llType->setBody(llWordTypes); + return llType; +diff --git a/compiler/src/loader.cpp b/compiler/src/loader.cpp +index cd90f58..78b6a18 100644 +--- a/compiler/src/loader.cpp ++++ b/compiler/src/loader.cpp +@@ -70,8 +70,8 @@ static std::string getCPU(llvm::Triple const &triple) { + } + } + +-static std::string getPtrSize(const llvm::TargetData *targetData) { +- switch (targetData->getPointerSizeInBits()) { ++static std::string getPtrSize(const llvm::DataLayout *dataLayout) { ++ switch (dataLayout->getPointerSizeInBits()) { + case 32 : return "32"; + case 64 : return "64"; + default : assert(false); return ""; +@@ -84,7 +84,7 @@ static void initModuleSuffixes() { + string os = getOS(triple); + string osgroup = getOSGroup(triple); + string cpu = getCPU(triple); +- string bits = getPtrSize(llvmTargetData); ++ string bits = getPtrSize(llvmDataLayout); + moduleSuffixes.push_back("." + os + "." + cpu + "." + bits + ".clay"); + moduleSuffixes.push_back("." + os + "." + cpu + ".clay"); + moduleSuffixes.push_back("." + os + "." + bits + ".clay"); +diff --git a/compiler/src/main.cpp b/compiler/src/main.cpp +index f2fbd85..a24c20f 100644 +--- a/compiler/src/main.cpp ++++ b/compiler/src/main.cpp +@@ -72,12 +72,12 @@ static void optimizeLLVM(llvm::Module *module, unsigned optLevel, bool internali + llvm::PassManager passes; + + string moduleDataLayout = module->getDataLayout(); +- llvm::TargetData *td = new llvm::TargetData(moduleDataLayout); +- passes.add(td); ++ llvm::DataLayout *dl = new llvm::DataLayout(moduleDataLayout); ++ passes.add(dl); + + llvm::FunctionPassManager fpasses(module); + +- fpasses.add(new llvm::TargetData(*td)); ++ fpasses.add(new llvm::DataLayout(*dl)); + + addOptimizationPasses(passes, fpasses, optLevel, internalize); + +@@ -116,7 +116,7 @@ static void generateAssembly(llvm::Module *module, + + llvm::FunctionPassManager fpasses(module); + +- fpasses.add(new llvm::TargetData(module)); ++ fpasses.add(new llvm::DataLayout(module)); + fpasses.add(llvm::createVerifierPass()); + + targetMachine->setAsmVerbosityDefault(true); +@@ -180,7 +180,7 @@ static bool generateBinary(llvm::Module *module, + vector<const char *> clangArgs; + clangArgs.push_back(clangPath.c_str()); + +- switch (llvmTargetData->getPointerSizeInBits()) { ++ switch (llvmDataLayout->getPointerSizeInBits()) { + case 32 : + clangArgs.push_back("-m32"); + break; +diff --git a/compiler/src/types.cpp b/compiler/src/types.cpp +index 8f86faa..6990a15 100644 +--- a/compiler/src/types.cpp ++++ b/compiler/src/types.cpp +@@ -43,11 +43,11 @@ static vector<vector<StaticTypePtr> > staticTypes; + // + + static size_t llTypeSize(llvm::Type *llt) { +- return (size_t)llvmTargetData->getTypeAllocSize(llt); ++ return (size_t)llvmDataLayout->getTypeAllocSize(llt); + } + + static size_t llTypeAlignment(llvm::Type *llt) { +- return (size_t)llvmTargetData->getABITypeAlignment(llt); ++ return (size_t)llvmDataLayout->getABITypeAlignment(llt); + } + + static size_t debugTypeSize(llvm::Type *llt) { +@@ -81,7 +81,7 @@ void initTypes() { + complex80Type = new ComplexType(80); + + cIntType = int32Type; +- switch (llvmTargetData->getPointerSizeInBits()) { ++ switch (llvmDataLayout->getPointerSizeInBits()) { + case 32 : + cSizeTType = uint32Type; + cPtrDiffTType = int32Type; +@@ -826,7 +826,7 @@ const llvm::StructLayout *tupleTypeLayout(TupleType *t) { + if (t->layout == NULL) { + llvm::StructType *st = + llvm::cast<llvm::StructType>(llvmType(t)); +- t->layout = llvmTargetData->getStructLayout(st); ++ t->layout = llvmDataLayout->getStructLayout(st); + } + return t->layout; + } +@@ -835,7 +835,7 @@ const llvm::StructLayout *complexTypeLayout(ComplexType *t) { + if (t->layout == NULL) { + llvm::StructType *st = + llvm::cast<llvm::StructType>(llvmType(t)); +- t->layout = llvmTargetData->getStructLayout(st); ++ t->layout = llvmDataLayout->getStructLayout(st); + } + return t->layout; + } +@@ -844,7 +844,7 @@ const llvm::StructLayout *recordTypeLayout(RecordType *t) { + if (t->layout == NULL) { + llvm::StructType *st = + llvm::cast<llvm::StructType>(llvmType(t)); +- t->layout = llvmTargetData->getStructLayout(st); ++ t->layout = llvmDataLayout->getStructLayout(st); + } + return t->layout; + } +@@ -1101,15 +1101,22 @@ static void declareLLVMType(TypePtr t) { + for (unsigned i = 0; i < x->argTypes.size(); ++i) { + llvm::DIType argType = llvmTypeDebugInfo(x->argTypes[i]); + llvm::DIType argRefType +- = llvmDIBuilder->createReferenceType(argType); ++ = llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ argType); + debugParamTypes.push_back(argRefType); + } + for (unsigned i = 0; i < x->returnTypes.size(); ++i) { + llvm::DIType returnType = llvmTypeDebugInfo(x->returnTypes[i]); + llvm::DIType returnRefType = x->returnIsRef[i] + ? llvmDIBuilder->createReferenceType( +- llvmDIBuilder->createReferenceType(returnType)) +- : llvmDIBuilder->createReferenceType(returnType); ++ llvm::dwarf::DW_TAG_reference_type, ++ llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ returnType)) ++ : llvmDIBuilder->createReferenceType( ++ llvm::dwarf::DW_TAG_reference_type, ++ returnType); + + debugParamTypes.push_back(returnRefType); + } +@@ -1259,7 +1266,8 @@ static void declareLLVMType(TypePtr t) { + line, + debugTypeSize(t->llType), + debugTypeAlignment(t->llType), +- enumArray); ++ enumArray, ++ llvm::DIType()); + } + break; + } +@@ -1358,8 +1366,8 @@ static void defineLLVMType(TypePtr t) { + size_t maxSize = 0; + for (unsigned i = 0; i < x->memberTypes.size(); ++i) { + llvm::Type *llt = llvmType(x->memberTypes[i]); +- size_t align = (size_t)llvmTargetData->getABITypeAlignment(llt); +- size_t size = (size_t)llvmTargetData->getTypeAllocSize(llt); ++ size_t align = (size_t)llvmDataLayout->getABITypeAlignment(llt); ++ size_t size = (size_t)llvmDataLayout->getTypeAllocSize(llt); + if (align > maxAlign) { + maxAlign = align; + maxAlignType = llt; --- clay-0.1.2_1.patch ends here --- >Release-Note: >Audit-Trail: >Unformatted:
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201309300101.r8U11SaH094176>