From d4ab1926af982e4334978fd9bf9156c7c087f6f5 Mon Sep 17 00:00:00 2001 From: Justin Holewinski Date: Tue, 2 Apr 2013 12:37:11 +0000 Subject: [PATCH] [NVPTX] Fix a few style issues in NVVMReflect git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@178536 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Target/NVPTX/NVVMReflect.cpp | 128 ++++++++++++++----------------- 1 file changed, 56 insertions(+), 72 deletions(-) diff --git a/lib/Target/NVPTX/NVVMReflect.cpp b/lib/Target/NVPTX/NVVMReflect.cpp index 3bbd1a13da0..0ad62ce39b0 100644 --- a/lib/Target/NVPTX/NVVMReflect.cpp +++ b/lib/Target/NVPTX/NVVMReflect.cpp @@ -9,9 +9,13 @@ // // This pass replaces occurences of __nvvm_reflect("string") with an // integer based on -nvvm-reflect-list string= option given to this pass. +// If an undefined string value is seen in a call to __nvvm_reflect("string"), +// a default value of 0 will be used. // //===----------------------------------------------------------------------===// +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/Pass.h" #include "llvm/IR/Function.h" @@ -38,16 +42,15 @@ namespace llvm { void initializeNVVMReflectPass(PassRegistry &); } namespace { class LLVM_LIBRARY_VISIBILITY NVVMReflect : public ModulePass { private: - //std::map VarMap; StringMap VarMap; - typedef std::map::iterator VarMapIter; - Function *reflectFunction; + typedef DenseMap::iterator VarMapIter; + Function *ReflectFunction; public: static char ID; NVVMReflect() : ModulePass(ID) { VarMap.clear(); - reflectFunction = 0; + ReflectFunction = 0; } void getAnalysisUsage(AnalysisUsage &AU) const { AU.setPreservesAll(); } @@ -67,48 +70,30 @@ INITIALIZE_PASS(NVVMReflect, "nvvm-reflect", false) static cl::list -ReflectList("nvvm-reflect-list", cl::value_desc("name=0/1"), - cl::desc("A list of string=num assignments, where num=0 or 1"), +ReflectList("nvvm-reflect-list", cl::value_desc("name="), + cl::desc("A list of string=num assignments"), cl::ValueRequired); -/// This function does the same operation as perl's split. -/// For example, calling this with ("a=1,b=2,c=0", ",") will -/// return ["a=1", "b=2", "c=0"] in the return std::vector. -static std::vector -Tokenize(const std::string &str, const std::string &delim) { - std::vector tokens; - - size_t p0 = 0, p1 = std::string::npos; - while (p0 != std::string::npos) { - p1 = str.find_first_of(delim, p0); - if (p1 != p0) { - std::string token = str.substr(p0, p1 - p0); - tokens.push_back(token); - } - p0 = str.find_first_not_of(delim, p1); - } - - return tokens; -} - /// The command line can look as follows : -/// -R a=1,b=2 -R c=3,d=0 -R e=2 +/// -nvvm-reflect-list a=1,b=2 -nvvm-reflect-list c=3,d=0 -R e=2 /// The strings "a=1,b=2", "c=3,d=0", "e=2" are available in the /// ReflectList vector. First, each of ReflectList[i] is 'split' /// using "," as the delimiter. Then each of this part is split /// using "=" as the delimiter. void NVVMReflect::setVarMap() { for (unsigned i = 0, e = ReflectList.size(); i != e; ++i) { - // DEBUG(dbgs() << "Option : " << ReflectList[i] << std::endl); - std::vector nameValList = Tokenize(ReflectList[i], ","); - for (unsigned j = 0, ej = nameValList.size(); j != ej; ++j) { - std::vector nameValPair = Tokenize(nameValList[j], "="); - assert(nameValPair.size() == 2 && "name=val expected"); - std::stringstream valstream(nameValPair[1]); - int val; - valstream >> val; - assert((!(valstream.fail())) && "integer value expected"); - VarMap[nameValPair[0]] = val; + DEBUG(dbgs() << "Option : " << ReflectList[i] << "\n"); + SmallVector NameValList; + StringRef(ReflectList[i]).split(NameValList, ","); + for (unsigned j = 0, ej = NameValList.size(); j != ej; ++j) { + SmallVector NameValPair; + NameValList[j].split(NameValPair, "="); + assert(NameValPair.size() == 2 && "name=val expected"); + std::stringstream ValStream(NameValPair[1]); + int Val; + ValStream >> Val; + assert((!(ValStream.fail())) && "integer value expected"); + VarMap[NameValPair[0]] = Val; } } } @@ -119,75 +104,74 @@ bool NVVMReflect::runOnModule(Module &M) { setVarMap(); - reflectFunction = M.getFunction(NVVM_REFLECT_FUNCTION); + ReflectFunction = M.getFunction(NVVM_REFLECT_FUNCTION); // If reflect function is not used, then there will be // no entry in the module. - if (reflectFunction == 0) { + if (ReflectFunction == 0) return false; - } // Validate _reflect function - assert(reflectFunction->isDeclaration() && + assert(ReflectFunction->isDeclaration() && "_reflect function should not have a body"); - assert(reflectFunction->getReturnType()->isIntegerTy() && + assert(ReflectFunction->getReturnType()->isIntegerTy() && "_reflect's return type should be integer"); - std::vector toRemove; + std::vector ToRemove; - // Go through the uses of reflectFunction in this Function. + // Go through the uses of ReflectFunction in this Function. // Each of them should a CallInst with a ConstantArray argument. // First validate that. If the c-string corresponding to the // ConstantArray can be found successfully, see if it can be // found in VarMap. If so, replace the uses of CallInst with the // value found in VarMap. If not, replace the use with value 0. - for (Value::use_iterator iter = reflectFunction->use_begin(), - iterEnd = reflectFunction->use_end(); - iter != iterEnd; ++iter) { - assert(isa(*iter) && "Only a call instruction can use _reflect"); - CallInst *reflect = cast(*iter); + for (Value::use_iterator I = ReflectFunction->use_begin(), + E = ReflectFunction->use_end(); + I != E; ++I) { + assert(isa(*I) && "Only a call instruction can use _reflect"); + CallInst *Reflect = cast(*I); - assert((reflect->getNumOperands() == 2) && + assert((Reflect->getNumOperands() == 2) && "Only one operand expect for _reflect function"); // In cuda, we will have an extra constant-to-generic conversion of // the string. - const Value *conv = reflect->getArgOperand(0); + const Value *conv = Reflect->getArgOperand(0); assert(isa(conv) && "Expected a const-to-gen conversion"); - const CallInst *convcall = cast(conv); - const Value *str = convcall->getArgOperand(0); + const CallInst *ConvCall = cast(conv); + const Value *str = ConvCall->getArgOperand(0); assert(isa(str) && "Format of _reflect function not recognized"); - const ConstantExpr *gep = cast(str); + const ConstantExpr *GEP = cast(str); - const Value *sym = gep->getOperand(0); - assert(isa(sym) && "Format of _reflect function not recognized"); + const Value *Sym = GEP->getOperand(0); + assert(isa(Sym) && "Format of _reflect function not recognized"); - const Constant *symstr = cast(sym); + const Constant *SymStr = cast(Sym); - assert(isa(symstr->getOperand(0)) && + assert(isa(SymStr->getOperand(0)) && "Format of _reflect function not recognized"); - assert(cast(symstr->getOperand(0))->isCString() && + assert(cast(SymStr->getOperand(0))->isCString() && "Format of _reflect function not recognized"); - std::string reflectArg = - cast(symstr->getOperand(0))->getAsString(); + std::string ReflectArg = + cast(SymStr->getOperand(0))->getAsString(); - reflectArg = reflectArg.substr(0, reflectArg.size() - 1); - // DEBUG(dbgs() << "Arg of _reflect : " << reflectArg << std::endl); + ReflectArg = ReflectArg.substr(0, ReflectArg.size() - 1); + DEBUG(dbgs() << "Arg of _reflect : " << ReflectArg << "\n"); - int reflectVal = 0; // The default value is 0 - if (VarMap.find(reflectArg) != VarMap.end()) { - reflectVal = VarMap[reflectArg]; + int ReflectVal = 0; // The default value is 0 + if (VarMap.find(ReflectArg) != VarMap.end()) { + ReflectVal = VarMap[ReflectArg]; } - reflect->replaceAllUsesWith( - ConstantInt::get(reflect->getType(), reflectVal)); - toRemove.push_back(reflect); + Reflect->replaceAllUsesWith( + ConstantInt::get(Reflect->getType(), ReflectVal)); + ToRemove.push_back(Reflect); } - if (toRemove.size() == 0) + if (ToRemove.size() == 0) return false; - for (unsigned i = 0, e = toRemove.size(); i != e; ++i) - toRemove[i]->eraseFromParent(); + for (unsigned i = 0, e = ToRemove.size(); i != e; ++i) + ToRemove[i]->eraseFromParent(); return true; }