From 71537c178303c9d3f44aa0b9e0de167a7d670c77 Mon Sep 17 00:00:00 2001 From: Robert Lytton Date: Mon, 9 Sep 2013 10:42:11 +0000 Subject: [PATCH] XCore handling of thread local lowering Fix XCoreLowerThreadLocal trying to initialise globals which have no initializer. Add handling of const expressions containing thread local variables. These need to be replaced with instructions, as the thread ID is used to access the thread local variable. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190300 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/XCore/XCoreLowerThreadLocal.cpp | 103 +++++++++++++++++++-- test/CodeGen/XCore/threads.ll | 71 ++++++++++---- 2 files changed, 149 insertions(+), 25 deletions(-) diff --git a/lib/Target/XCore/XCoreLowerThreadLocal.cpp b/lib/Target/XCore/XCoreLowerThreadLocal.cpp index 2e328b4e344..5a832825148 100644 --- a/lib/Target/XCore/XCoreLowerThreadLocal.cpp +++ b/lib/Target/XCore/XCoreLowerThreadLocal.cpp @@ -22,6 +22,8 @@ #include "llvm/IR/Module.h" #include "llvm/Pass.h" #include "llvm/Support/CommandLine.h" +#include "llvm/Support/NoFolder.h" +#include "llvm/Support/ValueHandle.h" #define DEBUG_TYPE "xcore-lower-thread-local" @@ -71,13 +73,94 @@ createLoweredInitializer(ArrayType *NewType, Constant *OriginalInitializer) { return ConstantArray::get(NewType, Elements); } -static bool hasNonInstructionUse(GlobalVariable *GV) { - for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end(); UI != E; - ++UI) - if (!isa(*UI)) - return true; +static Instruction * +createReplacementInstr(ConstantExpr *CE, Instruction *Instr) { + IRBuilder Builder(Instr); + unsigned OpCode = CE->getOpcode(); + switch (OpCode) { + case Instruction::GetElementPtr: { + SmallVector CEOpVec(CE->op_begin(), CE->op_end()); + ArrayRef CEOps(CEOpVec); + return dyn_cast(Builder.CreateInBoundsGEP(CEOps[0], + CEOps.slice(1))); + } + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + case Instruction::UDiv: + case Instruction::SDiv: + case Instruction::FDiv: + case Instruction::URem: + case Instruction::SRem: + case Instruction::FRem: + case Instruction::Shl: + case Instruction::LShr: + case Instruction::AShr: + case Instruction::And: + case Instruction::Or: + case Instruction::Xor: + return dyn_cast( + Builder.CreateBinOp((Instruction::BinaryOps)OpCode, + CE->getOperand(0), CE->getOperand(1), + CE->getName())); + case Instruction::Trunc: + case Instruction::ZExt: + case Instruction::SExt: + case Instruction::FPToUI: + case Instruction::FPToSI: + case Instruction::UIToFP: + case Instruction::SIToFP: + case Instruction::FPTrunc: + case Instruction::FPExt: + case Instruction::PtrToInt: + case Instruction::IntToPtr: + case Instruction::BitCast: + return dyn_cast( + Builder.CreateCast((Instruction::CastOps)OpCode, + CE->getOperand(0), CE->getType(), + CE->getName())); + default: + assert(0 && "Unhandled constant expression!\n"); + } +} + +static bool replaceConstantExprOp(ConstantExpr *CE) { + do { + SmallVector WUsers; + for (Value::use_iterator I = CE->use_begin(), E = CE->use_end(); + I != E; ++I) + WUsers.push_back(WeakVH(*I)); + while (!WUsers.empty()) + if (WeakVH WU = WUsers.pop_back_val()) { + if (Instruction *Instr = dyn_cast(WU)) { + Instruction *NewInst = createReplacementInstr(CE, Instr); + assert(NewInst && "Must build an instruction\n"); + // If NewInst uses a CE being handled in an earlier recursion the + // earlier recursion's do-while-hasNUsesOrMore(1) will run again. + Instr->replaceUsesOfWith(CE, NewInst); + } else { + ConstantExpr *CExpr = dyn_cast(WU); + if (!CExpr || !replaceConstantExprOp(CExpr)) + return false; + } + } + } while (CE->hasNUsesOrMore(1)); // Does a recursion's NewInst use CE? + CE->destroyConstant(); + return true; +} - return false; +static bool rewriteNonInstructionUses(GlobalVariable *GV) { + SmallVector WUsers; + for (Value::use_iterator I = GV->use_begin(), E = GV->use_end(); I != E; ++I) + if (!isa(*I)) + WUsers.push_back(WeakVH(*I)); + while (!WUsers.empty()) + if (WeakVH WU = WUsers.pop_back_val()) { + ConstantExpr *CE = dyn_cast(WU); + if (!CE || !replaceConstantExprOp(CE)) + return false; + } + return true; } static bool isZeroLengthArray(Type *Ty) { @@ -92,14 +175,16 @@ bool XCoreLowerThreadLocal::lowerGlobal(GlobalVariable *GV) { return false; // Skip globals that we can't lower and leave it for the backend to error. - if (hasNonInstructionUse(GV) || + if (!rewriteNonInstructionUses(GV) || !GV->getType()->isSized() || isZeroLengthArray(GV->getType())) return false; // Create replacement global. ArrayType *NewType = createLoweredType(GV->getType()->getElementType()); - Constant *NewInitializer = createLoweredInitializer(NewType, - GV->getInitializer()); + Constant *NewInitializer = 0; + if (GV->hasInitializer()) + NewInitializer = createLoweredInitializer(NewType, + GV->getInitializer()); GlobalVariable *NewGV = new GlobalVariable(*M, NewType, GV->isConstant(), GV->getLinkage(), NewInitializer, "", 0, GlobalVariable::NotThreadLocal, diff --git a/test/CodeGen/XCore/threads.ll b/test/CodeGen/XCore/threads.ll index 5840e777618..b56b16b5fa9 100644 --- a/test/CodeGen/XCore/threads.ll +++ b/test/CodeGen/XCore/threads.ll @@ -13,55 +13,94 @@ declare void @llvm.xcore.initdp.p1i8(i8 addrspace(1)* %r, i8* %value) define i8 addrspace(1)* @test_getst(i8 addrspace(1)* %r) { ; CHECK-LABEL: test_getst: ; CHECK: getst r0, res[r0] - %result = call i8 addrspace(1)* @llvm.xcore.getst.p1i8.p1i8(i8 addrspace(1)* %r) - ret i8 addrspace(1)* %result + %result = call i8 addrspace(1)* @llvm.xcore.getst.p1i8.p1i8(i8 addrspace(1)* %r) + ret i8 addrspace(1)* %result } define void @test_ssync() { ; CHECK-LABEL: test_ssync: ; CHECK: ssync - call void @llvm.xcore.ssync() - ret void + call void @llvm.xcore.ssync() + ret void } define void @test_mjoin(i8 addrspace(1)* %r) { ; CHECK-LABEL: test_mjoin: ; CHECK: mjoin res[r0] - call void @llvm.xcore.mjoin.p1i8(i8 addrspace(1)* %r) - ret void + call void @llvm.xcore.mjoin.p1i8(i8 addrspace(1)* %r) + ret void } define void @test_initsp(i8 addrspace(1)* %t, i8* %src) { ; CHECK-LABEL: test_initsp: ; CHECK: init t[r0]:sp, r1 - call void @llvm.xcore.initsp.p1i8(i8 addrspace(1)* %t, i8* %src) - ret void + call void @llvm.xcore.initsp.p1i8(i8 addrspace(1)* %t, i8* %src) + ret void } define void @test_initpc(i8 addrspace(1)* %t, i8* %src) { ; CHECK-LABEL: test_initpc: ; CHECK: init t[r0]:pc, r1 - call void @llvm.xcore.initpc.p1i8(i8 addrspace(1)* %t, i8* %src) - ret void + call void @llvm.xcore.initpc.p1i8(i8 addrspace(1)* %t, i8* %src) + ret void } define void @test_initlr(i8 addrspace(1)* %t, i8* %src) { ; CHECK-LABEL: test_initlr: ; CHECK: init t[r0]:lr, r1 - call void @llvm.xcore.initlr.p1i8(i8 addrspace(1)* %t, i8* %src) - ret void + call void @llvm.xcore.initlr.p1i8(i8 addrspace(1)* %t, i8* %src) + ret void } define void @test_initcp(i8 addrspace(1)* %t, i8* %src) { ; CHECK-LABEL: test_initcp: ; CHECK: init t[r0]:cp, r1 - call void @llvm.xcore.initcp.p1i8(i8 addrspace(1)* %t, i8* %src) - ret void + call void @llvm.xcore.initcp.p1i8(i8 addrspace(1)* %t, i8* %src) + ret void } define void @test_initdp(i8 addrspace(1)* %t, i8* %src) { ; CHECK-LABEL: test_initdp: ; CHECK: init t[r0]:dp, r1 - call void @llvm.xcore.initdp.p1i8(i8 addrspace(1)* %t, i8* %src) - ret void + call void @llvm.xcore.initdp.p1i8(i8 addrspace(1)* %t, i8* %src) + ret void } + +@tl = thread_local global [3 x i32] zeroinitializer +@tle = external thread_local global [2 x i32] + +define i32* @f_tl() { +; CHECK-LABEL: f_tl: +; CHECK: get r11, id +; CHECK: ldaw [[R0:r[0-9]]], dp[tl] +; CHECK: ldc [[R1:r[0-9]]], 8 +; CHECK: ldc [[R2:r[0-9]]], 12 +; r0 = id*12 + 8 + &tl +; CHECK: lmul {{r[0-9]}}, r0, r11, [[R2]], [[R0]], [[R1]] + ret i32* getelementptr inbounds ([3 x i32]* @tl, i32 0, i32 2) +} + +define i32* @f_tle() { +; CHECK-LABEL: f_tle: +; CHECK: get r11, id +; CHECK: shl [[R0:r[0-9]]], r11, 3 +; CHECK: ldaw [[R1:r[0-9]]], dp[tle] +; r0 = &tl + id*8 +; CHECK: add r0, [[R1]], [[R0]] + ret i32* getelementptr inbounds ([2 x i32]* @tle, i32 0, i32 0) +} + +define i32 @f_tlExpr () { +; CHECK-LABEL: f_tlExpr: +; CHECK: get r11, id +; CHECK: shl [[R0:r[0-9]]], r11, 3 +; CHECK: ldaw [[R1:r[0-9]]], dp[tle] +; CHECK: add [[R2:r[0-9]]], [[R1]], [[R0]] +; CHECK: add r0, [[R2]], [[R2]] + ret i32 add( + i32 ptrtoint( i32* getelementptr inbounds ([2 x i32]* @tle, i32 0, i32 0) to i32), + i32 ptrtoint( i32* getelementptr inbounds ([2 x i32]* @tle, i32 0, i32 0) to i32)) +} + +; CHECK-LABEL: tl: +; CHECK: .space 96 -- 2.34.1