From e05252b4765180b224cc78221e5fc0161873c2f3 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 2 Mar 2008 08:07:24 +0000 Subject: [PATCH] Several changes: * Simplify handling of byval, making it easier to understand and more consistent. This fixes PR2065. * Clean up and simplify handling of GEPs. I can actually understand it now! * Implement support for GEP'ing into vectors, this fixes SingleSource/UnitTests/Vector/build2 among others. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47818 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/CBackend/CBackend.cpp | 189 ++++++++++++++++++------------- 1 file changed, 108 insertions(+), 81 deletions(-) diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp index 7fcc3dd51db..ca00e19b2bf 100644 --- a/lib/Target/CBackend/CBackend.cpp +++ b/lib/Target/CBackend/CBackend.cpp @@ -87,7 +87,7 @@ namespace { std::map TypeNames; std::map FPConstantMap; std::set intrinsicPrototypesAlreadyGenerated; - std::set ByValParams; + std::set ByValParams; public: static char ID; @@ -122,8 +122,8 @@ namespace { delete Mang; FPConstantMap.clear(); TypeNames.clear(); - intrinsicPrototypesAlreadyGenerated.clear(); ByValParams.clear(); + intrinsicPrototypesAlreadyGenerated.clear(); return false; } @@ -139,6 +139,20 @@ namespace { void printStructReturnPointerFunctionType(std::ostream &Out, const ParamAttrsList *PAL, const PointerType *Ty); + + /// writeOperandDeref - Print the result of dereferencing the specified + /// operand with '*'. This is equivalent to printing '*' then using + /// writeOperand, but avoids excess syntax in some cases. + void writeOperandDeref(Value *Operand) { + if (isAddressExposed(Operand)) { + // Already something with an address exposed. + writeOperandInternal(Operand); + } else { + Out << "*("; + writeOperand(Operand); + Out << ")"; + } + } void writeOperand(Value *Operand); void writeOperandRaw(Value *Operand); @@ -170,8 +184,17 @@ namespace { void printConstantWithCast(Constant *CPV, unsigned Opcode); bool printConstExprCast(const ConstantExpr *CE); void printConstantArray(ConstantArray *CPA); - void printConstantVector(ConstantVector *CP); + void printConstantVector(ConstantVector *CV); + /// isAddressExposed - Return true if the specified value's name needs to + /// have its address taken in order to get a C value of the correct type. + /// This happens for global variables, byval parameters, and direct allocas. + bool isAddressExposed(const Value *V) const { + if (const Argument *A = dyn_cast(V)) + return ByValParams.count(A); + return isa(V) || isDirectAlloca(V); + } + // isInlinableInst - Attempt to inline instructions into their uses to build // trees as much as possible. To do this, we have to consistently decide // what is acceptable to inline, so that variable declarations don't get @@ -275,8 +298,8 @@ namespace { BasicBlock *Successor, unsigned Indent); void printBranchToBlock(BasicBlock *CurBlock, BasicBlock *SuccBlock, unsigned Indent); - void printIndexingExpression(Value *Ptr, gep_type_iterator I, - gep_type_iterator E); + void printGEPExpression(Value *Ptr, gep_type_iterator I, + gep_type_iterator E); std::string GetValueName(const Value *Operand); }; @@ -772,10 +795,10 @@ void CWriter::printConstant(Constant *CPV) { return; case Instruction::GetElementPtr: - Out << "(&("; - printIndexingExpression(CE->getOperand(0), gep_type_begin(CPV), - gep_type_end(CPV)); - Out << "))"; + Out << "("; + printGEPExpression(CE->getOperand(0), gep_type_begin(CPV), + gep_type_end(CPV)); + Out << ")"; return; case Instruction::Select: Out << '('; @@ -1214,12 +1237,13 @@ void CWriter::writeOperandRaw(Value *Operand) { } void CWriter::writeOperand(Value *Operand) { - if (isa(Operand) || isDirectAlloca(Operand)) + bool isAddressImplicit = isAddressExposed(Operand); + if (isAddressImplicit) Out << "(&"; // Global variables are referenced as their addresses by llvm writeOperandInternal(Operand); - if (isa(Operand) || isDirectAlloca(Operand)) + if (isAddressImplicit) Out << ')'; } @@ -1920,10 +1944,8 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) { ArgName = ""; const Type *ArgTy = I->getType(); if (PAL && PAL->paramHasAttr(Idx, ParamAttr::ByVal)) { - assert(isa(ArgTy)); ArgTy = cast(ArgTy)->getElementType(); - const Value *Arg = &(*I); - ByValParams.insert(Arg); + ByValParams.insert(I); } printType(FunctionInnards, ArgTy, /*isSigned=*/PAL && PAL->paramHasAttr(Idx, ParamAttr::SExt), @@ -2430,13 +2452,6 @@ void CWriter::visitCastInst(CastInst &I) { // Make sure we really get a sext from bool by subtracing the bool from 0 Out << "0-"; } - // If it's a byval parameter being casted, then takes its address. - bool isByVal = ByValParams.count(I.getOperand(0)); - if (isByVal) { - assert(I.getOpcode() == Instruction::BitCast && - "ByVal aggregate parameter must ptr type"); - Out << '&'; - } writeOperand(I.getOperand(0)); if (DstTy == Type::Int1Ty && (I.getOpcode() == Instruction::Trunc || @@ -2666,10 +2681,7 @@ void CWriter::visitCallInst(CallInst &I) { bool hasByVal = I.hasByValArgument(); bool isStructRet = I.isStructReturn(); if (isStructRet) { - bool isByVal = ByValParams.count(I.getOperand(1)); - if (!isByVal) Out << "*("; - writeOperand(I.getOperand(1)); - if (!isByVal) Out << ")"; + writeOperandDeref(I.getOperand(1)); Out << " = "; } @@ -2737,16 +2749,10 @@ void CWriter::visitCallInst(CallInst &I) { Out << ')'; } // Check if the argument is expected to be passed by value. - bool isOutByVal = PAL && PAL->paramHasAttr(ArgNo+1, ParamAttr::ByVal); - // Check if this argument itself is passed in by reference. - bool isInByVal = ByValParams.count(*AI); - if (isOutByVal && !isInByVal) - Out << "*("; - else if (!isOutByVal && isInByVal) - Out << "&("; - writeOperand(*AI); - if (isOutByVal ^ isInByVal) - Out << ")"; + if (I.paramHasAttr(ArgNo+1, ParamAttr::ByVal)) + writeOperandDeref(*AI); + else + writeOperand(*AI); PrintedArg = true; } Out << ')'; @@ -2858,7 +2864,7 @@ void CWriter::visitInlineAsm(CallInst &CI) { Out << "__asm__ volatile (\"" << asmstr << "\"\n"; Out << " :"; - for (std::vector >::iterator I = Output.begin(), + for (std::vector >::iterator I =Output.begin(), E = Output.end(); I != E; ++I) { Out << "\"" << I->first << "\"("; writeOperandRaw(I->second); @@ -2901,61 +2907,85 @@ void CWriter::visitFreeInst(FreeInst &I) { assert(0 && "lowerallocations pass didn't work!"); } -void CWriter::printIndexingExpression(Value *Ptr, gep_type_iterator I, - gep_type_iterator E) { - bool HasImplicitAddress = false; - // If accessing a global value with no indexing, avoid *(&GV) syndrome - if (isa(Ptr)) { - HasImplicitAddress = true; - } else if (isDirectAlloca(Ptr)) { - HasImplicitAddress = true; - } - +void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I, + gep_type_iterator E) { + + // If there are no indices, just print out the pointer. if (I == E) { - if (!HasImplicitAddress) - Out << '*'; // Implicit zero first argument: '*x' is equivalent to 'x[0]' - - writeOperandInternal(Ptr); + writeOperand(Ptr); return; } - - const Constant *CI = dyn_cast(I.getOperand()); - if (HasImplicitAddress && (!CI || !CI->isNullValue())) - Out << "(&"; - - writeOperandInternal(Ptr); - - if (HasImplicitAddress && (!CI || !CI->isNullValue())) { - Out << ')'; - HasImplicitAddress = false; // HIA is only true if we haven't addressed yet + + // Find out if the last index is into a vector. If so, we have to print this + // specially. Since vectors can't have elements of indexable type, only the + // last index could possibly be of a vector element. + const VectorType *LastIndexIsVector = 0; + { + for (gep_type_iterator TmpI = I; TmpI != E; ++TmpI) + LastIndexIsVector = dyn_cast(*TmpI); } + + Out << "("; + + // If the last index is into a vector, we can't print it as &a[i][j] because + // we can't index into a vector with j in GCC. Instead, emit this as + // (((float*)&a[i])+j) + if (LastIndexIsVector) { + Out << "(("; + printType(Out, PointerType::getUnqual(LastIndexIsVector->getElementType())); + Out << ")("; + } + + Out << '&'; - assert((!HasImplicitAddress || (CI && CI->isNullValue())) && - "Can only have implicit address with direct accessing"); + // If the first index is 0 (very typical) we can do a number of + // simplifications to clean up the code. + Value *FirstOp = I.getOperand(); + if (!isa(FirstOp) || !cast(FirstOp)->isNullValue()) { + // First index isn't simple, print it the hard way. + writeOperand(Ptr); + } else { + ++I; // Skip the zero index. - if (HasImplicitAddress) { - ++I; - } else if (CI && CI->isNullValue()) { - gep_type_iterator TmpI = I; ++TmpI; - - // Print out the -> operator if possible... - if (TmpI != E && isa(*TmpI)) { - // Check if it's actually an aggregate parameter passed by value. - bool isByVal = ByValParams.count(Ptr); - Out << ((HasImplicitAddress || isByVal) ? "." : "->"); - Out << "field" << cast(TmpI.getOperand())->getZExtValue(); - I = ++TmpI; + // Okay, emit the first operand. If Ptr is something that is already address + // exposed, like a global, avoid emitting (&foo)[0], just emit foo instead. + if (isAddressExposed(Ptr)) { + writeOperandInternal(Ptr); + } else if (I != E && isa(*I)) { + // If we didn't already emit the first operand, see if we can print it as + // P->f instead of "P[0].f" + writeOperand(Ptr); + Out << "->field" << cast(I.getOperand())->getZExtValue(); + ++I; // eat the struct index as well. + } else { + // Instead of emitting P[0][1], emit (*P)[1], which is more idiomatic. + Out << "(*"; + writeOperand(Ptr); + Out << ")"; } } - for (; I != E; ++I) + for (; I != E; ++I) { if (isa(*I)) { Out << ".field" << cast(I.getOperand())->getZExtValue(); - } else { + } else if (!isa(*I)) { Out << '['; writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr); Out << ']'; + } else { + // If the last index is into a vector, then print it out as "+j)". This + // works with the 'LastIndexIsVector' code above. + if (isa(I.getOperand()) && + cast(I.getOperand())->isNullValue()) { + Out << "))"; // avoid "+0". + } else { + Out << ")+("; + writeOperandWithCast(I.getOperand(), Instruction::GetElementPtr); + Out << "))"; + } } + } + Out << ")"; } void CWriter::writeMemoryAccess(Value *Operand, const Type *OperandType, @@ -2989,14 +3019,12 @@ void CWriter::writeMemoryAccess(Value *Operand, const Type *OperandType, } void CWriter::visitLoadInst(LoadInst &I) { - writeMemoryAccess(I.getOperand(0), I.getType(), I.isVolatile(), I.getAlignment()); } void CWriter::visitStoreInst(StoreInst &I) { - writeMemoryAccess(I.getPointerOperand(), I.getOperand(0)->getType(), I.isVolatile(), I.getAlignment()); Out << " = "; @@ -3018,9 +3046,8 @@ void CWriter::visitStoreInst(StoreInst &I) { } void CWriter::visitGetElementPtrInst(GetElementPtrInst &I) { - Out << '&'; - printIndexingExpression(I.getPointerOperand(), gep_type_begin(I), - gep_type_end(I)); + printGEPExpression(I.getPointerOperand(), gep_type_begin(I), + gep_type_end(I)); } void CWriter::visitVAArgInst(VAArgInst &I) {