X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=utils%2FTableGen%2FIntrinsicEmitter.cpp;h=7883e7ca655d9c91c8606a586616f9cf6b0886d8;hb=41474baac839da410302950305722cb0e026a094;hp=f7d852d725b034becbf94845da58085405dd68b3;hpb=81442c0d832872c8f50ec72aeaf937e06d8f3dfb;p=oota-llvm.git diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp index f7d852d725b..7883e7ca655 100644 --- a/utils/TableGen/IntrinsicEmitter.cpp +++ b/utils/TableGen/IntrinsicEmitter.cpp @@ -114,9 +114,9 @@ EmitIntrinsicToNameTable(const std::vector &Ints, OS << "#endif\n\n"; } -static void EmitTypeForValueType(std::ostream &OS, MVT::ValueType VT) { - if (MVT::isInteger(VT)) { - unsigned BitWidth = MVT::getSizeInBits(VT); +static void EmitTypeForValueType(std::ostream &OS, MVT::SimpleValueType VT) { + if (MVT(VT).isInteger()) { + unsigned BitWidth = MVT(VT).getSizeInBits(); OS << "IntegerType::get(" << BitWidth << ")"; } else if (VT == MVT::Other) { // MVT::OtherVT is used to mean the empty struct type here. @@ -138,9 +138,31 @@ static void EmitTypeForValueType(std::ostream &OS, MVT::ValueType VT) { } } -static void EmitTypeGenerate(std::ostream &OS, Record *ArgType, +static void EmitTypeGenerate(std::ostream &OS, const Record *ArgType, + unsigned &ArgNo); + +static void EmitTypeGenerate(std::ostream &OS, + const std::vector &ArgTypes, + unsigned &ArgNo) { + if (ArgTypes.size() == 1) { + EmitTypeGenerate(OS, ArgTypes.front(), ArgNo); + return; + } + + OS << "StructType::get("; + + for (std::vector::const_iterator + I = ArgTypes.begin(), E = ArgTypes.end(); I != E; ++I) { + EmitTypeGenerate(OS, *I, ArgNo); + OS << ", "; + } + + OS << " NULL)"; +} + +static void EmitTypeGenerate(std::ostream &OS, const Record *ArgType, unsigned &ArgNo) { - MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT")); + MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT")); if (ArgType->isSubClassOf("LLVMMatchType")) { unsigned Number = ArgType->getValueAsInt("Number"); @@ -153,14 +175,23 @@ static void EmitTypeGenerate(std::ostream &OS, Record *ArgType, // increment it when we actually hit an overloaded type. Getting this wrong // leads to very subtle bugs! OS << "Tys[" << ArgNo++ << "]"; - } else if (MVT::isVector(VT)) { + } else if (MVT(VT).isVector()) { + MVT VVT = VT; OS << "VectorType::get("; - EmitTypeForValueType(OS, MVT::getVectorElementType(VT)); - OS << ", " << MVT::getVectorNumElements(VT) << ")"; + EmitTypeForValueType(OS, VVT.getVectorElementType().getSimpleVT()); + OS << ", " << VVT.getVectorNumElements() << ")"; } else if (VT == MVT::iPTR) { OS << "PointerType::getUnqual("; EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo); OS << ")"; + } else if (VT == MVT::iPTRAny) { + // Make sure the user has passed us an argument type to overload. If not, + // treat it as an ordinary (not overloaded) intrinsic. + OS << "(" << ArgNo << " < numTys) ? Tys[" << ArgNo + << "] : PointerType::getUnqual("; + EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo); + OS << ")"; + ++ArgNo; } else if (VT == MVT::isVoid) { if (ArgNo == 0) OS << "Type::VoidTy"; @@ -175,17 +206,37 @@ static void EmitTypeGenerate(std::ostream &OS, Record *ArgType, /// RecordListComparator - Provide a determinstic comparator for lists of /// records. namespace { + typedef std::pair, std::vector > RecPair; struct RecordListComparator { - bool operator()(const std::vector &LHS, - const std::vector &RHS) const { + bool operator()(const RecPair &LHS, + const RecPair &RHS) const { unsigned i = 0; + const std::vector *LHSVec = &LHS.first; + const std::vector *RHSVec = &RHS.first; + unsigned RHSSize = RHSVec->size(); + unsigned LHSSize = LHSVec->size(); + do { - if (i == RHS.size()) return false; // RHS is shorter than LHS. - if (LHS[i] != RHS[i]) - return LHS[i]->getName() < RHS[i]->getName(); - } while (++i != LHS.size()); - - return i != RHS.size(); + if (i == RHSSize) return false; // RHS is shorter than LHS. + if ((*LHSVec)[i] != (*RHSVec)[i]) + return (*LHSVec)[i]->getName() < (*RHSVec)[i]->getName(); + } while (++i != LHSSize); + + if (i != RHSSize) return true; + + i = 0; + LHSVec = &LHS.second; + RHSVec = &RHS.second; + RHSSize = RHSVec->size(); + LHSSize = LHSVec->size(); + + for (i = 0; i != LHSSize; ++i) { + if (i == RHSSize) return false; // RHS is shorter than LHS. + if ((*LHSVec)[i] != (*RHSVec)[i]) + return (*LHSVec)[i]->getName() < (*RHSVec)[i]->getName(); + } + + return i != RHSSize; } }; } @@ -200,38 +251,62 @@ void IntrinsicEmitter::EmitVerifier(const std::vector &Ints, // This checking can emit a lot of very common code. To reduce the amount of // code that we emit, batch up cases that have identical types. This avoids // problems where GCC can run out of memory compiling Verifier.cpp. - typedef std::map, std::vector, - RecordListComparator> MapTy; + typedef std::map, RecordListComparator> MapTy; MapTy UniqueArgInfos; // Compute the unique argument type info. for (unsigned i = 0, e = Ints.size(); i != e; ++i) - UniqueArgInfos[Ints[i].ArgTypeDefs].push_back(i); + UniqueArgInfos[make_pair(Ints[i].IS.RetTypeDefs, + Ints[i].IS.ParamTypeDefs)].push_back(i); // Loop through the array, emitting one comparison for each batch. for (MapTy::iterator I = UniqueArgInfos.begin(), E = UniqueArgInfos.end(); I != E; ++I) { - for (unsigned i = 0, e = I->second.size(); i != e; ++i) { + for (unsigned i = 0, e = I->second.size(); i != e; ++i) OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// " << Ints[I->second[i]].Name << "\n"; - } - const std::vector &ArgTypes = I->first; - OS << " VerifyIntrinsicPrototype(ID, IF, " << ArgTypes.size() << ", "; - for (unsigned j = 0; j != ArgTypes.size(); ++j) { - Record *ArgType = ArgTypes[j]; + const RecPair &ArgTypes = I->first; + const std::vector &RetTys = ArgTypes.first; + const std::vector &ParamTys = ArgTypes.second; + + OS << " VerifyIntrinsicPrototype(ID, IF, " << RetTys.size() << ", " + << ParamTys.size(); + + // Emit return types. + for (unsigned j = 0, je = RetTys.size(); j != je; ++j) { + Record *ArgType = RetTys[j]; + OS << ", "; + if (ArgType->isSubClassOf("LLVMMatchType")) { unsigned Number = ArgType->getValueAsInt("Number"); assert(Number < j && "Invalid matching number!"); OS << "~" << Number; } else { - MVT::ValueType VT = getValueType(ArgType->getValueAsDef("VT")); + MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT")); OS << getEnumName(VT); - if (VT == MVT::isVoid && j != 0 && j != ArgTypes.size()-1) + + if (VT == MVT::isVoid && j != 0 && j != je - 1) + throw "Var arg type not last argument"; + } + } + + // Emit the parameter types. + for (unsigned j = 0, je = ParamTys.size(); j != je; ++j) { + Record *ArgType = ParamTys[j]; + OS << ", "; + + if (ArgType->isSubClassOf("LLVMMatchType")) { + unsigned Number = ArgType->getValueAsInt("Number"); + assert(Number < j + RetTys.size() && "Invalid matching number!"); + OS << "~" << Number; + } else { + MVT::SimpleValueType VT = getValueType(ArgType->getValueAsDef("VT")); + OS << getEnumName(VT); + + if (VT == MVT::isVoid && j != 0 && j != je - 1) throw "Var arg type not last argument"; } - if (j != ArgTypes.size()-1) - OS << ", "; } OS << ");\n"; @@ -250,43 +325,47 @@ void IntrinsicEmitter::EmitGenerator(const std::vector &Ints, // Similar to GET_INTRINSIC_VERIFIER, batch up cases that have identical // types. - typedef std::map, std::vector, - RecordListComparator> MapTy; + typedef std::map, RecordListComparator> MapTy; MapTy UniqueArgInfos; // Compute the unique argument type info. for (unsigned i = 0, e = Ints.size(); i != e; ++i) - UniqueArgInfos[Ints[i].ArgTypeDefs].push_back(i); + UniqueArgInfos[make_pair(Ints[i].IS.RetTypeDefs, + Ints[i].IS.ParamTypeDefs)].push_back(i); // Loop through the array, emitting one generator for each batch. for (MapTy::iterator I = UniqueArgInfos.begin(), E = UniqueArgInfos.end(); I != E; ++I) { - for (unsigned i = 0, e = I->second.size(); i != e; ++i) { + for (unsigned i = 0, e = I->second.size(); i != e; ++i) OS << " case Intrinsic::" << Ints[I->second[i]].EnumName << ":\t\t// " << Ints[I->second[i]].Name << "\n"; - } - const std::vector &ArgTypes = I->first; - unsigned N = ArgTypes.size(); + const RecPair &ArgTypes = I->first; + const std::vector &RetTys = ArgTypes.first; + const std::vector &ParamTys = ArgTypes.second; + + unsigned N = ParamTys.size(); if (N > 1 && - getValueType(ArgTypes[N-1]->getValueAsDef("VT")) == MVT::isVoid) { + getValueType(ParamTys[N - 1]->getValueAsDef("VT")) == MVT::isVoid) { OS << " IsVarArg = true;\n"; --N; } - + unsigned ArgNo = 0; OS << " ResultTy = "; - EmitTypeGenerate(OS, ArgTypes[0], ArgNo); + EmitTypeGenerate(OS, RetTys, ArgNo); OS << ";\n"; - for (unsigned j = 1; j != N; ++j) { + for (unsigned j = 0; j != N; ++j) { OS << " ArgTys.push_back("; - EmitTypeGenerate(OS, ArgTypes[j], ArgNo); + EmitTypeGenerate(OS, ParamTys[j], ArgNo); OS << ");\n"; } + OS << " break;\n"; } + OS << " }\n"; OS << "#endif\n\n"; } @@ -305,7 +384,7 @@ EmitAttributes(const std::vector &Ints, std::ostream &OS) { break; } } - OS << " Attr |= ParamAttr::ReadNone; // These do not access memory.\n"; + OS << " Attr |= Attribute::ReadNone; // These do not access memory.\n"; OS << " break;\n"; for (unsigned i = 0, e = Ints.size(); i != e; ++i) { switch (Ints[i].ModRef) { @@ -316,7 +395,7 @@ EmitAttributes(const std::vector &Ints, std::ostream &OS) { break; } } - OS << " Attr |= ParamAttr::ReadOnly; // These do not write memory.\n"; + OS << " Attr |= Attribute::ReadOnly; // These do not write memory.\n"; OS << " break;\n"; OS << " }\n"; OS << "#endif\n\n"; @@ -338,6 +417,112 @@ EmitGCCBuiltinList(const std::vector &Ints, std::ostream &OS){ OS << "#endif\n\n"; } +/// EmitBuiltinComparisons - Emit comparisons to determine whether the specified +/// sorted range of builtin names is equal to the current builtin. This breaks +/// it down into a simple tree. +/// +/// At this point, we know that all the builtins in the range have the same name +/// for the first 'CharStart' characters. Only the end of the name needs to be +/// discriminated. +typedef std::map::const_iterator StrMapIterator; +static void EmitBuiltinComparisons(StrMapIterator Start, StrMapIterator End, + unsigned CharStart, unsigned Indent, + std::ostream &OS) { + if (Start == End) return; // empty range. + + // Determine what, if anything, is the same about all these strings. + std::string CommonString = Start->first; + unsigned NumInRange = 0; + for (StrMapIterator I = Start; I != End; ++I, ++NumInRange) { + // Find the first character that doesn't match. + const std::string &ThisStr = I->first; + unsigned NonMatchChar = CharStart; + while (NonMatchChar < CommonString.size() && + NonMatchChar < ThisStr.size() && + CommonString[NonMatchChar] == ThisStr[NonMatchChar]) + ++NonMatchChar; + // Truncate off pieces that don't match. + CommonString.resize(NonMatchChar); + } + + // Just compare the rest of the string. + if (NumInRange == 1) { + if (CharStart != CommonString.size()) { + OS << std::string(Indent*2, ' ') << "if (!memcmp(BuiltinName"; + if (CharStart) OS << "+" << CharStart; + OS << ", \"" << (CommonString.c_str()+CharStart) << "\", "; + OS << CommonString.size() - CharStart << "))\n"; + ++Indent; + } + OS << std::string(Indent*2, ' ') << "IntrinsicID = Intrinsic::"; + OS << Start->second << ";\n"; + return; + } + + // At this point, we potentially have a common prefix for these builtins, emit + // a check for this common prefix. + if (CommonString.size() != CharStart) { + OS << std::string(Indent*2, ' ') << "if (!memcmp(BuiltinName"; + if (CharStart) OS << "+" << CharStart; + OS << ", \"" << (CommonString.c_str()+CharStart) << "\", "; + OS << CommonString.size()-CharStart << ")) {\n"; + + EmitBuiltinComparisons(Start, End, CommonString.size(), Indent+1, OS); + OS << std::string(Indent*2, ' ') << "}\n"; + return; + } + + // Output a switch on the character that differs across the set. + OS << std::string(Indent*2, ' ') << "switch (BuiltinName[" << CharStart + << "]) {"; + if (CharStart) + OS << " // \"" << std::string(Start->first.begin(), + Start->first.begin()+CharStart) << "\""; + OS << "\n"; + + for (StrMapIterator I = Start; I != End; ) { + char ThisChar = I->first[CharStart]; + OS << std::string(Indent*2, ' ') << "case '" << ThisChar << "':\n"; + // Figure out the range that has this common character. + StrMapIterator NextChar = I; + for (++NextChar; NextChar != End && NextChar->first[CharStart] == ThisChar; + ++NextChar) + /*empty*/; + EmitBuiltinComparisons(I, NextChar, CharStart+1, Indent+1, OS); + OS << std::string(Indent*2, ' ') << " break;\n"; + I = NextChar; + } + OS << std::string(Indent*2, ' ') << "}\n"; +} + +/// EmitTargetBuiltins - All of the builtins in the specified map are for the +/// same target, and we already checked it. +static void EmitTargetBuiltins(const std::map &BIM, + std::ostream &OS) { + // Rearrange the builtins by length. + std::vector > BuiltinsByLen; + BuiltinsByLen.reserve(100); + + for (StrMapIterator I = BIM.begin(), E = BIM.end(); I != E; ++I) { + if (I->first.size() >= BuiltinsByLen.size()) + BuiltinsByLen.resize(I->first.size()+1); + BuiltinsByLen[I->first.size()].insert(*I); + } + + // Now that we have all the builtins by their length, emit a switch stmt. + OS << " switch (strlen(BuiltinName)) {\n"; + OS << " default: break;\n"; + for (unsigned i = 0, e = BuiltinsByLen.size(); i != e; ++i) { + if (BuiltinsByLen[i].empty()) continue; + OS << " case " << i << ":\n"; + EmitBuiltinComparisons(BuiltinsByLen[i].begin(), BuiltinsByLen[i].end(), + 0, 3, OS); + OS << " break;\n"; + } + OS << " }\n"; +} + + void IntrinsicEmitter:: EmitIntrinsicToGCCBuiltinMap(const std::vector &Ints, std::ostream &OS) { @@ -361,6 +546,7 @@ EmitIntrinsicToGCCBuiltinMap(const std::vector &Ints, OS << "// in as TargetPrefix. The result is assigned to 'IntrinsicID'.\n"; OS << "#ifdef GET_LLVM_INTRINSIC_FOR_GCC_BUILTIN\n"; OS << " IntrinsicID = Intrinsic::not_intrinsic;\n"; + // Note: this could emit significantly better code if we cared. for (BIMTy::iterator I = BuiltinMap.begin(), E = BuiltinMap.end();I != E;++I){ OS << " "; @@ -370,15 +556,8 @@ EmitIntrinsicToGCCBuiltinMap(const std::vector &Ints, OS << "/* Target Independent Builtins */ "; OS << "{\n"; - OS << " if (0);\n"; - // Emit the comparisons for this target prefix. - std::map &BIM = I->second; - for (std::map::iterator J = BIM.begin(), - E = BIM.end(); J != E; ++J) { - OS << " else if (!strcmp(BuiltinName, \"" << J->first << "\"))\n"; - OS << " IntrinsicID = Intrinsic::" << J->second << ";\n"; - } + EmitTargetBuiltins(I->second, OS); OS << " }\n"; } OS << "#endif\n\n";