Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1 | //===-- LLParser.cpp - Parser Class ---------------------------------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file defines the parser class for .ll files. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "LLParser.h" |
| 15 | #include "llvm/AutoUpgrade.h" |
| 16 | #include "llvm/CallingConv.h" |
| 17 | #include "llvm/Constants.h" |
| 18 | #include "llvm/DerivedTypes.h" |
| 19 | #include "llvm/InlineAsm.h" |
| 20 | #include "llvm/Instructions.h" |
| 21 | #include "llvm/Module.h" |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 22 | #include "llvm/Operator.h" |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 23 | #include "llvm/ValueSymbolTable.h" |
| 24 | #include "llvm/ADT/SmallPtrSet.h" |
| 25 | #include "llvm/ADT/StringExtras.h" |
Torok Edwin | c25e758 | 2009-07-11 20:10:48 +0000 | [diff] [blame] | 26 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 27 | #include "llvm/Support/raw_ostream.h" |
| 28 | using namespace llvm; |
| 29 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 30 | /// Run: module ::= toplevelentity* |
Chris Lattner | ad7d1e2 | 2009-01-04 20:44:11 +0000 | [diff] [blame] | 31 | bool LLParser::Run() { |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 32 | // Prime the lexer. |
| 33 | Lex.Lex(); |
| 34 | |
Chris Lattner | ad7d1e2 | 2009-01-04 20:44:11 +0000 | [diff] [blame] | 35 | return ParseTopLevelEntities() || |
| 36 | ValidateEndOfModule(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 37 | } |
| 38 | |
| 39 | /// ValidateEndOfModule - Do final validity and sanity checks at the end of the |
| 40 | /// module. |
| 41 | bool LLParser::ValidateEndOfModule() { |
Victor Hernandez | 68afa54 | 2009-10-21 19:11:40 +0000 | [diff] [blame] | 42 | // Update auto-upgraded malloc calls to "malloc". |
Chris Lattner | cf4d2f1 | 2009-10-18 05:09:15 +0000 | [diff] [blame] | 43 | // FIXME: Remove in LLVM 3.0. |
Victor Hernandez | 13ad5aa | 2009-10-17 00:00:19 +0000 | [diff] [blame] | 44 | if (MallocF) { |
| 45 | MallocF->setName("malloc"); |
| 46 | // If setName() does not set the name to "malloc", then there is already a |
| 47 | // declaration of "malloc". In that case, iterate over all calls to MallocF |
| 48 | // and get them to call the declared "malloc" instead. |
| 49 | if (MallocF->getName() != "malloc") { |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 50 | Constant *RealMallocF = M->getFunction("malloc"); |
Victor Hernandez | 68afa54 | 2009-10-21 19:11:40 +0000 | [diff] [blame] | 51 | if (RealMallocF->getType() != MallocF->getType()) |
| 52 | RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType()); |
| 53 | MallocF->replaceAllUsesWith(RealMallocF); |
Victor Hernandez | 13ad5aa | 2009-10-17 00:00:19 +0000 | [diff] [blame] | 54 | MallocF->eraseFromParent(); |
| 55 | MallocF = NULL; |
| 56 | } |
| 57 | } |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 58 | |
| 59 | |
| 60 | // If there are entries in ForwardRefBlockAddresses at this point, they are |
| 61 | // references after the function was defined. Resolve those now. |
| 62 | while (!ForwardRefBlockAddresses.empty()) { |
| 63 | // Okay, we are referencing an already-parsed function, resolve them now. |
| 64 | Function *TheFn = 0; |
| 65 | const ValID &Fn = ForwardRefBlockAddresses.begin()->first; |
| 66 | if (Fn.Kind == ValID::t_GlobalName) |
| 67 | TheFn = M->getFunction(Fn.StrVal); |
| 68 | else if (Fn.UIntVal < NumberedVals.size()) |
| 69 | TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]); |
| 70 | |
| 71 | if (TheFn == 0) |
| 72 | return Error(Fn.Loc, "unknown function referenced by blockaddress"); |
| 73 | |
| 74 | // Resolve all these references. |
| 75 | if (ResolveForwardRefBlockAddresses(TheFn, |
| 76 | ForwardRefBlockAddresses.begin()->second, |
| 77 | 0)) |
| 78 | return true; |
| 79 | |
| 80 | ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin()); |
| 81 | } |
| 82 | |
| 83 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 84 | if (!ForwardRefTypes.empty()) |
| 85 | return Error(ForwardRefTypes.begin()->second.second, |
| 86 | "use of undefined type named '" + |
| 87 | ForwardRefTypes.begin()->first + "'"); |
| 88 | if (!ForwardRefTypeIDs.empty()) |
| 89 | return Error(ForwardRefTypeIDs.begin()->second.second, |
| 90 | "use of undefined type '%" + |
| 91 | utostr(ForwardRefTypeIDs.begin()->first) + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 92 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 93 | if (!ForwardRefVals.empty()) |
| 94 | return Error(ForwardRefVals.begin()->second.second, |
| 95 | "use of undefined value '@" + ForwardRefVals.begin()->first + |
| 96 | "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 97 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 98 | if (!ForwardRefValIDs.empty()) |
| 99 | return Error(ForwardRefValIDs.begin()->second.second, |
| 100 | "use of undefined value '@" + |
| 101 | utostr(ForwardRefValIDs.begin()->first) + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 102 | |
Devang Patel | 1c7eea6 | 2009-07-08 19:23:54 +0000 | [diff] [blame] | 103 | if (!ForwardRefMDNodes.empty()) |
| 104 | return Error(ForwardRefMDNodes.begin()->second.second, |
| 105 | "use of undefined metadata '!" + |
| 106 | utostr(ForwardRefMDNodes.begin()->first) + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 107 | |
Devang Patel | 1c7eea6 | 2009-07-08 19:23:54 +0000 | [diff] [blame] | 108 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 109 | // Look for intrinsic functions and CallInst that need to be upgraded |
| 110 | for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) |
| 111 | UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 112 | |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 113 | // Check debug info intrinsics. |
| 114 | CheckDebugInfoIntrinsics(M); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 115 | return false; |
| 116 | } |
| 117 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 118 | bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn, |
| 119 | std::vector<std::pair<ValID, GlobalValue*> > &Refs, |
| 120 | PerFunctionState *PFS) { |
| 121 | // Loop over all the references, resolving them. |
| 122 | for (unsigned i = 0, e = Refs.size(); i != e; ++i) { |
| 123 | BasicBlock *Res; |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 124 | if (PFS) { |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 125 | if (Refs[i].first.Kind == ValID::t_LocalName) |
| 126 | Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc); |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 127 | else |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 128 | Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc); |
| 129 | } else if (Refs[i].first.Kind == ValID::t_LocalID) { |
| 130 | return Error(Refs[i].first.Loc, |
Chris Lattner | ee7644d | 2009-11-02 18:28:45 +0000 | [diff] [blame] | 131 | "cannot take address of numeric label after the function is defined"); |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 132 | } else { |
| 133 | Res = dyn_cast_or_null<BasicBlock>( |
| 134 | TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal)); |
| 135 | } |
| 136 | |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 137 | if (Res == 0) |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 138 | return Error(Refs[i].first.Loc, |
| 139 | "referenced value is not a basic block"); |
| 140 | |
| 141 | // Get the BlockAddress for this and update references to use it. |
| 142 | BlockAddress *BA = BlockAddress::get(TheFn, Res); |
| 143 | Refs[i].second->replaceAllUsesWith(BA); |
| 144 | Refs[i].second->eraseFromParent(); |
| 145 | } |
| 146 | return false; |
| 147 | } |
| 148 | |
| 149 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 150 | //===----------------------------------------------------------------------===// |
| 151 | // Top-Level Entities |
| 152 | //===----------------------------------------------------------------------===// |
| 153 | |
| 154 | bool LLParser::ParseTopLevelEntities() { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 155 | while (1) { |
| 156 | switch (Lex.getKind()) { |
| 157 | default: return TokError("expected top-level entity"); |
| 158 | case lltok::Eof: return false; |
| 159 | //case lltok::kw_define: |
| 160 | case lltok::kw_declare: if (ParseDeclare()) return true; break; |
| 161 | case lltok::kw_define: if (ParseDefine()) return true; break; |
| 162 | case lltok::kw_module: if (ParseModuleAsm()) return true; break; |
| 163 | case lltok::kw_target: if (ParseTargetDefinition()) return true; break; |
| 164 | case lltok::kw_deplibs: if (ParseDepLibs()) return true; break; |
| 165 | case lltok::kw_type: if (ParseUnnamedType()) return true; break; |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 166 | case lltok::LocalVarID: if (ParseUnnamedType()) return true; break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 167 | case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 |
| 168 | case lltok::LocalVar: if (ParseNamedType()) return true; break; |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 169 | case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 170 | case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break; |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 171 | case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break; |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 172 | case lltok::MetadataVar: if (ParseNamedMetadata()) return true; break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 173 | |
| 174 | // The Global variable production with no name can have many different |
| 175 | // optional leading prefixes, the production is: |
| 176 | // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal |
| 177 | // OptionalAddrSpace ('constant'|'global') ... |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 178 | case lltok::kw_private : // OptionalLinkage |
| 179 | case lltok::kw_linker_private: // OptionalLinkage |
| 180 | case lltok::kw_internal: // OptionalLinkage |
| 181 | case lltok::kw_weak: // OptionalLinkage |
| 182 | case lltok::kw_weak_odr: // OptionalLinkage |
| 183 | case lltok::kw_linkonce: // OptionalLinkage |
| 184 | case lltok::kw_linkonce_odr: // OptionalLinkage |
| 185 | case lltok::kw_appending: // OptionalLinkage |
| 186 | case lltok::kw_dllexport: // OptionalLinkage |
| 187 | case lltok::kw_common: // OptionalLinkage |
| 188 | case lltok::kw_dllimport: // OptionalLinkage |
| 189 | case lltok::kw_extern_weak: // OptionalLinkage |
| 190 | case lltok::kw_external: { // OptionalLinkage |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 191 | unsigned Linkage, Visibility; |
| 192 | if (ParseOptionalLinkage(Linkage) || |
| 193 | ParseOptionalVisibility(Visibility) || |
Chris Lattner | eeb4a84 | 2009-07-02 23:08:13 +0000 | [diff] [blame] | 194 | ParseGlobal("", SMLoc(), Linkage, true, Visibility)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 195 | return true; |
| 196 | break; |
| 197 | } |
| 198 | case lltok::kw_default: // OptionalVisibility |
| 199 | case lltok::kw_hidden: // OptionalVisibility |
| 200 | case lltok::kw_protected: { // OptionalVisibility |
| 201 | unsigned Visibility; |
| 202 | if (ParseOptionalVisibility(Visibility) || |
Chris Lattner | eeb4a84 | 2009-07-02 23:08:13 +0000 | [diff] [blame] | 203 | ParseGlobal("", SMLoc(), 0, false, Visibility)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 204 | return true; |
| 205 | break; |
| 206 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 207 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 208 | case lltok::kw_thread_local: // OptionalThreadLocal |
| 209 | case lltok::kw_addrspace: // OptionalAddrSpace |
| 210 | case lltok::kw_constant: // GlobalType |
| 211 | case lltok::kw_global: // GlobalType |
Chris Lattner | eeb4a84 | 2009-07-02 23:08:13 +0000 | [diff] [blame] | 212 | if (ParseGlobal("", SMLoc(), 0, false, 0)) return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 213 | break; |
| 214 | } |
| 215 | } |
| 216 | } |
| 217 | |
| 218 | |
| 219 | /// toplevelentity |
| 220 | /// ::= 'module' 'asm' STRINGCONSTANT |
| 221 | bool LLParser::ParseModuleAsm() { |
| 222 | assert(Lex.getKind() == lltok::kw_module); |
| 223 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 224 | |
| 225 | std::string AsmStr; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 226 | if (ParseToken(lltok::kw_asm, "expected 'module asm'") || |
| 227 | ParseStringConstant(AsmStr)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 228 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 229 | const std::string &AsmSoFar = M->getModuleInlineAsm(); |
| 230 | if (AsmSoFar.empty()) |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 231 | M->setModuleInlineAsm(AsmStr); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 232 | else |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 233 | M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 234 | return false; |
| 235 | } |
| 236 | |
| 237 | /// toplevelentity |
| 238 | /// ::= 'target' 'triple' '=' STRINGCONSTANT |
| 239 | /// ::= 'target' 'datalayout' '=' STRINGCONSTANT |
| 240 | bool LLParser::ParseTargetDefinition() { |
| 241 | assert(Lex.getKind() == lltok::kw_target); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 242 | std::string Str; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 243 | switch (Lex.Lex()) { |
| 244 | default: return TokError("unknown target property"); |
| 245 | case lltok::kw_triple: |
| 246 | Lex.Lex(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 247 | if (ParseToken(lltok::equal, "expected '=' after target triple") || |
| 248 | ParseStringConstant(Str)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 249 | return true; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 250 | M->setTargetTriple(Str); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 251 | return false; |
| 252 | case lltok::kw_datalayout: |
| 253 | Lex.Lex(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 254 | if (ParseToken(lltok::equal, "expected '=' after target datalayout") || |
| 255 | ParseStringConstant(Str)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 256 | return true; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 257 | M->setDataLayout(Str); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 258 | return false; |
| 259 | } |
| 260 | } |
| 261 | |
| 262 | /// toplevelentity |
| 263 | /// ::= 'deplibs' '=' '[' ']' |
| 264 | /// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']' |
| 265 | bool LLParser::ParseDepLibs() { |
| 266 | assert(Lex.getKind() == lltok::kw_deplibs); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 267 | Lex.Lex(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 268 | if (ParseToken(lltok::equal, "expected '=' after deplibs") || |
| 269 | ParseToken(lltok::lsquare, "expected '=' after deplibs")) |
| 270 | return true; |
| 271 | |
| 272 | if (EatIfPresent(lltok::rsquare)) |
| 273 | return false; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 274 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 275 | std::string Str; |
| 276 | if (ParseStringConstant(Str)) return true; |
| 277 | M->addLibrary(Str); |
| 278 | |
| 279 | while (EatIfPresent(lltok::comma)) { |
| 280 | if (ParseStringConstant(Str)) return true; |
| 281 | M->addLibrary(Str); |
| 282 | } |
| 283 | |
| 284 | return ParseToken(lltok::rsquare, "expected ']' at end of list"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 285 | } |
| 286 | |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 287 | /// ParseUnnamedType: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 288 | /// ::= 'type' type |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 289 | /// ::= LocalVarID '=' 'type' type |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 290 | bool LLParser::ParseUnnamedType() { |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 291 | unsigned TypeID = NumberedTypes.size(); |
| 292 | |
| 293 | // Handle the LocalVarID form. |
| 294 | if (Lex.getKind() == lltok::LocalVarID) { |
| 295 | if (Lex.getUIntVal() != TypeID) |
| 296 | return Error(Lex.getLoc(), "type expected to be numbered '%" + |
| 297 | utostr(TypeID) + "'"); |
| 298 | Lex.Lex(); // eat LocalVarID; |
| 299 | |
| 300 | if (ParseToken(lltok::equal, "expected '=' after name")) |
| 301 | return true; |
| 302 | } |
| 303 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 304 | assert(Lex.getKind() == lltok::kw_type); |
| 305 | LocTy TypeLoc = Lex.getLoc(); |
| 306 | Lex.Lex(); // eat kw_type |
| 307 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 308 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 309 | if (ParseType(Ty)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 310 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 311 | // See if this type was previously referenced. |
| 312 | std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator |
| 313 | FI = ForwardRefTypeIDs.find(TypeID); |
| 314 | if (FI != ForwardRefTypeIDs.end()) { |
Chris Lattner | c38daba | 2009-01-05 18:19:46 +0000 | [diff] [blame] | 315 | if (FI->second.first.get() == Ty) |
| 316 | return Error(TypeLoc, "self referential type is invalid"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 317 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 318 | cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); |
| 319 | Ty = FI->second.first.get(); |
| 320 | ForwardRefTypeIDs.erase(FI); |
| 321 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 322 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 323 | NumberedTypes.push_back(Ty); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 324 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 325 | return false; |
| 326 | } |
| 327 | |
| 328 | /// toplevelentity |
| 329 | /// ::= LocalVar '=' 'type' type |
| 330 | bool LLParser::ParseNamedType() { |
| 331 | std::string Name = Lex.getStrVal(); |
| 332 | LocTy NameLoc = Lex.getLoc(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 333 | Lex.Lex(); // eat LocalVar. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 334 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 335 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 336 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 337 | if (ParseToken(lltok::equal, "expected '=' after name") || |
| 338 | ParseToken(lltok::kw_type, "expected 'type' after name") || |
| 339 | ParseType(Ty)) |
| 340 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 341 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 342 | // Set the type name, checking for conflicts as we do so. |
| 343 | bool AlreadyExists = M->addTypeName(Name, Ty); |
| 344 | if (!AlreadyExists) return false; |
| 345 | |
| 346 | // See if this type is a forward reference. We need to eagerly resolve |
| 347 | // types to allow recursive type redefinitions below. |
| 348 | std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator |
| 349 | FI = ForwardRefTypes.find(Name); |
| 350 | if (FI != ForwardRefTypes.end()) { |
Chris Lattner | c38daba | 2009-01-05 18:19:46 +0000 | [diff] [blame] | 351 | if (FI->second.first.get() == Ty) |
| 352 | return Error(NameLoc, "self referential type is invalid"); |
| 353 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 354 | cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); |
| 355 | Ty = FI->second.first.get(); |
| 356 | ForwardRefTypes.erase(FI); |
| 357 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 358 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 359 | // Inserting a name that is already defined, get the existing name. |
| 360 | const Type *Existing = M->getTypeByName(Name); |
| 361 | assert(Existing && "Conflict but no matching type?!"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 362 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 363 | // Otherwise, this is an attempt to redefine a type. That's okay if |
| 364 | // the redefinition is identical to the original. |
| 365 | // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0 |
| 366 | if (Existing == Ty) return false; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 367 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 368 | // Any other kind of (non-equivalent) redefinition is an error. |
| 369 | return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" + |
| 370 | Ty->getDescription() + "'"); |
| 371 | } |
| 372 | |
| 373 | |
| 374 | /// toplevelentity |
| 375 | /// ::= 'declare' FunctionHeader |
| 376 | bool LLParser::ParseDeclare() { |
| 377 | assert(Lex.getKind() == lltok::kw_declare); |
| 378 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 379 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 380 | Function *F; |
| 381 | return ParseFunctionHeader(F, false); |
| 382 | } |
| 383 | |
| 384 | /// toplevelentity |
| 385 | /// ::= 'define' FunctionHeader '{' ... |
| 386 | bool LLParser::ParseDefine() { |
| 387 | assert(Lex.getKind() == lltok::kw_define); |
| 388 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 389 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 390 | Function *F; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 391 | return ParseFunctionHeader(F, true) || |
| 392 | ParseFunctionBody(*F); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 393 | } |
| 394 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 395 | /// ParseGlobalType |
| 396 | /// ::= 'constant' |
| 397 | /// ::= 'global' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 398 | bool LLParser::ParseGlobalType(bool &IsConstant) { |
| 399 | if (Lex.getKind() == lltok::kw_constant) |
| 400 | IsConstant = true; |
| 401 | else if (Lex.getKind() == lltok::kw_global) |
| 402 | IsConstant = false; |
Duncan Sands | 35b5107 | 2009-02-10 16:24:55 +0000 | [diff] [blame] | 403 | else { |
| 404 | IsConstant = false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 405 | return TokError("expected 'global' or 'constant'"); |
Duncan Sands | 35b5107 | 2009-02-10 16:24:55 +0000 | [diff] [blame] | 406 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 407 | Lex.Lex(); |
| 408 | return false; |
| 409 | } |
| 410 | |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 411 | /// ParseUnnamedGlobal: |
| 412 | /// OptionalVisibility ALIAS ... |
| 413 | /// OptionalLinkage OptionalVisibility ... -> global variable |
| 414 | /// GlobalID '=' OptionalVisibility ALIAS ... |
| 415 | /// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable |
| 416 | bool LLParser::ParseUnnamedGlobal() { |
| 417 | unsigned VarID = NumberedVals.size(); |
| 418 | std::string Name; |
| 419 | LocTy NameLoc = Lex.getLoc(); |
| 420 | |
| 421 | // Handle the GlobalID form. |
| 422 | if (Lex.getKind() == lltok::GlobalID) { |
| 423 | if (Lex.getUIntVal() != VarID) |
| 424 | return Error(Lex.getLoc(), "variable expected to be numbered '%" + |
| 425 | utostr(VarID) + "'"); |
| 426 | Lex.Lex(); // eat GlobalID; |
| 427 | |
| 428 | if (ParseToken(lltok::equal, "expected '=' after name")) |
| 429 | return true; |
| 430 | } |
| 431 | |
| 432 | bool HasLinkage; |
| 433 | unsigned Linkage, Visibility; |
| 434 | if (ParseOptionalLinkage(Linkage, HasLinkage) || |
| 435 | ParseOptionalVisibility(Visibility)) |
| 436 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 437 | |
Dan Gohman | 3845e50 | 2009-08-12 23:32:33 +0000 | [diff] [blame] | 438 | if (HasLinkage || Lex.getKind() != lltok::kw_alias) |
| 439 | return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); |
| 440 | return ParseAlias(Name, NameLoc, Visibility); |
| 441 | } |
| 442 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 443 | /// ParseNamedGlobal: |
| 444 | /// GlobalVar '=' OptionalVisibility ALIAS ... |
| 445 | /// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable |
| 446 | bool LLParser::ParseNamedGlobal() { |
| 447 | assert(Lex.getKind() == lltok::GlobalVar); |
| 448 | LocTy NameLoc = Lex.getLoc(); |
| 449 | std::string Name = Lex.getStrVal(); |
| 450 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 451 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 452 | bool HasLinkage; |
| 453 | unsigned Linkage, Visibility; |
| 454 | if (ParseToken(lltok::equal, "expected '=' in global variable") || |
| 455 | ParseOptionalLinkage(Linkage, HasLinkage) || |
| 456 | ParseOptionalVisibility(Visibility)) |
| 457 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 458 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 459 | if (HasLinkage || Lex.getKind() != lltok::kw_alias) |
| 460 | return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); |
| 461 | return ParseAlias(Name, NameLoc, Visibility); |
| 462 | } |
| 463 | |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 464 | // MDString: |
| 465 | // ::= '!' STRINGCONSTANT |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 466 | bool LLParser::ParseMDString(MDString *&Result) { |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 467 | std::string Str; |
| 468 | if (ParseStringConstant(Str)) return true; |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 469 | Result = MDString::get(Context, Str); |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 470 | return false; |
| 471 | } |
| 472 | |
| 473 | // MDNode: |
| 474 | // ::= '!' MDNodeNumber |
Chris Lattner | 4a72efc | 2009-12-30 04:15:23 +0000 | [diff] [blame] | 475 | bool LLParser::ParseMDNodeID(MDNode *&Result) { |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 476 | // !{ ..., !42, ... } |
| 477 | unsigned MID = 0; |
Chris Lattner | e80250e | 2009-12-29 21:43:58 +0000 | [diff] [blame] | 478 | if (ParseUInt32(MID)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 479 | |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 480 | // Check existing MDNode. |
Chris Lattner | 0834e6a | 2009-12-30 04:51:58 +0000 | [diff] [blame] | 481 | if (MID < NumberedMetadata.size() && NumberedMetadata[MID] != 0) { |
| 482 | Result = NumberedMetadata[MID]; |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 483 | return false; |
| 484 | } |
| 485 | |
Chris Lattner | 42991ee | 2009-12-29 22:01:50 +0000 | [diff] [blame] | 486 | // Create MDNode forward reference. |
| 487 | |
| 488 | // FIXME: This is not unique enough! |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 489 | std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID); |
Benjamin Kramer | c17300f | 2009-12-29 22:17:06 +0000 | [diff] [blame] | 490 | Value *V = MDString::get(Context, FwdRefName); |
Chris Lattner | 42991ee | 2009-12-29 22:01:50 +0000 | [diff] [blame] | 491 | MDNode *FwdNode = MDNode::get(Context, &V, 1); |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 492 | ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc()); |
Chris Lattner | 0834e6a | 2009-12-30 04:51:58 +0000 | [diff] [blame] | 493 | |
| 494 | if (NumberedMetadata.size() <= MID) |
| 495 | NumberedMetadata.resize(MID+1); |
| 496 | NumberedMetadata[MID] = FwdNode; |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 497 | Result = FwdNode; |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 498 | return false; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 499 | } |
Devang Patel | 256be96 | 2009-07-20 19:00:08 +0000 | [diff] [blame] | 500 | |
Chris Lattner | 84d03b1 | 2009-12-29 22:35:39 +0000 | [diff] [blame] | 501 | /// ParseNamedMetadata: |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 502 | /// !foo = !{ !1, !2 } |
| 503 | bool LLParser::ParseNamedMetadata() { |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 504 | assert(Lex.getKind() == lltok::MetadataVar); |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 505 | std::string Name = Lex.getStrVal(); |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 506 | Lex.Lex(); |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 507 | |
Chris Lattner | 84d03b1 | 2009-12-29 22:35:39 +0000 | [diff] [blame] | 508 | if (ParseToken(lltok::equal, "expected '=' here") || |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 509 | ParseToken(lltok::exclaim, "Expected '!' here") || |
Chris Lattner | 84d03b1 | 2009-12-29 22:35:39 +0000 | [diff] [blame] | 510 | ParseToken(lltok::lbrace, "Expected '{' here")) |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 511 | return true; |
| 512 | |
Devang Patel | 3e30c2a | 2010-01-05 20:41:31 +0000 | [diff] [blame] | 513 | SmallVector<MDNode *, 8> Elts; |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 514 | do { |
Devang Patel | 69d02e0 | 2010-01-05 21:47:32 +0000 | [diff] [blame] | 515 | // Null is a special case since it is typeless. |
| 516 | if (EatIfPresent(lltok::kw_null)) { |
| 517 | Elts.push_back(0); |
| 518 | continue; |
| 519 | } |
| 520 | |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 521 | if (ParseToken(lltok::exclaim, "Expected '!' here")) |
Chris Lattner | 42991ee | 2009-12-29 22:01:50 +0000 | [diff] [blame] | 522 | return true; |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 523 | |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 524 | MDNode *N = 0; |
Chris Lattner | 4a72efc | 2009-12-30 04:15:23 +0000 | [diff] [blame] | 525 | if (ParseMDNodeID(N)) return true; |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 526 | Elts.push_back(N); |
| 527 | } while (EatIfPresent(lltok::comma)); |
| 528 | |
| 529 | if (ParseToken(lltok::rbrace, "expected end of metadata node")) |
| 530 | return true; |
| 531 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 532 | NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M); |
Devang Patel | eff2ab6 | 2009-07-29 00:34:02 +0000 | [diff] [blame] | 533 | return false; |
| 534 | } |
| 535 | |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 536 | /// ParseStandaloneMetadata: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 537 | /// !42 = !{...} |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 538 | bool LLParser::ParseStandaloneMetadata() { |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 539 | assert(Lex.getKind() == lltok::exclaim); |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 540 | Lex.Lex(); |
| 541 | unsigned MetadataID = 0; |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 542 | |
| 543 | LocTy TyLoc; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 544 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Devang Patel | 104cf9e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 545 | SmallVector<Value *, 16> Elts; |
Chris Lattner | 3f5132a | 2009-12-29 22:40:21 +0000 | [diff] [blame] | 546 | if (ParseUInt32(MetadataID) || |
| 547 | ParseToken(lltok::equal, "expected '=' here") || |
| 548 | ParseType(Ty, TyLoc) || |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 549 | ParseToken(lltok::exclaim, "Expected '!' here") || |
Chris Lattner | 3f5132a | 2009-12-29 22:40:21 +0000 | [diff] [blame] | 550 | ParseToken(lltok::lbrace, "Expected '{' here") || |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 551 | ParseMDNodeVector(Elts, NULL) || |
Chris Lattner | 3f5132a | 2009-12-29 22:40:21 +0000 | [diff] [blame] | 552 | ParseToken(lltok::rbrace, "expected end of metadata node")) |
Devang Patel | 104cf9e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 553 | return true; |
| 554 | |
Owen Anderson | 647e301 | 2009-07-31 21:35:40 +0000 | [diff] [blame] | 555 | MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size()); |
Chris Lattner | 0834e6a | 2009-12-30 04:51:58 +0000 | [diff] [blame] | 556 | |
| 557 | // See if this was forward referenced, if so, handle it. |
Chris Lattner | e80250e | 2009-12-29 21:43:58 +0000 | [diff] [blame] | 558 | std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> >::iterator |
Devang Patel | 1c7eea6 | 2009-07-08 19:23:54 +0000 | [diff] [blame] | 559 | FI = ForwardRefMDNodes.find(MetadataID); |
| 560 | if (FI != ForwardRefMDNodes.end()) { |
Chris Lattner | e80250e | 2009-12-29 21:43:58 +0000 | [diff] [blame] | 561 | FI->second.first->replaceAllUsesWith(Init); |
Devang Patel | 1c7eea6 | 2009-07-08 19:23:54 +0000 | [diff] [blame] | 562 | ForwardRefMDNodes.erase(FI); |
Chris Lattner | 0834e6a | 2009-12-30 04:51:58 +0000 | [diff] [blame] | 563 | |
| 564 | assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work"); |
| 565 | } else { |
| 566 | if (MetadataID >= NumberedMetadata.size()) |
| 567 | NumberedMetadata.resize(MetadataID+1); |
| 568 | |
| 569 | if (NumberedMetadata[MetadataID] != 0) |
| 570 | return TokError("Metadata id is already used"); |
| 571 | NumberedMetadata[MetadataID] = Init; |
Devang Patel | 1c7eea6 | 2009-07-08 19:23:54 +0000 | [diff] [blame] | 572 | } |
| 573 | |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 574 | return false; |
| 575 | } |
| 576 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 577 | /// ParseAlias: |
| 578 | /// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee |
| 579 | /// Aliasee |
Chris Lattner | 040f758 | 2009-04-25 21:26:00 +0000 | [diff] [blame] | 580 | /// ::= TypeAndValue |
| 581 | /// ::= 'bitcast' '(' TypeAndValue 'to' Type ')' |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 582 | /// ::= 'getelementptr' 'inbounds'? '(' ... ')' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 583 | /// |
| 584 | /// Everything through visibility has already been parsed. |
| 585 | /// |
| 586 | bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, |
| 587 | unsigned Visibility) { |
| 588 | assert(Lex.getKind() == lltok::kw_alias); |
| 589 | Lex.Lex(); |
| 590 | unsigned Linkage; |
| 591 | LocTy LinkageLoc = Lex.getLoc(); |
| 592 | if (ParseOptionalLinkage(Linkage)) |
| 593 | return true; |
| 594 | |
| 595 | if (Linkage != GlobalValue::ExternalLinkage && |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 596 | Linkage != GlobalValue::WeakAnyLinkage && |
| 597 | Linkage != GlobalValue::WeakODRLinkage && |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 598 | Linkage != GlobalValue::InternalLinkage && |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 599 | Linkage != GlobalValue::PrivateLinkage && |
| 600 | Linkage != GlobalValue::LinkerPrivateLinkage) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 601 | return Error(LinkageLoc, "invalid linkage type for alias"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 602 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 603 | Constant *Aliasee; |
| 604 | LocTy AliaseeLoc = Lex.getLoc(); |
Chris Lattner | 040f758 | 2009-04-25 21:26:00 +0000 | [diff] [blame] | 605 | if (Lex.getKind() != lltok::kw_bitcast && |
| 606 | Lex.getKind() != lltok::kw_getelementptr) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 607 | if (ParseGlobalTypeAndValue(Aliasee)) return true; |
| 608 | } else { |
| 609 | // The bitcast dest type is not present, it is implied by the dest type. |
| 610 | ValID ID; |
| 611 | if (ParseValID(ID)) return true; |
| 612 | if (ID.Kind != ValID::t_Constant) |
| 613 | return Error(AliaseeLoc, "invalid aliasee"); |
| 614 | Aliasee = ID.ConstantVal; |
| 615 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 616 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 617 | if (!isa<PointerType>(Aliasee->getType())) |
| 618 | return Error(AliaseeLoc, "alias must have pointer type"); |
| 619 | |
| 620 | // Okay, create the alias but do not insert it into the module yet. |
| 621 | GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), |
| 622 | (GlobalValue::LinkageTypes)Linkage, Name, |
| 623 | Aliasee); |
| 624 | GA->setVisibility((GlobalValue::VisibilityTypes)Visibility); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 625 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 626 | // See if this value already exists in the symbol table. If so, it is either |
| 627 | // a redefinition or a definition of a forward reference. |
Chris Lattner | 1d871c5 | 2009-10-25 23:22:50 +0000 | [diff] [blame] | 628 | if (GlobalValue *Val = M->getNamedValue(Name)) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 629 | // See if this was a redefinition. If so, there is no entry in |
| 630 | // ForwardRefVals. |
| 631 | std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator |
| 632 | I = ForwardRefVals.find(Name); |
| 633 | if (I == ForwardRefVals.end()) |
| 634 | return Error(NameLoc, "redefinition of global named '@" + Name + "'"); |
| 635 | |
| 636 | // Otherwise, this was a definition of forward ref. Verify that types |
| 637 | // agree. |
| 638 | if (Val->getType() != GA->getType()) |
| 639 | return Error(NameLoc, |
| 640 | "forward reference and definition of alias have different types"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 641 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 642 | // If they agree, just RAUW the old value with the alias and remove the |
| 643 | // forward ref info. |
| 644 | Val->replaceAllUsesWith(GA); |
| 645 | Val->eraseFromParent(); |
| 646 | ForwardRefVals.erase(I); |
| 647 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 648 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 649 | // Insert into the module, we know its name won't collide now. |
| 650 | M->getAliasList().push_back(GA); |
| 651 | assert(GA->getNameStr() == Name && "Should not be a name conflict!"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 652 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 653 | return false; |
| 654 | } |
| 655 | |
| 656 | /// ParseGlobal |
| 657 | /// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal |
| 658 | /// OptionalAddrSpace GlobalType Type Const |
| 659 | /// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal |
| 660 | /// OptionalAddrSpace GlobalType Type Const |
| 661 | /// |
| 662 | /// Everything through visibility has been parsed already. |
| 663 | /// |
| 664 | bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, |
| 665 | unsigned Linkage, bool HasLinkage, |
| 666 | unsigned Visibility) { |
| 667 | unsigned AddrSpace; |
| 668 | bool ThreadLocal, IsConstant; |
| 669 | LocTy TyLoc; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 670 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 671 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 672 | if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) || |
| 673 | ParseOptionalAddrSpace(AddrSpace) || |
| 674 | ParseGlobalType(IsConstant) || |
| 675 | ParseType(Ty, TyLoc)) |
| 676 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 677 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 678 | // If the linkage is specified and is external, then no initializer is |
| 679 | // present. |
| 680 | Constant *Init = 0; |
| 681 | if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage && |
Duncan Sands | 5f4ee1f | 2009-03-11 08:08:06 +0000 | [diff] [blame] | 682 | Linkage != GlobalValue::ExternalWeakLinkage && |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 683 | Linkage != GlobalValue::ExternalLinkage)) { |
| 684 | if (ParseGlobalValue(Ty, Init)) |
| 685 | return true; |
| 686 | } |
| 687 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 688 | if (isa<FunctionType>(Ty) || Ty->isLabelTy()) |
Chris Lattner | 4a2f112 | 2009-02-08 20:00:15 +0000 | [diff] [blame] | 689 | return Error(TyLoc, "invalid type for global variable"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 690 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 691 | GlobalVariable *GV = 0; |
| 692 | |
| 693 | // See if the global was forward referenced, if so, use the global. |
Chris Lattner | 91dad87 | 2009-02-02 07:24:28 +0000 | [diff] [blame] | 694 | if (!Name.empty()) { |
Chris Lattner | 1d871c5 | 2009-10-25 23:22:50 +0000 | [diff] [blame] | 695 | if (GlobalValue *GVal = M->getNamedValue(Name)) { |
| 696 | if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal)) |
| 697 | return Error(NameLoc, "redefinition of global '@" + Name + "'"); |
| 698 | GV = cast<GlobalVariable>(GVal); |
| 699 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 700 | } else { |
| 701 | std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator |
| 702 | I = ForwardRefValIDs.find(NumberedVals.size()); |
| 703 | if (I != ForwardRefValIDs.end()) { |
| 704 | GV = cast<GlobalVariable>(I->second.first); |
| 705 | ForwardRefValIDs.erase(I); |
| 706 | } |
| 707 | } |
| 708 | |
| 709 | if (GV == 0) { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 710 | GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0, |
Owen Anderson | e9b11b4 | 2009-07-08 19:03:57 +0000 | [diff] [blame] | 711 | Name, 0, false, AddrSpace); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 712 | } else { |
| 713 | if (GV->getType()->getElementType() != Ty) |
| 714 | return Error(TyLoc, |
| 715 | "forward reference and definition of global have different types"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 716 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 717 | // Move the forward-reference to the correct spot in the module. |
| 718 | M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV); |
| 719 | } |
| 720 | |
| 721 | if (Name.empty()) |
| 722 | NumberedVals.push_back(GV); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 723 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 724 | // Set the parsed properties on the global. |
| 725 | if (Init) |
| 726 | GV->setInitializer(Init); |
| 727 | GV->setConstant(IsConstant); |
| 728 | GV->setLinkage((GlobalValue::LinkageTypes)Linkage); |
| 729 | GV->setVisibility((GlobalValue::VisibilityTypes)Visibility); |
| 730 | GV->setThreadLocal(ThreadLocal); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 731 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 732 | // Parse attributes on the global. |
| 733 | while (Lex.getKind() == lltok::comma) { |
| 734 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 735 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 736 | if (Lex.getKind() == lltok::kw_section) { |
| 737 | Lex.Lex(); |
| 738 | GV->setSection(Lex.getStrVal()); |
| 739 | if (ParseToken(lltok::StringConstant, "expected global section string")) |
| 740 | return true; |
| 741 | } else if (Lex.getKind() == lltok::kw_align) { |
| 742 | unsigned Alignment; |
| 743 | if (ParseOptionalAlignment(Alignment)) return true; |
| 744 | GV->setAlignment(Alignment); |
| 745 | } else { |
| 746 | TokError("unknown global variable property!"); |
| 747 | } |
| 748 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 749 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 750 | return false; |
| 751 | } |
| 752 | |
| 753 | |
| 754 | //===----------------------------------------------------------------------===// |
| 755 | // GlobalValue Reference/Resolution Routines. |
| 756 | //===----------------------------------------------------------------------===// |
| 757 | |
| 758 | /// GetGlobalVal - Get a value with the specified name or ID, creating a |
| 759 | /// forward reference record if needed. This can return null if the value |
| 760 | /// exists but does not have the right type. |
| 761 | GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, |
| 762 | LocTy Loc) { |
| 763 | const PointerType *PTy = dyn_cast<PointerType>(Ty); |
| 764 | if (PTy == 0) { |
| 765 | Error(Loc, "global variable reference must have pointer type"); |
| 766 | return 0; |
| 767 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 768 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 769 | // Look this name up in the normal function symbol table. |
| 770 | GlobalValue *Val = |
| 771 | cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 772 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 773 | // If this is a forward reference for the value, see if we already created a |
| 774 | // forward ref record. |
| 775 | if (Val == 0) { |
| 776 | std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator |
| 777 | I = ForwardRefVals.find(Name); |
| 778 | if (I != ForwardRefVals.end()) |
| 779 | Val = I->second.first; |
| 780 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 781 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 782 | // If we have the value in the symbol table or fwd-ref table, return it. |
| 783 | if (Val) { |
| 784 | if (Val->getType() == Ty) return Val; |
| 785 | Error(Loc, "'@" + Name + "' defined with type '" + |
| 786 | Val->getType()->getDescription() + "'"); |
| 787 | return 0; |
| 788 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 789 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 790 | // Otherwise, create a new forward reference for this value and remember it. |
| 791 | GlobalValue *FwdVal; |
Chris Lattner | 1e407c3 | 2009-01-08 19:05:36 +0000 | [diff] [blame] | 792 | if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { |
| 793 | // Function types can return opaque but functions can't. |
| 794 | if (isa<OpaqueType>(FT->getReturnType())) { |
| 795 | Error(Loc, "function may not return opaque type"); |
| 796 | return 0; |
| 797 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 798 | |
Duncan Sands | 5f4ee1f | 2009-03-11 08:08:06 +0000 | [diff] [blame] | 799 | FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M); |
Chris Lattner | 1e407c3 | 2009-01-08 19:05:36 +0000 | [diff] [blame] | 800 | } else { |
Owen Anderson | e9b11b4 | 2009-07-08 19:03:57 +0000 | [diff] [blame] | 801 | FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, |
| 802 | GlobalValue::ExternalWeakLinkage, 0, Name); |
Chris Lattner | 1e407c3 | 2009-01-08 19:05:36 +0000 | [diff] [blame] | 803 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 804 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 805 | ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); |
| 806 | return FwdVal; |
| 807 | } |
| 808 | |
| 809 | GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { |
| 810 | const PointerType *PTy = dyn_cast<PointerType>(Ty); |
| 811 | if (PTy == 0) { |
| 812 | Error(Loc, "global variable reference must have pointer type"); |
| 813 | return 0; |
| 814 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 815 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 816 | GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 817 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 818 | // If this is a forward reference for the value, see if we already created a |
| 819 | // forward ref record. |
| 820 | if (Val == 0) { |
| 821 | std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator |
| 822 | I = ForwardRefValIDs.find(ID); |
| 823 | if (I != ForwardRefValIDs.end()) |
| 824 | Val = I->second.first; |
| 825 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 826 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 827 | // If we have the value in the symbol table or fwd-ref table, return it. |
| 828 | if (Val) { |
| 829 | if (Val->getType() == Ty) return Val; |
| 830 | Error(Loc, "'@" + utostr(ID) + "' defined with type '" + |
| 831 | Val->getType()->getDescription() + "'"); |
| 832 | return 0; |
| 833 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 834 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 835 | // Otherwise, create a new forward reference for this value and remember it. |
| 836 | GlobalValue *FwdVal; |
Chris Lattner | 830703b | 2009-01-05 18:27:50 +0000 | [diff] [blame] | 837 | if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { |
| 838 | // Function types can return opaque but functions can't. |
| 839 | if (isa<OpaqueType>(FT->getReturnType())) { |
Chris Lattner | 0d8484f | 2009-01-05 18:56:52 +0000 | [diff] [blame] | 840 | Error(Loc, "function may not return opaque type"); |
Chris Lattner | 830703b | 2009-01-05 18:27:50 +0000 | [diff] [blame] | 841 | return 0; |
| 842 | } |
Duncan Sands | 5f4ee1f | 2009-03-11 08:08:06 +0000 | [diff] [blame] | 843 | FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M); |
Chris Lattner | 830703b | 2009-01-05 18:27:50 +0000 | [diff] [blame] | 844 | } else { |
Owen Anderson | e9b11b4 | 2009-07-08 19:03:57 +0000 | [diff] [blame] | 845 | FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, |
| 846 | GlobalValue::ExternalWeakLinkage, 0, ""); |
Chris Lattner | 830703b | 2009-01-05 18:27:50 +0000 | [diff] [blame] | 847 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 848 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 849 | ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); |
| 850 | return FwdVal; |
| 851 | } |
| 852 | |
| 853 | |
| 854 | //===----------------------------------------------------------------------===// |
| 855 | // Helper Routines. |
| 856 | //===----------------------------------------------------------------------===// |
| 857 | |
| 858 | /// ParseToken - If the current token has the specified kind, eat it and return |
| 859 | /// success. Otherwise, emit the specified error and return failure. |
| 860 | bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) { |
| 861 | if (Lex.getKind() != T) |
| 862 | return TokError(ErrMsg); |
| 863 | Lex.Lex(); |
| 864 | return false; |
| 865 | } |
| 866 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 867 | /// ParseStringConstant |
| 868 | /// ::= StringConstant |
| 869 | bool LLParser::ParseStringConstant(std::string &Result) { |
| 870 | if (Lex.getKind() != lltok::StringConstant) |
| 871 | return TokError("expected string constant"); |
| 872 | Result = Lex.getStrVal(); |
| 873 | Lex.Lex(); |
| 874 | return false; |
| 875 | } |
| 876 | |
| 877 | /// ParseUInt32 |
| 878 | /// ::= uint32 |
| 879 | bool LLParser::ParseUInt32(unsigned &Val) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 880 | if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned()) |
| 881 | return TokError("expected integer"); |
| 882 | uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1); |
| 883 | if (Val64 != unsigned(Val64)) |
| 884 | return TokError("expected 32-bit integer (too large)"); |
| 885 | Val = Val64; |
| 886 | Lex.Lex(); |
| 887 | return false; |
| 888 | } |
| 889 | |
| 890 | |
| 891 | /// ParseOptionalAddrSpace |
| 892 | /// := /*empty*/ |
| 893 | /// := 'addrspace' '(' uint32 ')' |
| 894 | bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) { |
| 895 | AddrSpace = 0; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 896 | if (!EatIfPresent(lltok::kw_addrspace)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 897 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 898 | return ParseToken(lltok::lparen, "expected '(' in address space") || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 899 | ParseUInt32(AddrSpace) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 900 | ParseToken(lltok::rparen, "expected ')' in address space"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 901 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 902 | |
| 903 | /// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind |
| 904 | /// indicates what kind of attribute list this is: 0: function arg, 1: result, |
| 905 | /// 2: function attr. |
Chris Lattner | ad9ad7c | 2009-03-25 06:36:36 +0000 | [diff] [blame] | 906 | /// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0 |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 907 | bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { |
| 908 | Attrs = Attribute::None; |
| 909 | LocTy AttrLoc = Lex.getLoc(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 910 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 911 | while (1) { |
| 912 | switch (Lex.getKind()) { |
| 913 | case lltok::kw_sext: |
| 914 | case lltok::kw_zext: |
Chris Lattner | ad9ad7c | 2009-03-25 06:36:36 +0000 | [diff] [blame] | 915 | // Treat these as signext/zeroext if they occur in the argument list after |
| 916 | // the value, as in "call i8 @foo(i8 10 sext)". If they occur before the |
| 917 | // value, as in "call i8 @foo(i8 sext (" then it is part of a constant |
| 918 | // expr. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 919 | // FIXME: REMOVE THIS IN LLVM 3.0 |
Chris Lattner | ad9ad7c | 2009-03-25 06:36:36 +0000 | [diff] [blame] | 920 | if (AttrKind == 3) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 921 | if (Lex.getKind() == lltok::kw_sext) |
| 922 | Attrs |= Attribute::SExt; |
| 923 | else |
| 924 | Attrs |= Attribute::ZExt; |
| 925 | break; |
| 926 | } |
| 927 | // FALL THROUGH. |
| 928 | default: // End of attributes. |
| 929 | if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly)) |
| 930 | return Error(AttrLoc, "invalid use of function-only attribute"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 931 | |
Chris Lattner | ad9ad7c | 2009-03-25 06:36:36 +0000 | [diff] [blame] | 932 | if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 933 | return Error(AttrLoc, "invalid use of parameter-only attribute"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 934 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 935 | return false; |
Devang Patel | 578efa9 | 2009-06-05 21:57:13 +0000 | [diff] [blame] | 936 | case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break; |
| 937 | case lltok::kw_signext: Attrs |= Attribute::SExt; break; |
| 938 | case lltok::kw_inreg: Attrs |= Attribute::InReg; break; |
| 939 | case lltok::kw_sret: Attrs |= Attribute::StructRet; break; |
| 940 | case lltok::kw_noalias: Attrs |= Attribute::NoAlias; break; |
| 941 | case lltok::kw_nocapture: Attrs |= Attribute::NoCapture; break; |
| 942 | case lltok::kw_byval: Attrs |= Attribute::ByVal; break; |
| 943 | case lltok::kw_nest: Attrs |= Attribute::Nest; break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 944 | |
Devang Patel | 578efa9 | 2009-06-05 21:57:13 +0000 | [diff] [blame] | 945 | case lltok::kw_noreturn: Attrs |= Attribute::NoReturn; break; |
| 946 | case lltok::kw_nounwind: Attrs |= Attribute::NoUnwind; break; |
| 947 | case lltok::kw_noinline: Attrs |= Attribute::NoInline; break; |
| 948 | case lltok::kw_readnone: Attrs |= Attribute::ReadNone; break; |
| 949 | case lltok::kw_readonly: Attrs |= Attribute::ReadOnly; break; |
Jakob Stoklund Olesen | 570a4a5 | 2010-02-06 01:16:28 +0000 | [diff] [blame^] | 950 | case lltok::kw_inlinehint: Attrs |= Attribute::InlineHint; break; |
Devang Patel | 578efa9 | 2009-06-05 21:57:13 +0000 | [diff] [blame] | 951 | case lltok::kw_alwaysinline: Attrs |= Attribute::AlwaysInline; break; |
| 952 | case lltok::kw_optsize: Attrs |= Attribute::OptimizeForSize; break; |
| 953 | case lltok::kw_ssp: Attrs |= Attribute::StackProtect; break; |
| 954 | case lltok::kw_sspreq: Attrs |= Attribute::StackProtectReq; break; |
| 955 | case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break; |
| 956 | case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break; |
Anton Korobeynikov | c5ec8a7 | 2009-07-17 18:07:26 +0000 | [diff] [blame] | 957 | case lltok::kw_naked: Attrs |= Attribute::Naked; break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 958 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 959 | case lltok::kw_align: { |
| 960 | unsigned Alignment; |
| 961 | if (ParseOptionalAlignment(Alignment)) |
| 962 | return true; |
| 963 | Attrs |= Attribute::constructAlignmentFromInt(Alignment); |
| 964 | continue; |
| 965 | } |
| 966 | } |
| 967 | Lex.Lex(); |
| 968 | } |
| 969 | } |
| 970 | |
| 971 | /// ParseOptionalLinkage |
| 972 | /// ::= /*empty*/ |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 973 | /// ::= 'private' |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 974 | /// ::= 'linker_private' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 975 | /// ::= 'internal' |
| 976 | /// ::= 'weak' |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 977 | /// ::= 'weak_odr' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 978 | /// ::= 'linkonce' |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 979 | /// ::= 'linkonce_odr' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 980 | /// ::= 'appending' |
| 981 | /// ::= 'dllexport' |
| 982 | /// ::= 'common' |
| 983 | /// ::= 'dllimport' |
| 984 | /// ::= 'extern_weak' |
| 985 | /// ::= 'external' |
| 986 | bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) { |
| 987 | HasLinkage = false; |
| 988 | switch (Lex.getKind()) { |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 989 | default: Res=GlobalValue::ExternalLinkage; return false; |
| 990 | case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break; |
| 991 | case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break; |
| 992 | case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break; |
| 993 | case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break; |
| 994 | case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break; |
| 995 | case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break; |
| 996 | case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break; |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 997 | case lltok::kw_available_externally: |
| 998 | Res = GlobalValue::AvailableExternallyLinkage; |
| 999 | break; |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 1000 | case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break; |
| 1001 | case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break; |
| 1002 | case lltok::kw_common: Res = GlobalValue::CommonLinkage; break; |
| 1003 | case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break; |
| 1004 | case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break; |
| 1005 | case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1006 | } |
| 1007 | Lex.Lex(); |
| 1008 | HasLinkage = true; |
| 1009 | return false; |
| 1010 | } |
| 1011 | |
| 1012 | /// ParseOptionalVisibility |
| 1013 | /// ::= /*empty*/ |
| 1014 | /// ::= 'default' |
| 1015 | /// ::= 'hidden' |
| 1016 | /// ::= 'protected' |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1017 | /// |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1018 | bool LLParser::ParseOptionalVisibility(unsigned &Res) { |
| 1019 | switch (Lex.getKind()) { |
| 1020 | default: Res = GlobalValue::DefaultVisibility; return false; |
| 1021 | case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break; |
| 1022 | case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break; |
| 1023 | case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break; |
| 1024 | } |
| 1025 | Lex.Lex(); |
| 1026 | return false; |
| 1027 | } |
| 1028 | |
| 1029 | /// ParseOptionalCallingConv |
| 1030 | /// ::= /*empty*/ |
| 1031 | /// ::= 'ccc' |
| 1032 | /// ::= 'fastcc' |
| 1033 | /// ::= 'coldcc' |
| 1034 | /// ::= 'x86_stdcallcc' |
| 1035 | /// ::= 'x86_fastcallcc' |
Anton Korobeynikov | 385f5a9 | 2009-06-16 18:50:49 +0000 | [diff] [blame] | 1036 | /// ::= 'arm_apcscc' |
| 1037 | /// ::= 'arm_aapcscc' |
| 1038 | /// ::= 'arm_aapcs_vfpcc' |
Anton Korobeynikov | 211a14e | 2009-12-07 02:27:35 +0000 | [diff] [blame] | 1039 | /// ::= 'msp430_intrcc' |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1040 | /// ::= 'cc' UINT |
Anton Korobeynikov | 385f5a9 | 2009-06-16 18:50:49 +0000 | [diff] [blame] | 1041 | /// |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 1042 | bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1043 | switch (Lex.getKind()) { |
| 1044 | default: CC = CallingConv::C; return false; |
| 1045 | case lltok::kw_ccc: CC = CallingConv::C; break; |
| 1046 | case lltok::kw_fastcc: CC = CallingConv::Fast; break; |
| 1047 | case lltok::kw_coldcc: CC = CallingConv::Cold; break; |
| 1048 | case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break; |
| 1049 | case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break; |
Anton Korobeynikov | 385f5a9 | 2009-06-16 18:50:49 +0000 | [diff] [blame] | 1050 | case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break; |
| 1051 | case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break; |
| 1052 | case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break; |
Anton Korobeynikov | 211a14e | 2009-12-07 02:27:35 +0000 | [diff] [blame] | 1053 | case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break; |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 1054 | case lltok::kw_cc: { |
| 1055 | unsigned ArbitraryCC; |
| 1056 | Lex.Lex(); |
| 1057 | if (ParseUInt32(ArbitraryCC)) { |
| 1058 | return true; |
| 1059 | } else |
| 1060 | CC = static_cast<CallingConv::ID>(ArbitraryCC); |
| 1061 | return false; |
| 1062 | } |
| 1063 | break; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1064 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1065 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1066 | Lex.Lex(); |
| 1067 | return false; |
| 1068 | } |
| 1069 | |
Chris Lattner | b8c4686 | 2009-12-30 05:31:19 +0000 | [diff] [blame] | 1070 | /// ParseInstructionMetadata |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 1071 | /// ::= !dbg !42 (',' !dbg !57)* |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 1072 | bool LLParser:: |
| 1073 | ParseInstructionMetadata(SmallVectorImpl<std::pair<unsigned, |
| 1074 | MDNode *> > &Result){ |
Chris Lattner | b8c4686 | 2009-12-30 05:31:19 +0000 | [diff] [blame] | 1075 | do { |
| 1076 | if (Lex.getKind() != lltok::MetadataVar) |
| 1077 | return TokError("expected metadata after comma"); |
Devang Patel | 0475c91 | 2009-09-29 00:01:14 +0000 | [diff] [blame] | 1078 | |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 1079 | std::string Name = Lex.getStrVal(); |
| 1080 | Lex.Lex(); |
Chris Lattner | 52e2031 | 2009-10-19 05:31:10 +0000 | [diff] [blame] | 1081 | |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 1082 | MDNode *Node; |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 1083 | if (ParseToken(lltok::exclaim, "expected '!' here") || |
| 1084 | ParseMDNodeID(Node)) |
| 1085 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1086 | |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 1087 | unsigned MDK = M->getMDKindID(Name.c_str()); |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 1088 | Result.push_back(std::make_pair(MDK, Node)); |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 1089 | |
| 1090 | // If this is the end of the list, we're done. |
Chris Lattner | b8c4686 | 2009-12-30 05:31:19 +0000 | [diff] [blame] | 1091 | } while (EatIfPresent(lltok::comma)); |
| 1092 | return false; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 1093 | } |
| 1094 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1095 | /// ParseOptionalAlignment |
| 1096 | /// ::= /* empty */ |
| 1097 | /// ::= 'align' 4 |
| 1098 | bool LLParser::ParseOptionalAlignment(unsigned &Alignment) { |
| 1099 | Alignment = 0; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1100 | if (!EatIfPresent(lltok::kw_align)) |
| 1101 | return false; |
Chris Lattner | 3fbb3ab | 2009-01-05 07:46:05 +0000 | [diff] [blame] | 1102 | LocTy AlignLoc = Lex.getLoc(); |
| 1103 | if (ParseUInt32(Alignment)) return true; |
| 1104 | if (!isPowerOf2_32(Alignment)) |
| 1105 | return Error(AlignLoc, "alignment is not a power of two"); |
| 1106 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1107 | } |
| 1108 | |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 1109 | /// ParseOptionalCommaAlign |
| 1110 | /// ::= |
| 1111 | /// ::= ',' align 4 |
| 1112 | /// |
| 1113 | /// This returns with AteExtraComma set to true if it ate an excess comma at the |
| 1114 | /// end. |
| 1115 | bool LLParser::ParseOptionalCommaAlign(unsigned &Alignment, |
| 1116 | bool &AteExtraComma) { |
| 1117 | AteExtraComma = false; |
| 1118 | while (EatIfPresent(lltok::comma)) { |
| 1119 | // Metadata at the end is an early exit. |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 1120 | if (Lex.getKind() == lltok::MetadataVar) { |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 1121 | AteExtraComma = true; |
| 1122 | return false; |
| 1123 | } |
| 1124 | |
| 1125 | if (Lex.getKind() == lltok::kw_align) { |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 1126 | if (ParseOptionalAlignment(Alignment)) return true; |
| 1127 | } else |
| 1128 | return true; |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 1129 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1130 | |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 1131 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1132 | } |
| 1133 | |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 1134 | |
Chris Lattner | 628c13a | 2009-12-30 05:14:00 +0000 | [diff] [blame] | 1135 | /// ParseIndexList - This parses the index list for an insert/extractvalue |
| 1136 | /// instruction. This sets AteExtraComma in the case where we eat an extra |
| 1137 | /// comma at the end of the line and find that it is followed by metadata. |
| 1138 | /// Clients that don't allow metadata can call the version of this function that |
| 1139 | /// only takes one argument. |
| 1140 | /// |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1141 | /// ParseIndexList |
| 1142 | /// ::= (',' uint32)+ |
Chris Lattner | 628c13a | 2009-12-30 05:14:00 +0000 | [diff] [blame] | 1143 | /// |
| 1144 | bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices, |
| 1145 | bool &AteExtraComma) { |
| 1146 | AteExtraComma = false; |
| 1147 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1148 | if (Lex.getKind() != lltok::comma) |
| 1149 | return TokError("expected ',' as start of index list"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1150 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1151 | while (EatIfPresent(lltok::comma)) { |
Chris Lattner | 628c13a | 2009-12-30 05:14:00 +0000 | [diff] [blame] | 1152 | if (Lex.getKind() == lltok::MetadataVar) { |
| 1153 | AteExtraComma = true; |
| 1154 | return false; |
| 1155 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1156 | unsigned Idx; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1157 | if (ParseUInt32(Idx)) return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1158 | Indices.push_back(Idx); |
| 1159 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1160 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1161 | return false; |
| 1162 | } |
| 1163 | |
| 1164 | //===----------------------------------------------------------------------===// |
| 1165 | // Type Parsing. |
| 1166 | //===----------------------------------------------------------------------===// |
| 1167 | |
| 1168 | /// ParseType - Parse and resolve a full type. |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1169 | bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) { |
| 1170 | LocTy TypeLoc = Lex.getLoc(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1171 | if (ParseTypeRec(Result)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1172 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1173 | // Verify no unresolved uprefs. |
| 1174 | if (!UpRefs.empty()) |
| 1175 | return Error(UpRefs.back().Loc, "invalid unresolved type up reference"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1176 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1177 | if (!AllowVoid && Result.get()->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1178 | return Error(TypeLoc, "void type only allowed for function results"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1179 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1180 | return false; |
| 1181 | } |
| 1182 | |
| 1183 | /// HandleUpRefs - Every time we finish a new layer of types, this function is |
| 1184 | /// called. It loops through the UpRefs vector, which is a list of the |
| 1185 | /// currently active types. For each type, if the up-reference is contained in |
| 1186 | /// the newly completed type, we decrement the level count. When the level |
| 1187 | /// count reaches zero, the up-referenced type is the type that is passed in: |
| 1188 | /// thus we can complete the cycle. |
| 1189 | /// |
| 1190 | PATypeHolder LLParser::HandleUpRefs(const Type *ty) { |
| 1191 | // If Ty isn't abstract, or if there are no up-references in it, then there is |
| 1192 | // nothing to resolve here. |
| 1193 | if (!ty->isAbstract() || UpRefs.empty()) return ty; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1194 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1195 | PATypeHolder Ty(ty); |
| 1196 | #if 0 |
David Greene | 0e28d76 | 2009-12-23 23:38:28 +0000 | [diff] [blame] | 1197 | dbgs() << "Type '" << Ty->getDescription() |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1198 | << "' newly formed. Resolving upreferences.\n" |
| 1199 | << UpRefs.size() << " upreferences active!\n"; |
| 1200 | #endif |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1201 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1202 | // If we find any resolvable upreferences (i.e., those whose NestingLevel goes |
| 1203 | // to zero), we resolve them all together before we resolve them to Ty. At |
| 1204 | // the end of the loop, if there is anything to resolve to Ty, it will be in |
| 1205 | // this variable. |
| 1206 | OpaqueType *TypeToResolve = 0; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1207 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1208 | for (unsigned i = 0; i != UpRefs.size(); ++i) { |
| 1209 | // Determine if 'Ty' directly contains this up-references 'LastContainedTy'. |
| 1210 | bool ContainsType = |
| 1211 | std::find(Ty->subtype_begin(), Ty->subtype_end(), |
| 1212 | UpRefs[i].LastContainedTy) != Ty->subtype_end(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1213 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1214 | #if 0 |
David Greene | 0e28d76 | 2009-12-23 23:38:28 +0000 | [diff] [blame] | 1215 | dbgs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1216 | << UpRefs[i].LastContainedTy->getDescription() << ") = " |
| 1217 | << (ContainsType ? "true" : "false") |
| 1218 | << " level=" << UpRefs[i].NestingLevel << "\n"; |
| 1219 | #endif |
| 1220 | if (!ContainsType) |
| 1221 | continue; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1222 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1223 | // Decrement level of upreference |
| 1224 | unsigned Level = --UpRefs[i].NestingLevel; |
| 1225 | UpRefs[i].LastContainedTy = Ty; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1226 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1227 | // If the Up-reference has a non-zero level, it shouldn't be resolved yet. |
| 1228 | if (Level != 0) |
| 1229 | continue; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1230 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1231 | #if 0 |
David Greene | 0e28d76 | 2009-12-23 23:38:28 +0000 | [diff] [blame] | 1232 | dbgs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n"; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1233 | #endif |
| 1234 | if (!TypeToResolve) |
| 1235 | TypeToResolve = UpRefs[i].UpRefTy; |
| 1236 | else |
| 1237 | UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); |
| 1238 | UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list. |
| 1239 | --i; // Do not skip the next element. |
| 1240 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1241 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1242 | if (TypeToResolve) |
| 1243 | TypeToResolve->refineAbstractTypeTo(Ty); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1244 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1245 | return Ty; |
| 1246 | } |
| 1247 | |
| 1248 | |
| 1249 | /// ParseTypeRec - The recursive function used to process the internal |
| 1250 | /// implementation details of types. |
| 1251 | bool LLParser::ParseTypeRec(PATypeHolder &Result) { |
| 1252 | switch (Lex.getKind()) { |
| 1253 | default: |
| 1254 | return TokError("expected type"); |
| 1255 | case lltok::Type: |
| 1256 | // TypeRec ::= 'float' | 'void' (etc) |
| 1257 | Result = Lex.getTyVal(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1258 | Lex.Lex(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1259 | break; |
| 1260 | case lltok::kw_opaque: |
| 1261 | // TypeRec ::= 'opaque' |
Owen Anderson | 0e275dc | 2009-08-13 23:27:32 +0000 | [diff] [blame] | 1262 | Result = OpaqueType::get(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1263 | Lex.Lex(); |
| 1264 | break; |
| 1265 | case lltok::lbrace: |
| 1266 | // TypeRec ::= '{' ... '}' |
| 1267 | if (ParseStructType(Result, false)) |
| 1268 | return true; |
| 1269 | break; |
| 1270 | case lltok::lsquare: |
| 1271 | // TypeRec ::= '[' ... ']' |
| 1272 | Lex.Lex(); // eat the lsquare. |
| 1273 | if (ParseArrayVectorType(Result, false)) |
| 1274 | return true; |
| 1275 | break; |
| 1276 | case lltok::less: // Either vector or packed struct. |
| 1277 | // TypeRec ::= '<' ... '>' |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1278 | Lex.Lex(); |
| 1279 | if (Lex.getKind() == lltok::lbrace) { |
| 1280 | if (ParseStructType(Result, true) || |
| 1281 | ParseToken(lltok::greater, "expected '>' at end of packed struct")) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1282 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1283 | } else if (ParseArrayVectorType(Result, true)) |
| 1284 | return true; |
| 1285 | break; |
| 1286 | case lltok::LocalVar: |
| 1287 | case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 |
| 1288 | // TypeRec ::= %foo |
| 1289 | if (const Type *T = M->getTypeByName(Lex.getStrVal())) { |
| 1290 | Result = T; |
| 1291 | } else { |
Owen Anderson | 0e275dc | 2009-08-13 23:27:32 +0000 | [diff] [blame] | 1292 | Result = OpaqueType::get(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1293 | ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(), |
| 1294 | std::make_pair(Result, |
| 1295 | Lex.getLoc()))); |
| 1296 | M->addTypeName(Lex.getStrVal(), Result.get()); |
| 1297 | } |
| 1298 | Lex.Lex(); |
| 1299 | break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1300 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1301 | case lltok::LocalVarID: |
| 1302 | // TypeRec ::= %4 |
| 1303 | if (Lex.getUIntVal() < NumberedTypes.size()) |
| 1304 | Result = NumberedTypes[Lex.getUIntVal()]; |
| 1305 | else { |
| 1306 | std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator |
| 1307 | I = ForwardRefTypeIDs.find(Lex.getUIntVal()); |
| 1308 | if (I != ForwardRefTypeIDs.end()) |
| 1309 | Result = I->second.first; |
| 1310 | else { |
Owen Anderson | 0e275dc | 2009-08-13 23:27:32 +0000 | [diff] [blame] | 1311 | Result = OpaqueType::get(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1312 | ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(), |
| 1313 | std::make_pair(Result, |
| 1314 | Lex.getLoc()))); |
| 1315 | } |
| 1316 | } |
| 1317 | Lex.Lex(); |
| 1318 | break; |
| 1319 | case lltok::backslash: { |
| 1320 | // TypeRec ::= '\' 4 |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1321 | Lex.Lex(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1322 | unsigned Val; |
| 1323 | if (ParseUInt32(Val)) return true; |
Owen Anderson | 0e275dc | 2009-08-13 23:27:32 +0000 | [diff] [blame] | 1324 | OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1325 | UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT)); |
| 1326 | Result = OT; |
| 1327 | break; |
| 1328 | } |
| 1329 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1330 | |
| 1331 | // Parse the type suffixes. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1332 | while (1) { |
| 1333 | switch (Lex.getKind()) { |
| 1334 | // End of type. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1335 | default: return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1336 | |
| 1337 | // TypeRec ::= TypeRec '*' |
| 1338 | case lltok::star: |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1339 | if (Result.get()->isLabelTy()) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1340 | return TokError("basic block pointers are invalid"); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1341 | if (Result.get()->isVoidTy()) |
Dan Gohman | b9070d3 | 2009-02-09 17:41:21 +0000 | [diff] [blame] | 1342 | return TokError("pointers to void are invalid; use i8* instead"); |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1343 | if (!PointerType::isValidElementType(Result.get())) |
| 1344 | return TokError("pointer to this type is invalid"); |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 1345 | Result = HandleUpRefs(PointerType::getUnqual(Result.get())); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1346 | Lex.Lex(); |
| 1347 | break; |
| 1348 | |
| 1349 | // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*' |
| 1350 | case lltok::kw_addrspace: { |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1351 | if (Result.get()->isLabelTy()) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1352 | return TokError("basic block pointers are invalid"); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1353 | if (Result.get()->isVoidTy()) |
Dan Gohman | b9070d3 | 2009-02-09 17:41:21 +0000 | [diff] [blame] | 1354 | return TokError("pointers to void are invalid; use i8* instead"); |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1355 | if (!PointerType::isValidElementType(Result.get())) |
| 1356 | return TokError("pointer to this type is invalid"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1357 | unsigned AddrSpace; |
| 1358 | if (ParseOptionalAddrSpace(AddrSpace) || |
| 1359 | ParseToken(lltok::star, "expected '*' in address space")) |
| 1360 | return true; |
| 1361 | |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 1362 | Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1363 | break; |
| 1364 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1365 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1366 | /// Types '(' ArgTypeListI ')' OptFuncAttrs |
| 1367 | case lltok::lparen: |
| 1368 | if (ParseFunctionType(Result)) |
| 1369 | return true; |
| 1370 | break; |
| 1371 | } |
| 1372 | } |
| 1373 | } |
| 1374 | |
| 1375 | /// ParseParameterList |
| 1376 | /// ::= '(' ')' |
| 1377 | /// ::= '(' Arg (',' Arg)* ')' |
| 1378 | /// Arg |
| 1379 | /// ::= Type OptionalAttributes Value OptionalAttributes |
| 1380 | bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, |
| 1381 | PerFunctionState &PFS) { |
| 1382 | if (ParseToken(lltok::lparen, "expected '(' in call")) |
| 1383 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1384 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1385 | while (Lex.getKind() != lltok::rparen) { |
| 1386 | // If this isn't the first argument, we need a comma. |
| 1387 | if (!ArgList.empty() && |
| 1388 | ParseToken(lltok::comma, "expected ',' in argument list")) |
| 1389 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1390 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1391 | // Parse the argument. |
| 1392 | LocTy ArgLoc; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1393 | PATypeHolder ArgTy(Type::getVoidTy(Context)); |
Victor Hernandez | 1971556 | 2009-12-03 23:40:58 +0000 | [diff] [blame] | 1394 | unsigned ArgAttrs1 = Attribute::None; |
| 1395 | unsigned ArgAttrs2 = Attribute::None; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1396 | Value *V; |
Victor Hernandez | 1971556 | 2009-12-03 23:40:58 +0000 | [diff] [blame] | 1397 | if (ParseType(ArgTy, ArgLoc)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1398 | return true; |
Victor Hernandez | 1971556 | 2009-12-03 23:40:58 +0000 | [diff] [blame] | 1399 | |
Chris Lattner | 287881d | 2009-12-30 02:11:14 +0000 | [diff] [blame] | 1400 | // Otherwise, handle normal operands. |
| 1401 | if (ParseOptionalAttrs(ArgAttrs1, 0) || |
| 1402 | ParseValue(ArgTy, V, PFS) || |
| 1403 | // FIXME: Should not allow attributes after the argument, remove this |
| 1404 | // in LLVM 3.0. |
| 1405 | ParseOptionalAttrs(ArgAttrs2, 3)) |
| 1406 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1407 | ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2)); |
| 1408 | } |
| 1409 | |
| 1410 | Lex.Lex(); // Lex the ')'. |
| 1411 | return false; |
| 1412 | } |
| 1413 | |
| 1414 | |
| 1415 | |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 1416 | /// ParseArgumentList - Parse the argument list for a function type or function |
| 1417 | /// prototype. If 'inType' is true then we are parsing a FunctionType. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1418 | /// ::= '(' ArgTypeListI ')' |
| 1419 | /// ArgTypeListI |
| 1420 | /// ::= /*empty*/ |
| 1421 | /// ::= '...' |
| 1422 | /// ::= ArgTypeList ',' '...' |
| 1423 | /// ::= ArgType (',' ArgType)* |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 1424 | /// |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1425 | bool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList, |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 1426 | bool &isVarArg, bool inType) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1427 | isVarArg = false; |
| 1428 | assert(Lex.getKind() == lltok::lparen); |
| 1429 | Lex.Lex(); // eat the (. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1430 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1431 | if (Lex.getKind() == lltok::rparen) { |
| 1432 | // empty |
| 1433 | } else if (Lex.getKind() == lltok::dotdotdot) { |
| 1434 | isVarArg = true; |
| 1435 | Lex.Lex(); |
| 1436 | } else { |
| 1437 | LocTy TypeLoc = Lex.getLoc(); |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1438 | PATypeHolder ArgTy(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1439 | unsigned Attrs; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1440 | std::string Name; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1441 | |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 1442 | // If we're parsing a type, use ParseTypeRec, because we allow recursive |
| 1443 | // types (such as a function returning a pointer to itself). If parsing a |
| 1444 | // function prototype, we require fully resolved types. |
| 1445 | if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1446 | ParseOptionalAttrs(Attrs, 0)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1447 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1448 | if (ArgTy->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1449 | return Error(TypeLoc, "argument can not have void type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1450 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1451 | if (Lex.getKind() == lltok::LocalVar || |
| 1452 | Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 |
| 1453 | Name = Lex.getStrVal(); |
| 1454 | Lex.Lex(); |
| 1455 | } |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1456 | |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1457 | if (!FunctionType::isValidArgumentType(ArgTy)) |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1458 | return Error(TypeLoc, "invalid type for function argument"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1459 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1460 | ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1461 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1462 | while (EatIfPresent(lltok::comma)) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1463 | // Handle ... at end of arg list. |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1464 | if (EatIfPresent(lltok::dotdotdot)) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1465 | isVarArg = true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1466 | break; |
| 1467 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1468 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1469 | // Otherwise must be an argument type. |
| 1470 | TypeLoc = Lex.getLoc(); |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1471 | if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1472 | ParseOptionalAttrs(Attrs, 0)) return true; |
| 1473 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1474 | if (ArgTy->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1475 | return Error(TypeLoc, "argument can not have void type"); |
| 1476 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1477 | if (Lex.getKind() == lltok::LocalVar || |
| 1478 | Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 |
| 1479 | Name = Lex.getStrVal(); |
| 1480 | Lex.Lex(); |
| 1481 | } else { |
| 1482 | Name = ""; |
| 1483 | } |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1484 | |
| 1485 | if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy)) |
| 1486 | return Error(TypeLoc, "invalid type for function argument"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1487 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1488 | ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); |
| 1489 | } |
| 1490 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1491 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1492 | return ParseToken(lltok::rparen, "expected ')' at end of argument list"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1493 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1494 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1495 | /// ParseFunctionType |
| 1496 | /// ::= Type ArgumentList OptionalAttrs |
| 1497 | bool LLParser::ParseFunctionType(PATypeHolder &Result) { |
| 1498 | assert(Lex.getKind() == lltok::lparen); |
| 1499 | |
Chris Lattner | d77d04c | 2009-01-05 08:04:33 +0000 | [diff] [blame] | 1500 | if (!FunctionType::isValidReturnType(Result)) |
| 1501 | return TokError("invalid function return type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1502 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1503 | std::vector<ArgInfo> ArgList; |
| 1504 | bool isVarArg; |
| 1505 | unsigned Attrs; |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 1506 | if (ParseArgumentList(ArgList, isVarArg, true) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1507 | // FIXME: Allow, but ignore attributes on function types! |
| 1508 | // FIXME: Remove in LLVM 3.0 |
| 1509 | ParseOptionalAttrs(Attrs, 2)) |
| 1510 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1511 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1512 | // Reject names on the arguments lists. |
| 1513 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { |
| 1514 | if (!ArgList[i].Name.empty()) |
| 1515 | return Error(ArgList[i].Loc, "argument name invalid in function type"); |
| 1516 | if (!ArgList[i].Attrs != 0) { |
| 1517 | // Allow but ignore attributes on function types; this permits |
| 1518 | // auto-upgrade. |
| 1519 | // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0 |
| 1520 | } |
| 1521 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1522 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1523 | std::vector<const Type*> ArgListTy; |
| 1524 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) |
| 1525 | ArgListTy.push_back(ArgList[i].Type); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1526 | |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 1527 | Result = HandleUpRefs(FunctionType::get(Result.get(), |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 1528 | ArgListTy, isVarArg)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1529 | return false; |
| 1530 | } |
| 1531 | |
| 1532 | /// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere. |
| 1533 | /// TypeRec |
| 1534 | /// ::= '{' '}' |
| 1535 | /// ::= '{' TypeRec (',' TypeRec)* '}' |
| 1536 | /// ::= '<' '{' '}' '>' |
| 1537 | /// ::= '<' '{' TypeRec (',' TypeRec)* '}' '>' |
| 1538 | bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { |
| 1539 | assert(Lex.getKind() == lltok::lbrace); |
| 1540 | Lex.Lex(); // Consume the '{' |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1541 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1542 | if (EatIfPresent(lltok::rbrace)) { |
Owen Anderson | d7f2a6c | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 1543 | Result = StructType::get(Context, Packed); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1544 | return false; |
| 1545 | } |
| 1546 | |
| 1547 | std::vector<PATypeHolder> ParamsList; |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1548 | LocTy EltTyLoc = Lex.getLoc(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1549 | if (ParseTypeRec(Result)) return true; |
| 1550 | ParamsList.push_back(Result); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1551 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1552 | if (Result->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1553 | return Error(EltTyLoc, "struct element can not have void type"); |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1554 | if (!StructType::isValidElementType(Result)) |
| 1555 | return Error(EltTyLoc, "invalid element type for struct"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1556 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1557 | while (EatIfPresent(lltok::comma)) { |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1558 | EltTyLoc = Lex.getLoc(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1559 | if (ParseTypeRec(Result)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1560 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1561 | if (Result->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1562 | return Error(EltTyLoc, "struct element can not have void type"); |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1563 | if (!StructType::isValidElementType(Result)) |
| 1564 | return Error(EltTyLoc, "invalid element type for struct"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1565 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1566 | ParamsList.push_back(Result); |
| 1567 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1568 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1569 | if (ParseToken(lltok::rbrace, "expected '}' at end of struct")) |
| 1570 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1571 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1572 | std::vector<const Type*> ParamsListTy; |
| 1573 | for (unsigned i = 0, e = ParamsList.size(); i != e; ++i) |
| 1574 | ParamsListTy.push_back(ParamsList[i].get()); |
Owen Anderson | d7f2a6c | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 1575 | Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1576 | return false; |
| 1577 | } |
| 1578 | |
| 1579 | /// ParseArrayVectorType - Parse an array or vector type, assuming the first |
| 1580 | /// token has already been consumed. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1581 | /// TypeRec |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1582 | /// ::= '[' APSINTVAL 'x' Types ']' |
| 1583 | /// ::= '<' APSINTVAL 'x' Types '>' |
| 1584 | bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) { |
| 1585 | if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() || |
| 1586 | Lex.getAPSIntVal().getBitWidth() > 64) |
| 1587 | return TokError("expected number in address space"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1588 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1589 | LocTy SizeLoc = Lex.getLoc(); |
| 1590 | uint64_t Size = Lex.getAPSIntVal().getZExtValue(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1591 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1592 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1593 | if (ParseToken(lltok::kw_x, "expected 'x' after element count")) |
| 1594 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1595 | |
| 1596 | LocTy TypeLoc = Lex.getLoc(); |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1597 | PATypeHolder EltTy(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1598 | if (ParseTypeRec(EltTy)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1599 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1600 | if (EltTy->isVoidTy()) |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 1601 | return Error(TypeLoc, "array and vector element type cannot be void"); |
| 1602 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1603 | if (ParseToken(isVector ? lltok::greater : lltok::rsquare, |
| 1604 | "expected end of sequential type")) |
| 1605 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1606 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1607 | if (isVector) { |
Chris Lattner | 452e262 | 2009-02-28 18:12:41 +0000 | [diff] [blame] | 1608 | if (Size == 0) |
| 1609 | return Error(SizeLoc, "zero element vector is illegal"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1610 | if ((unsigned)Size != Size) |
| 1611 | return Error(SizeLoc, "size too large for vector"); |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1612 | if (!VectorType::isValidElementType(EltTy)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1613 | return Error(TypeLoc, "vector element type must be fp or integer"); |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 1614 | Result = VectorType::get(EltTy, unsigned(Size)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1615 | } else { |
Nick Lewycky | a5f54a0 | 2009-06-07 07:26:46 +0000 | [diff] [blame] | 1616 | if (!ArrayType::isValidElementType(EltTy)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1617 | return Error(TypeLoc, "invalid array element type"); |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 1618 | Result = HandleUpRefs(ArrayType::get(EltTy, Size)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1619 | } |
| 1620 | return false; |
| 1621 | } |
| 1622 | |
| 1623 | //===----------------------------------------------------------------------===// |
| 1624 | // Function Semantic Analysis. |
| 1625 | //===----------------------------------------------------------------------===// |
| 1626 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 1627 | LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f, |
| 1628 | int functionNumber) |
| 1629 | : P(p), F(f), FunctionNumber(functionNumber) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1630 | |
| 1631 | // Insert unnamed arguments into the NumberedVals list. |
| 1632 | for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); |
| 1633 | AI != E; ++AI) |
| 1634 | if (!AI->hasName()) |
| 1635 | NumberedVals.push_back(AI); |
| 1636 | } |
| 1637 | |
| 1638 | LLParser::PerFunctionState::~PerFunctionState() { |
| 1639 | // If there were any forward referenced non-basicblock values, delete them. |
| 1640 | for (std::map<std::string, std::pair<Value*, LocTy> >::iterator |
| 1641 | I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I) |
| 1642 | if (!isa<BasicBlock>(I->second.first)) { |
Owen Anderson | b43eae7 | 2009-07-02 17:04:01 +0000 | [diff] [blame] | 1643 | I->second.first->replaceAllUsesWith( |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1644 | UndefValue::get(I->second.first->getType())); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1645 | delete I->second.first; |
| 1646 | I->second.first = 0; |
| 1647 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1648 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1649 | for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator |
| 1650 | I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I) |
| 1651 | if (!isa<BasicBlock>(I->second.first)) { |
Owen Anderson | b43eae7 | 2009-07-02 17:04:01 +0000 | [diff] [blame] | 1652 | I->second.first->replaceAllUsesWith( |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1653 | UndefValue::get(I->second.first->getType())); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1654 | delete I->second.first; |
| 1655 | I->second.first = 0; |
| 1656 | } |
| 1657 | } |
| 1658 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 1659 | bool LLParser::PerFunctionState::FinishFunction() { |
| 1660 | // Check to see if someone took the address of labels in this block. |
| 1661 | if (!P.ForwardRefBlockAddresses.empty()) { |
| 1662 | ValID FunctionID; |
| 1663 | if (!F.getName().empty()) { |
| 1664 | FunctionID.Kind = ValID::t_GlobalName; |
| 1665 | FunctionID.StrVal = F.getName(); |
| 1666 | } else { |
| 1667 | FunctionID.Kind = ValID::t_GlobalID; |
| 1668 | FunctionID.UIntVal = FunctionNumber; |
| 1669 | } |
| 1670 | |
| 1671 | std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator |
| 1672 | FRBAI = P.ForwardRefBlockAddresses.find(FunctionID); |
| 1673 | if (FRBAI != P.ForwardRefBlockAddresses.end()) { |
| 1674 | // Resolve all these references. |
| 1675 | if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this)) |
| 1676 | return true; |
| 1677 | |
| 1678 | P.ForwardRefBlockAddresses.erase(FRBAI); |
| 1679 | } |
| 1680 | } |
| 1681 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1682 | if (!ForwardRefVals.empty()) |
| 1683 | return P.Error(ForwardRefVals.begin()->second.second, |
| 1684 | "use of undefined value '%" + ForwardRefVals.begin()->first + |
| 1685 | "'"); |
| 1686 | if (!ForwardRefValIDs.empty()) |
| 1687 | return P.Error(ForwardRefValIDs.begin()->second.second, |
| 1688 | "use of undefined value '%" + |
| 1689 | utostr(ForwardRefValIDs.begin()->first) + "'"); |
| 1690 | return false; |
| 1691 | } |
| 1692 | |
| 1693 | |
| 1694 | /// GetVal - Get a value with the specified name or ID, creating a |
| 1695 | /// forward reference record if needed. This can return null if the value |
| 1696 | /// exists but does not have the right type. |
| 1697 | Value *LLParser::PerFunctionState::GetVal(const std::string &Name, |
| 1698 | const Type *Ty, LocTy Loc) { |
| 1699 | // Look this name up in the normal function symbol table. |
| 1700 | Value *Val = F.getValueSymbolTable().lookup(Name); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1701 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1702 | // If this is a forward reference for the value, see if we already created a |
| 1703 | // forward ref record. |
| 1704 | if (Val == 0) { |
| 1705 | std::map<std::string, std::pair<Value*, LocTy> >::iterator |
| 1706 | I = ForwardRefVals.find(Name); |
| 1707 | if (I != ForwardRefVals.end()) |
| 1708 | Val = I->second.first; |
| 1709 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1710 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1711 | // If we have the value in the symbol table or fwd-ref table, return it. |
| 1712 | if (Val) { |
| 1713 | if (Val->getType() == Ty) return Val; |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1714 | if (Ty->isLabelTy()) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1715 | P.Error(Loc, "'%" + Name + "' is not a basic block"); |
| 1716 | else |
| 1717 | P.Error(Loc, "'%" + Name + "' defined with type '" + |
| 1718 | Val->getType()->getDescription() + "'"); |
| 1719 | return 0; |
| 1720 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1721 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1722 | // Don't make placeholders with invalid type. |
Benjamin Kramer | f012705 | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 1723 | if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && !Ty->isLabelTy()) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1724 | P.Error(Loc, "invalid use of a non-first-class type"); |
| 1725 | return 0; |
| 1726 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1727 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1728 | // Otherwise, create a new forward reference for this value and remember it. |
| 1729 | Value *FwdVal; |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1730 | if (Ty->isLabelTy()) |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1731 | FwdVal = BasicBlock::Create(F.getContext(), Name, &F); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1732 | else |
| 1733 | FwdVal = new Argument(Ty, Name); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1734 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1735 | ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); |
| 1736 | return FwdVal; |
| 1737 | } |
| 1738 | |
| 1739 | Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty, |
| 1740 | LocTy Loc) { |
| 1741 | // Look this name up in the normal function symbol table. |
| 1742 | Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1743 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1744 | // If this is a forward reference for the value, see if we already created a |
| 1745 | // forward ref record. |
| 1746 | if (Val == 0) { |
| 1747 | std::map<unsigned, std::pair<Value*, LocTy> >::iterator |
| 1748 | I = ForwardRefValIDs.find(ID); |
| 1749 | if (I != ForwardRefValIDs.end()) |
| 1750 | Val = I->second.first; |
| 1751 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1752 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1753 | // If we have the value in the symbol table or fwd-ref table, return it. |
| 1754 | if (Val) { |
| 1755 | if (Val->getType() == Ty) return Val; |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1756 | if (Ty->isLabelTy()) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1757 | P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block"); |
| 1758 | else |
| 1759 | P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" + |
| 1760 | Val->getType()->getDescription() + "'"); |
| 1761 | return 0; |
| 1762 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1763 | |
Benjamin Kramer | f012705 | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 1764 | if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && !Ty->isLabelTy()) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1765 | P.Error(Loc, "invalid use of a non-first-class type"); |
| 1766 | return 0; |
| 1767 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1768 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1769 | // Otherwise, create a new forward reference for this value and remember it. |
| 1770 | Value *FwdVal; |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1771 | if (Ty->isLabelTy()) |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1772 | FwdVal = BasicBlock::Create(F.getContext(), "", &F); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1773 | else |
| 1774 | FwdVal = new Argument(Ty); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1775 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1776 | ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); |
| 1777 | return FwdVal; |
| 1778 | } |
| 1779 | |
| 1780 | /// SetInstName - After an instruction is parsed and inserted into its |
| 1781 | /// basic block, this installs its name. |
| 1782 | bool LLParser::PerFunctionState::SetInstName(int NameID, |
| 1783 | const std::string &NameStr, |
| 1784 | LocTy NameLoc, Instruction *Inst) { |
| 1785 | // If this instruction has void type, it cannot have a name or ID specified. |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1786 | if (Inst->getType()->isVoidTy()) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1787 | if (NameID != -1 || !NameStr.empty()) |
| 1788 | return P.Error(NameLoc, "instructions returning void cannot have a name"); |
| 1789 | return false; |
| 1790 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1791 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1792 | // If this was a numbered instruction, verify that the instruction is the |
| 1793 | // expected value and resolve any forward references. |
| 1794 | if (NameStr.empty()) { |
| 1795 | // If neither a name nor an ID was specified, just use the next ID. |
| 1796 | if (NameID == -1) |
| 1797 | NameID = NumberedVals.size(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1798 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1799 | if (unsigned(NameID) != NumberedVals.size()) |
| 1800 | return P.Error(NameLoc, "instruction expected to be numbered '%" + |
| 1801 | utostr(NumberedVals.size()) + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1802 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1803 | std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI = |
| 1804 | ForwardRefValIDs.find(NameID); |
| 1805 | if (FI != ForwardRefValIDs.end()) { |
| 1806 | if (FI->second.first->getType() != Inst->getType()) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1807 | return P.Error(NameLoc, "instruction forward referenced with type '" + |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1808 | FI->second.first->getType()->getDescription() + "'"); |
| 1809 | FI->second.first->replaceAllUsesWith(Inst); |
Nuno Lopes | 2b4f28e | 2009-09-02 15:02:57 +0000 | [diff] [blame] | 1810 | delete FI->second.first; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1811 | ForwardRefValIDs.erase(FI); |
| 1812 | } |
| 1813 | |
| 1814 | NumberedVals.push_back(Inst); |
| 1815 | return false; |
| 1816 | } |
| 1817 | |
| 1818 | // Otherwise, the instruction had a name. Resolve forward refs and set it. |
| 1819 | std::map<std::string, std::pair<Value*, LocTy> >::iterator |
| 1820 | FI = ForwardRefVals.find(NameStr); |
| 1821 | if (FI != ForwardRefVals.end()) { |
| 1822 | if (FI->second.first->getType() != Inst->getType()) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1823 | return P.Error(NameLoc, "instruction forward referenced with type '" + |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1824 | FI->second.first->getType()->getDescription() + "'"); |
| 1825 | FI->second.first->replaceAllUsesWith(Inst); |
Nuno Lopes | 531552a | 2009-09-02 14:22:03 +0000 | [diff] [blame] | 1826 | delete FI->second.first; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1827 | ForwardRefVals.erase(FI); |
| 1828 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1829 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1830 | // Set the name on the instruction. |
| 1831 | Inst->setName(NameStr); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1832 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1833 | if (Inst->getNameStr() != NameStr) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1834 | return P.Error(NameLoc, "multiple definition of local value named '" + |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1835 | NameStr + "'"); |
| 1836 | return false; |
| 1837 | } |
| 1838 | |
| 1839 | /// GetBB - Get a basic block with the specified name or ID, creating a |
| 1840 | /// forward reference record if needed. |
| 1841 | BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name, |
| 1842 | LocTy Loc) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1843 | return cast_or_null<BasicBlock>(GetVal(Name, |
| 1844 | Type::getLabelTy(F.getContext()), Loc)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1845 | } |
| 1846 | |
| 1847 | BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1848 | return cast_or_null<BasicBlock>(GetVal(ID, |
| 1849 | Type::getLabelTy(F.getContext()), Loc)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1850 | } |
| 1851 | |
| 1852 | /// DefineBB - Define the specified basic block, which is either named or |
| 1853 | /// unnamed. If there is an error, this returns null otherwise it returns |
| 1854 | /// the block being defined. |
| 1855 | BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, |
| 1856 | LocTy Loc) { |
| 1857 | BasicBlock *BB; |
| 1858 | if (Name.empty()) |
| 1859 | BB = GetBB(NumberedVals.size(), Loc); |
| 1860 | else |
| 1861 | BB = GetBB(Name, Loc); |
| 1862 | if (BB == 0) return 0; // Already diagnosed error. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1863 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1864 | // Move the block to the end of the function. Forward ref'd blocks are |
| 1865 | // inserted wherever they happen to be referenced. |
| 1866 | F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1867 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1868 | // Remove the block from forward ref sets. |
| 1869 | if (Name.empty()) { |
| 1870 | ForwardRefValIDs.erase(NumberedVals.size()); |
| 1871 | NumberedVals.push_back(BB); |
| 1872 | } else { |
| 1873 | // BB forward references are already in the function symbol table. |
| 1874 | ForwardRefVals.erase(Name); |
| 1875 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1876 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1877 | return BB; |
| 1878 | } |
| 1879 | |
| 1880 | //===----------------------------------------------------------------------===// |
| 1881 | // Constants. |
| 1882 | //===----------------------------------------------------------------------===// |
| 1883 | |
| 1884 | /// ParseValID - Parse an abstract value that doesn't necessarily have a |
| 1885 | /// type implied. For example, if we parse "4" we don't know what integer type |
| 1886 | /// it has. The value will later be combined with its type and checked for |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 1887 | /// sanity. PFS is used to convert function-local operands of metadata (since |
| 1888 | /// metadata operands are not just parsed here but also converted to values). |
| 1889 | /// PFS can be null when we are not parsing metadata values inside a function. |
Victor Hernandez | bf170d4 | 2010-01-05 22:22:14 +0000 | [diff] [blame] | 1890 | bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1891 | ID.Loc = Lex.getLoc(); |
| 1892 | switch (Lex.getKind()) { |
| 1893 | default: return TokError("expected value token"); |
| 1894 | case lltok::GlobalID: // @42 |
| 1895 | ID.UIntVal = Lex.getUIntVal(); |
| 1896 | ID.Kind = ValID::t_GlobalID; |
| 1897 | break; |
| 1898 | case lltok::GlobalVar: // @foo |
| 1899 | ID.StrVal = Lex.getStrVal(); |
| 1900 | ID.Kind = ValID::t_GlobalName; |
| 1901 | break; |
| 1902 | case lltok::LocalVarID: // %42 |
| 1903 | ID.UIntVal = Lex.getUIntVal(); |
| 1904 | ID.Kind = ValID::t_LocalID; |
| 1905 | break; |
| 1906 | case lltok::LocalVar: // %foo |
| 1907 | case lltok::StringConstant: // "foo" - FIXME: REMOVE IN LLVM 3.0 |
| 1908 | ID.StrVal = Lex.getStrVal(); |
| 1909 | ID.Kind = ValID::t_LocalName; |
| 1910 | break; |
Chris Lattner | e434d27 | 2009-12-30 04:56:59 +0000 | [diff] [blame] | 1911 | case lltok::exclaim: // !{...} MDNode, !"foo" MDString |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 1912 | Lex.Lex(); |
Chris Lattner | 442ffa1 | 2009-12-29 21:53:55 +0000 | [diff] [blame] | 1913 | |
Chris Lattner | 3f5132a | 2009-12-29 22:40:21 +0000 | [diff] [blame] | 1914 | if (EatIfPresent(lltok::lbrace)) { |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 1915 | SmallVector<Value*, 16> Elts; |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 1916 | if (ParseMDNodeVector(Elts, PFS) || |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 1917 | ParseToken(lltok::rbrace, "expected end of metadata node")) |
| 1918 | return true; |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 1919 | |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 1920 | ID.MDNodeVal = MDNode::get(Context, Elts.data(), Elts.size()); |
Chris Lattner | 287881d | 2009-12-30 02:11:14 +0000 | [diff] [blame] | 1921 | ID.Kind = ValID::t_MDNode; |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 1922 | return false; |
| 1923 | } |
| 1924 | |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 1925 | // Standalone metadata reference |
| 1926 | // !{ ..., !42, ... } |
Chris Lattner | 860775c | 2009-12-30 04:13:37 +0000 | [diff] [blame] | 1927 | if (Lex.getKind() == lltok::APSInt) { |
Chris Lattner | 4a72efc | 2009-12-30 04:15:23 +0000 | [diff] [blame] | 1928 | if (ParseMDNodeID(ID.MDNodeVal)) return true; |
Chris Lattner | 287881d | 2009-12-30 02:11:14 +0000 | [diff] [blame] | 1929 | ID.Kind = ValID::t_MDNode; |
Devang Patel | 923078c | 2009-07-01 19:21:12 +0000 | [diff] [blame] | 1930 | return false; |
Chris Lattner | 287881d | 2009-12-30 02:11:14 +0000 | [diff] [blame] | 1931 | } |
| 1932 | |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 1933 | // MDString: |
| 1934 | // ::= '!' STRINGCONSTANT |
Chris Lattner | 287881d | 2009-12-30 02:11:14 +0000 | [diff] [blame] | 1935 | if (ParseMDString(ID.MDStringVal)) return true; |
| 1936 | ID.Kind = ValID::t_MDString; |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 1937 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1938 | case lltok::APSInt: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1939 | ID.APSIntVal = Lex.getAPSIntVal(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1940 | ID.Kind = ValID::t_APSInt; |
| 1941 | break; |
| 1942 | case lltok::APFloat: |
| 1943 | ID.APFloatVal = Lex.getAPFloatVal(); |
| 1944 | ID.Kind = ValID::t_APFloat; |
| 1945 | break; |
| 1946 | case lltok::kw_true: |
Owen Anderson | 5defacc | 2009-07-31 17:39:07 +0000 | [diff] [blame] | 1947 | ID.ConstantVal = ConstantInt::getTrue(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1948 | ID.Kind = ValID::t_Constant; |
| 1949 | break; |
| 1950 | case lltok::kw_false: |
Owen Anderson | 5defacc | 2009-07-31 17:39:07 +0000 | [diff] [blame] | 1951 | ID.ConstantVal = ConstantInt::getFalse(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1952 | ID.Kind = ValID::t_Constant; |
| 1953 | break; |
| 1954 | case lltok::kw_null: ID.Kind = ValID::t_Null; break; |
| 1955 | case lltok::kw_undef: ID.Kind = ValID::t_Undef; break; |
| 1956 | case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1957 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1958 | case lltok::lbrace: { |
| 1959 | // ValID ::= '{' ConstVector '}' |
| 1960 | Lex.Lex(); |
| 1961 | SmallVector<Constant*, 16> Elts; |
| 1962 | if (ParseGlobalValueVector(Elts) || |
| 1963 | ParseToken(lltok::rbrace, "expected end of struct constant")) |
| 1964 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1965 | |
Owen Anderson | d7f2a6c | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 1966 | ID.ConstantVal = ConstantStruct::get(Context, Elts.data(), |
| 1967 | Elts.size(), false); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1968 | ID.Kind = ValID::t_Constant; |
| 1969 | return false; |
| 1970 | } |
| 1971 | case lltok::less: { |
| 1972 | // ValID ::= '<' ConstVector '>' --> Vector. |
| 1973 | // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct. |
| 1974 | Lex.Lex(); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 1975 | bool isPackedStruct = EatIfPresent(lltok::lbrace); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1976 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1977 | SmallVector<Constant*, 16> Elts; |
| 1978 | LocTy FirstEltLoc = Lex.getLoc(); |
| 1979 | if (ParseGlobalValueVector(Elts) || |
| 1980 | (isPackedStruct && |
| 1981 | ParseToken(lltok::rbrace, "expected end of packed struct")) || |
| 1982 | ParseToken(lltok::greater, "expected end of constant")) |
| 1983 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1984 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1985 | if (isPackedStruct) { |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 1986 | ID.ConstantVal = |
Owen Anderson | d7f2a6c | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 1987 | ConstantStruct::get(Context, Elts.data(), Elts.size(), true); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1988 | ID.Kind = ValID::t_Constant; |
| 1989 | return false; |
| 1990 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1991 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 1992 | if (Elts.empty()) |
| 1993 | return Error(ID.Loc, "constant vector must not be empty"); |
| 1994 | |
| 1995 | if (!Elts[0]->getType()->isInteger() && |
| 1996 | !Elts[0]->getType()->isFloatingPoint()) |
| 1997 | return Error(FirstEltLoc, |
| 1998 | "vector elements must have integer or floating point type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1999 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2000 | // Verify that all the vector elements have the same type. |
| 2001 | for (unsigned i = 1, e = Elts.size(); i != e; ++i) |
| 2002 | if (Elts[i]->getType() != Elts[0]->getType()) |
| 2003 | return Error(FirstEltLoc, |
| 2004 | "vector element #" + utostr(i) + |
| 2005 | " is not of type '" + Elts[0]->getType()->getDescription()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2006 | |
Owen Anderson | af7ec97 | 2009-07-28 21:19:26 +0000 | [diff] [blame] | 2007 | ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size()); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2008 | ID.Kind = ValID::t_Constant; |
| 2009 | return false; |
| 2010 | } |
| 2011 | case lltok::lsquare: { // Array Constant |
| 2012 | Lex.Lex(); |
| 2013 | SmallVector<Constant*, 16> Elts; |
| 2014 | LocTy FirstEltLoc = Lex.getLoc(); |
| 2015 | if (ParseGlobalValueVector(Elts) || |
| 2016 | ParseToken(lltok::rsquare, "expected end of array constant")) |
| 2017 | return true; |
| 2018 | |
| 2019 | // Handle empty element. |
| 2020 | if (Elts.empty()) { |
| 2021 | // Use undef instead of an array because it's inconvenient to determine |
| 2022 | // the element type at this point, there being no elements to examine. |
Chris Lattner | 081b505 | 2009-01-05 07:52:51 +0000 | [diff] [blame] | 2023 | ID.Kind = ValID::t_EmptyArray; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2024 | return false; |
| 2025 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2026 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2027 | if (!Elts[0]->getType()->isFirstClassType()) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2028 | return Error(FirstEltLoc, "invalid array element type: " + |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2029 | Elts[0]->getType()->getDescription()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2030 | |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 2031 | ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2032 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2033 | // Verify all elements are correct type! |
Chris Lattner | 6d6b3cc | 2009-01-02 08:49:06 +0000 | [diff] [blame] | 2034 | for (unsigned i = 0, e = Elts.size(); i != e; ++i) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2035 | if (Elts[i]->getType() != Elts[0]->getType()) |
| 2036 | return Error(FirstEltLoc, |
| 2037 | "array element #" + utostr(i) + |
| 2038 | " is not of type '" +Elts[0]->getType()->getDescription()); |
| 2039 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2040 | |
Owen Anderson | 1fd7096 | 2009-07-28 18:32:17 +0000 | [diff] [blame] | 2041 | ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size()); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2042 | ID.Kind = ValID::t_Constant; |
| 2043 | return false; |
| 2044 | } |
| 2045 | case lltok::kw_c: // c "foo" |
| 2046 | Lex.Lex(); |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2047 | ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2048 | if (ParseToken(lltok::StringConstant, "expected string")) return true; |
| 2049 | ID.Kind = ValID::t_Constant; |
| 2050 | return false; |
| 2051 | |
| 2052 | case lltok::kw_asm: { |
Dale Johannesen | 8ba2d5b | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 2053 | // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT |
| 2054 | bool HasSideEffect, AlignStack; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2055 | Lex.Lex(); |
| 2056 | if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || |
Dale Johannesen | 8ba2d5b | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 2057 | ParseOptionalToken(lltok::kw_alignstack, AlignStack) || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2058 | ParseStringConstant(ID.StrVal) || |
| 2059 | ParseToken(lltok::comma, "expected comma in inline asm expression") || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2060 | ParseToken(lltok::StringConstant, "expected constraint string")) |
| 2061 | return true; |
| 2062 | ID.StrVal2 = Lex.getStrVal(); |
Daniel Dunbar | f0bb41c | 2009-11-07 23:51:55 +0000 | [diff] [blame] | 2063 | ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2064 | ID.Kind = ValID::t_InlineAsm; |
| 2065 | return false; |
| 2066 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2067 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 2068 | case lltok::kw_blockaddress: { |
| 2069 | // ValID ::= 'blockaddress' '(' @foo ',' %bar ')' |
| 2070 | Lex.Lex(); |
| 2071 | |
| 2072 | ValID Fn, Label; |
| 2073 | LocTy FnLoc, LabelLoc; |
| 2074 | |
| 2075 | if (ParseToken(lltok::lparen, "expected '(' in block address expression") || |
| 2076 | ParseValID(Fn) || |
| 2077 | ParseToken(lltok::comma, "expected comma in block address expression")|| |
| 2078 | ParseValID(Label) || |
| 2079 | ParseToken(lltok::rparen, "expected ')' in block address expression")) |
| 2080 | return true; |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 2081 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 2082 | if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) |
| 2083 | return Error(Fn.Loc, "expected function name in blockaddress"); |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 2084 | if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName) |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 2085 | return Error(Label.Loc, "expected basic block name in blockaddress"); |
| 2086 | |
| 2087 | // Make a global variable as a placeholder for this reference. |
| 2088 | GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), |
| 2089 | false, GlobalValue::InternalLinkage, |
| 2090 | 0, ""); |
| 2091 | ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef)); |
| 2092 | ID.ConstantVal = FwdRef; |
| 2093 | ID.Kind = ValID::t_Constant; |
| 2094 | return false; |
| 2095 | } |
| 2096 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2097 | case lltok::kw_trunc: |
| 2098 | case lltok::kw_zext: |
| 2099 | case lltok::kw_sext: |
| 2100 | case lltok::kw_fptrunc: |
| 2101 | case lltok::kw_fpext: |
| 2102 | case lltok::kw_bitcast: |
| 2103 | case lltok::kw_uitofp: |
| 2104 | case lltok::kw_sitofp: |
| 2105 | case lltok::kw_fptoui: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2106 | case lltok::kw_fptosi: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2107 | case lltok::kw_inttoptr: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2108 | case lltok::kw_ptrtoint: { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2109 | unsigned Opc = Lex.getUIntVal(); |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2110 | PATypeHolder DestTy(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2111 | Constant *SrcVal; |
| 2112 | Lex.Lex(); |
| 2113 | if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") || |
| 2114 | ParseGlobalTypeAndValue(SrcVal) || |
Dan Gohman | 24b108b | 2009-06-15 21:52:11 +0000 | [diff] [blame] | 2115 | ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2116 | ParseType(DestTy) || |
| 2117 | ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast")) |
| 2118 | return true; |
| 2119 | if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy)) |
| 2120 | return Error(ID.Loc, "invalid cast opcode for cast from '" + |
| 2121 | SrcVal->getType()->getDescription() + "' to '" + |
| 2122 | DestTy->getDescription() + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2123 | ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 2124 | SrcVal, DestTy); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2125 | ID.Kind = ValID::t_Constant; |
| 2126 | return false; |
| 2127 | } |
| 2128 | case lltok::kw_extractvalue: { |
| 2129 | Lex.Lex(); |
| 2130 | Constant *Val; |
| 2131 | SmallVector<unsigned, 4> Indices; |
| 2132 | if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")|| |
| 2133 | ParseGlobalTypeAndValue(Val) || |
| 2134 | ParseIndexList(Indices) || |
| 2135 | ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) |
| 2136 | return true; |
Devang Patel | e8bc45a | 2009-11-03 19:06:07 +0000 | [diff] [blame] | 2137 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2138 | if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) |
| 2139 | return Error(ID.Loc, "extractvalue operand must be array or struct"); |
| 2140 | if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), |
| 2141 | Indices.end())) |
| 2142 | return Error(ID.Loc, "invalid indices for extractvalue"); |
Jay Foad | e3e51c0 | 2009-05-21 09:52:38 +0000 | [diff] [blame] | 2143 | ID.ConstantVal = |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2144 | ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size()); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2145 | ID.Kind = ValID::t_Constant; |
| 2146 | return false; |
| 2147 | } |
| 2148 | case lltok::kw_insertvalue: { |
| 2149 | Lex.Lex(); |
| 2150 | Constant *Val0, *Val1; |
| 2151 | SmallVector<unsigned, 4> Indices; |
| 2152 | if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")|| |
| 2153 | ParseGlobalTypeAndValue(Val0) || |
| 2154 | ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")|| |
| 2155 | ParseGlobalTypeAndValue(Val1) || |
| 2156 | ParseIndexList(Indices) || |
| 2157 | ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr")) |
| 2158 | return true; |
| 2159 | if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) |
| 2160 | return Error(ID.Loc, "extractvalue operand must be array or struct"); |
| 2161 | if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), |
| 2162 | Indices.end())) |
| 2163 | return Error(ID.Loc, "invalid indices for insertvalue"); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2164 | ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 2165 | Indices.data(), Indices.size()); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2166 | ID.Kind = ValID::t_Constant; |
| 2167 | return false; |
| 2168 | } |
| 2169 | case lltok::kw_icmp: |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2170 | case lltok::kw_fcmp: { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2171 | unsigned PredVal, Opc = Lex.getUIntVal(); |
| 2172 | Constant *Val0, *Val1; |
| 2173 | Lex.Lex(); |
| 2174 | if (ParseCmpPredicate(PredVal, Opc) || |
| 2175 | ParseToken(lltok::lparen, "expected '(' in compare constantexpr") || |
| 2176 | ParseGlobalTypeAndValue(Val0) || |
| 2177 | ParseToken(lltok::comma, "expected comma in compare constantexpr") || |
| 2178 | ParseGlobalTypeAndValue(Val1) || |
| 2179 | ParseToken(lltok::rparen, "expected ')' in compare constantexpr")) |
| 2180 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2181 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2182 | if (Val0->getType() != Val1->getType()) |
| 2183 | return Error(ID.Loc, "compare operands must have the same type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2184 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2185 | CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2186 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2187 | if (Opc == Instruction::FCmp) { |
| 2188 | if (!Val0->getType()->isFPOrFPVector()) |
| 2189 | return Error(ID.Loc, "fcmp requires floating point operands"); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2190 | ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1); |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2191 | } else { |
| 2192 | assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2193 | if (!Val0->getType()->isIntOrIntVector() && |
| 2194 | !isa<PointerType>(Val0->getType())) |
| 2195 | return Error(ID.Loc, "icmp requires pointer or integer operands"); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2196 | ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2197 | } |
| 2198 | ID.Kind = ValID::t_Constant; |
| 2199 | return false; |
| 2200 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2201 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2202 | // Binary Operators. |
| 2203 | case lltok::kw_add: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 2204 | case lltok::kw_fadd: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2205 | case lltok::kw_sub: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 2206 | case lltok::kw_fsub: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2207 | case lltok::kw_mul: |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 2208 | case lltok::kw_fmul: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2209 | case lltok::kw_udiv: |
| 2210 | case lltok::kw_sdiv: |
| 2211 | case lltok::kw_fdiv: |
| 2212 | case lltok::kw_urem: |
| 2213 | case lltok::kw_srem: |
| 2214 | case lltok::kw_frem: { |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2215 | bool NUW = false; |
| 2216 | bool NSW = false; |
| 2217 | bool Exact = false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2218 | unsigned Opc = Lex.getUIntVal(); |
| 2219 | Constant *Val0, *Val1; |
| 2220 | Lex.Lex(); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2221 | LocTy ModifierLoc = Lex.getLoc(); |
| 2222 | if (Opc == Instruction::Add || |
| 2223 | Opc == Instruction::Sub || |
| 2224 | Opc == Instruction::Mul) { |
| 2225 | if (EatIfPresent(lltok::kw_nuw)) |
| 2226 | NUW = true; |
| 2227 | if (EatIfPresent(lltok::kw_nsw)) { |
| 2228 | NSW = true; |
| 2229 | if (EatIfPresent(lltok::kw_nuw)) |
| 2230 | NUW = true; |
| 2231 | } |
| 2232 | } else if (Opc == Instruction::SDiv) { |
| 2233 | if (EatIfPresent(lltok::kw_exact)) |
| 2234 | Exact = true; |
| 2235 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2236 | if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") || |
| 2237 | ParseGlobalTypeAndValue(Val0) || |
| 2238 | ParseToken(lltok::comma, "expected comma in binary constantexpr") || |
| 2239 | ParseGlobalTypeAndValue(Val1) || |
| 2240 | ParseToken(lltok::rparen, "expected ')' in binary constantexpr")) |
| 2241 | return true; |
| 2242 | if (Val0->getType() != Val1->getType()) |
| 2243 | return Error(ID.Loc, "operands of constexpr must have same type"); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2244 | if (!Val0->getType()->isIntOrIntVector()) { |
| 2245 | if (NUW) |
| 2246 | return Error(ModifierLoc, "nuw only applies to integer operations"); |
| 2247 | if (NSW) |
| 2248 | return Error(ModifierLoc, "nsw only applies to integer operations"); |
| 2249 | } |
| 2250 | // API compatibility: Accept either integer or floating-point types with |
| 2251 | // add, sub, and mul. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2252 | if (!Val0->getType()->isIntOrIntVector() && |
| 2253 | !Val0->getType()->isFPOrFPVector()) |
| 2254 | return Error(ID.Loc,"constexpr requires integer, fp, or vector operands"); |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2255 | unsigned Flags = 0; |
| 2256 | if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap; |
| 2257 | if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap; |
| 2258 | if (Exact) Flags |= SDivOperator::IsExact; |
| 2259 | Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2260 | ID.ConstantVal = C; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2261 | ID.Kind = ValID::t_Constant; |
| 2262 | return false; |
| 2263 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2264 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2265 | // Logical Operations |
| 2266 | case lltok::kw_shl: |
| 2267 | case lltok::kw_lshr: |
| 2268 | case lltok::kw_ashr: |
| 2269 | case lltok::kw_and: |
| 2270 | case lltok::kw_or: |
| 2271 | case lltok::kw_xor: { |
| 2272 | unsigned Opc = Lex.getUIntVal(); |
| 2273 | Constant *Val0, *Val1; |
| 2274 | Lex.Lex(); |
| 2275 | if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") || |
| 2276 | ParseGlobalTypeAndValue(Val0) || |
| 2277 | ParseToken(lltok::comma, "expected comma in logical constantexpr") || |
| 2278 | ParseGlobalTypeAndValue(Val1) || |
| 2279 | ParseToken(lltok::rparen, "expected ')' in logical constantexpr")) |
| 2280 | return true; |
| 2281 | if (Val0->getType() != Val1->getType()) |
| 2282 | return Error(ID.Loc, "operands of constexpr must have same type"); |
| 2283 | if (!Val0->getType()->isIntOrIntVector()) |
| 2284 | return Error(ID.Loc, |
| 2285 | "constexpr requires integer or integer vector operands"); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2286 | ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2287 | ID.Kind = ValID::t_Constant; |
| 2288 | return false; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2289 | } |
| 2290 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2291 | case lltok::kw_getelementptr: |
| 2292 | case lltok::kw_shufflevector: |
| 2293 | case lltok::kw_insertelement: |
| 2294 | case lltok::kw_extractelement: |
| 2295 | case lltok::kw_select: { |
| 2296 | unsigned Opc = Lex.getUIntVal(); |
| 2297 | SmallVector<Constant*, 16> Elts; |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 2298 | bool InBounds = false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2299 | Lex.Lex(); |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 2300 | if (Opc == Instruction::GetElementPtr) |
Dan Gohman | dcb40a3 | 2009-07-29 15:58:36 +0000 | [diff] [blame] | 2301 | InBounds = EatIfPresent(lltok::kw_inbounds); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2302 | if (ParseToken(lltok::lparen, "expected '(' in constantexpr") || |
| 2303 | ParseGlobalValueVector(Elts) || |
| 2304 | ParseToken(lltok::rparen, "expected ')' in constantexpr")) |
| 2305 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2306 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2307 | if (Opc == Instruction::GetElementPtr) { |
| 2308 | if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType())) |
| 2309 | return Error(ID.Loc, "getelementptr requires pointer operand"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2310 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2311 | if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), |
Eli Friedman | 4e9bac3 | 2009-07-24 21:56:17 +0000 | [diff] [blame] | 2312 | (Value**)(Elts.data() + 1), |
| 2313 | Elts.size() - 1)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2314 | return Error(ID.Loc, "invalid indices for getelementptr"); |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2315 | ID.ConstantVal = InBounds ? |
| 2316 | ConstantExpr::getInBoundsGetElementPtr(Elts[0], |
| 2317 | Elts.data() + 1, |
| 2318 | Elts.size() - 1) : |
| 2319 | ConstantExpr::getGetElementPtr(Elts[0], |
| 2320 | Elts.data() + 1, Elts.size() - 1); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2321 | } else if (Opc == Instruction::Select) { |
| 2322 | if (Elts.size() != 3) |
| 2323 | return Error(ID.Loc, "expected three operands to select"); |
| 2324 | if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1], |
| 2325 | Elts[2])) |
| 2326 | return Error(ID.Loc, Reason); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2327 | ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2328 | } else if (Opc == Instruction::ShuffleVector) { |
| 2329 | if (Elts.size() != 3) |
| 2330 | return Error(ID.Loc, "expected three operands to shufflevector"); |
| 2331 | if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2])) |
| 2332 | return Error(ID.Loc, "invalid operands to shufflevector"); |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 2333 | ID.ConstantVal = |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2334 | ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2335 | } else if (Opc == Instruction::ExtractElement) { |
| 2336 | if (Elts.size() != 2) |
| 2337 | return Error(ID.Loc, "expected two operands to extractelement"); |
| 2338 | if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1])) |
| 2339 | return Error(ID.Loc, "invalid extractelement operands"); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2340 | ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2341 | } else { |
| 2342 | assert(Opc == Instruction::InsertElement && "Unknown opcode"); |
| 2343 | if (Elts.size() != 3) |
| 2344 | return Error(ID.Loc, "expected three operands to insertelement"); |
| 2345 | if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2])) |
| 2346 | return Error(ID.Loc, "invalid insertelement operands"); |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 2347 | ID.ConstantVal = |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 2348 | ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2349 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2350 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2351 | ID.Kind = ValID::t_Constant; |
| 2352 | return false; |
| 2353 | } |
| 2354 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2355 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2356 | Lex.Lex(); |
| 2357 | return false; |
| 2358 | } |
| 2359 | |
| 2360 | /// ParseGlobalValue - Parse a global value with the specified type. |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2361 | bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&C) { |
| 2362 | C = 0; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2363 | ValID ID; |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2364 | Value *V = NULL; |
| 2365 | bool Parsed = ParseValID(ID) || |
| 2366 | ConvertValIDToValue(Ty, ID, V, NULL); |
| 2367 | if (V && !(C = dyn_cast<Constant>(V))) |
| 2368 | return Error(ID.Loc, "global values must be constants"); |
| 2369 | return Parsed; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2370 | } |
| 2371 | |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2372 | bool LLParser::ParseGlobalTypeAndValue(Constant *&V) { |
| 2373 | PATypeHolder Type(Type::getVoidTy(Context)); |
| 2374 | return ParseType(Type) || |
| 2375 | ParseGlobalValue(Type, V); |
| 2376 | } |
| 2377 | |
| 2378 | /// ParseGlobalValueVector |
| 2379 | /// ::= /*empty*/ |
| 2380 | /// ::= TypeAndValue (',' TypeAndValue)* |
| 2381 | bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) { |
| 2382 | // Empty list. |
| 2383 | if (Lex.getKind() == lltok::rbrace || |
| 2384 | Lex.getKind() == lltok::rsquare || |
| 2385 | Lex.getKind() == lltok::greater || |
| 2386 | Lex.getKind() == lltok::rparen) |
| 2387 | return false; |
| 2388 | |
| 2389 | Constant *C; |
| 2390 | if (ParseGlobalTypeAndValue(C)) return true; |
| 2391 | Elts.push_back(C); |
| 2392 | |
| 2393 | while (EatIfPresent(lltok::comma)) { |
| 2394 | if (ParseGlobalTypeAndValue(C)) return true; |
| 2395 | Elts.push_back(C); |
| 2396 | } |
| 2397 | |
| 2398 | return false; |
| 2399 | } |
| 2400 | |
| 2401 | |
| 2402 | //===----------------------------------------------------------------------===// |
| 2403 | // Function Parsing. |
| 2404 | //===----------------------------------------------------------------------===// |
| 2405 | |
| 2406 | bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, |
| 2407 | PerFunctionState *PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2408 | if (isa<FunctionType>(Ty)) |
| 2409 | return Error(ID.Loc, "functions are not values, refer to them as pointers"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2410 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2411 | switch (ID.Kind) { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2412 | default: llvm_unreachable("Unknown ValID!"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2413 | case ValID::t_LocalID: |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2414 | if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); |
| 2415 | V = PFS->GetVal(ID.UIntVal, Ty, ID.Loc); |
| 2416 | return (V == 0); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2417 | case ValID::t_LocalName: |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2418 | if (!PFS) return Error(ID.Loc, "invalid use of function-local name"); |
| 2419 | V = PFS->GetVal(ID.StrVal, Ty, ID.Loc); |
| 2420 | return (V == 0); |
| 2421 | case ValID::t_InlineAsm: { |
| 2422 | const PointerType *PTy = dyn_cast<PointerType>(Ty); |
| 2423 | const FunctionType *FTy = |
| 2424 | PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; |
| 2425 | if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) |
| 2426 | return Error(ID.Loc, "invalid type for inline asm constraint string"); |
| 2427 | V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1); |
| 2428 | return false; |
| 2429 | } |
| 2430 | case ValID::t_MDNode: |
| 2431 | if (!Ty->isMetadataTy()) |
| 2432 | return Error(ID.Loc, "metadata value must have metadata type"); |
| 2433 | V = ID.MDNodeVal; |
| 2434 | return false; |
| 2435 | case ValID::t_MDString: |
| 2436 | if (!Ty->isMetadataTy()) |
| 2437 | return Error(ID.Loc, "metadata value must have metadata type"); |
| 2438 | V = ID.MDStringVal; |
| 2439 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2440 | case ValID::t_GlobalName: |
| 2441 | V = GetGlobalVal(ID.StrVal, Ty, ID.Loc); |
| 2442 | return V == 0; |
| 2443 | case ValID::t_GlobalID: |
| 2444 | V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc); |
| 2445 | return V == 0; |
| 2446 | case ValID::t_APSInt: |
| 2447 | if (!isa<IntegerType>(Ty)) |
| 2448 | return Error(ID.Loc, "integer constant must have integer type"); |
| 2449 | ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits()); |
Owen Anderson | eed707b | 2009-07-24 23:12:02 +0000 | [diff] [blame] | 2450 | V = ConstantInt::get(Context, ID.APSIntVal); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2451 | return false; |
| 2452 | case ValID::t_APFloat: |
| 2453 | if (!Ty->isFloatingPoint() || |
| 2454 | !ConstantFP::isValueValidForType(Ty, ID.APFloatVal)) |
| 2455 | return Error(ID.Loc, "floating point constant invalid for type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2456 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2457 | // The lexer has no type info, so builds all float and double FP constants |
| 2458 | // as double. Fix this here. Long double does not need this. |
| 2459 | if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble && |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2460 | Ty->isFloatTy()) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2461 | bool Ignored; |
| 2462 | ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, |
| 2463 | &Ignored); |
| 2464 | } |
Owen Anderson | 6f83c9c | 2009-07-27 20:59:43 +0000 | [diff] [blame] | 2465 | V = ConstantFP::get(Context, ID.APFloatVal); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2466 | |
Chris Lattner | 959873d | 2009-01-05 18:24:23 +0000 | [diff] [blame] | 2467 | if (V->getType() != Ty) |
| 2468 | return Error(ID.Loc, "floating point constant does not have type '" + |
| 2469 | Ty->getDescription() + "'"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2470 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2471 | return false; |
| 2472 | case ValID::t_Null: |
| 2473 | if (!isa<PointerType>(Ty)) |
| 2474 | return Error(ID.Loc, "null must be a pointer type"); |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2475 | V = ConstantPointerNull::get(cast<PointerType>(Ty)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2476 | return false; |
| 2477 | case ValID::t_Undef: |
Chris Lattner | e67c1aa | 2009-01-05 08:13:38 +0000 | [diff] [blame] | 2478 | // FIXME: LabelTy should not be a first-class type. |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2479 | if ((!Ty->isFirstClassType() || Ty->isLabelTy()) && |
Chris Lattner | 0b61635 | 2009-01-05 18:12:21 +0000 | [diff] [blame] | 2480 | !isa<OpaqueType>(Ty)) |
Chris Lattner | e67c1aa | 2009-01-05 08:13:38 +0000 | [diff] [blame] | 2481 | return Error(ID.Loc, "invalid type for undef constant"); |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2482 | V = UndefValue::get(Ty); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2483 | return false; |
Chris Lattner | 081b505 | 2009-01-05 07:52:51 +0000 | [diff] [blame] | 2484 | case ValID::t_EmptyArray: |
| 2485 | if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0) |
| 2486 | return Error(ID.Loc, "invalid empty array initializer"); |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2487 | V = UndefValue::get(Ty); |
Chris Lattner | 081b505 | 2009-01-05 07:52:51 +0000 | [diff] [blame] | 2488 | return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2489 | case ValID::t_Zero: |
Chris Lattner | e67c1aa | 2009-01-05 08:13:38 +0000 | [diff] [blame] | 2490 | // FIXME: LabelTy should not be a first-class type. |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 2491 | if (!Ty->isFirstClassType() || Ty->isLabelTy()) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2492 | return Error(ID.Loc, "invalid type for null constant"); |
Owen Anderson | a7235ea | 2009-07-31 20:28:14 +0000 | [diff] [blame] | 2493 | V = Constant::getNullValue(Ty); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2494 | return false; |
| 2495 | case ValID::t_Constant: |
| 2496 | if (ID.ConstantVal->getType() != Ty) |
| 2497 | return Error(ID.Loc, "constant expression type mismatch"); |
| 2498 | V = ID.ConstantVal; |
| 2499 | return false; |
| 2500 | } |
| 2501 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2502 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2503 | bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) { |
| 2504 | V = 0; |
| 2505 | ValID ID; |
Victor Hernandez | bf170d4 | 2010-01-05 22:22:14 +0000 | [diff] [blame] | 2506 | return ParseValID(ID, &PFS) || |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 2507 | ConvertValIDToValue(Ty, ID, V, &PFS); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2508 | } |
| 2509 | |
| 2510 | bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2511 | PATypeHolder T(Type::getVoidTy(Context)); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2512 | return ParseType(T) || |
| 2513 | ParseValue(T, V, PFS); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2514 | } |
| 2515 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2516 | bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, |
| 2517 | PerFunctionState &PFS) { |
| 2518 | Value *V; |
| 2519 | Loc = Lex.getLoc(); |
| 2520 | if (ParseTypeAndValue(V, PFS)) return true; |
| 2521 | if (!isa<BasicBlock>(V)) |
| 2522 | return Error(Loc, "expected a basic block"); |
| 2523 | BB = cast<BasicBlock>(V); |
| 2524 | return false; |
| 2525 | } |
| 2526 | |
| 2527 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2528 | /// FunctionHeader |
| 2529 | /// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs |
| 2530 | /// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection |
| 2531 | /// OptionalAlign OptGC |
| 2532 | bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { |
| 2533 | // Parse the linkage. |
| 2534 | LocTy LinkageLoc = Lex.getLoc(); |
| 2535 | unsigned Linkage; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2536 | |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 2537 | unsigned Visibility, RetAttrs; |
| 2538 | CallingConv::ID CC; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2539 | PATypeHolder RetType(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2540 | LocTy RetTypeLoc = Lex.getLoc(); |
| 2541 | if (ParseOptionalLinkage(Linkage) || |
| 2542 | ParseOptionalVisibility(Visibility) || |
| 2543 | ParseOptionalCallingConv(CC) || |
| 2544 | ParseOptionalAttrs(RetAttrs, 1) || |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 2545 | ParseType(RetType, RetTypeLoc, true /*void allowed*/)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2546 | return true; |
| 2547 | |
| 2548 | // Verify that the linkage is ok. |
| 2549 | switch ((GlobalValue::LinkageTypes)Linkage) { |
| 2550 | case GlobalValue::ExternalLinkage: |
| 2551 | break; // always ok. |
| 2552 | case GlobalValue::DLLImportLinkage: |
Duncan Sands | 5f4ee1f | 2009-03-11 08:08:06 +0000 | [diff] [blame] | 2553 | case GlobalValue::ExternalWeakLinkage: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2554 | if (isDefine) |
| 2555 | return Error(LinkageLoc, "invalid linkage for function definition"); |
| 2556 | break; |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 2557 | case GlobalValue::PrivateLinkage: |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 2558 | case GlobalValue::LinkerPrivateLinkage: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2559 | case GlobalValue::InternalLinkage: |
Nick Lewycky | 55f64db | 2009-04-13 07:02:02 +0000 | [diff] [blame] | 2560 | case GlobalValue::AvailableExternallyLinkage: |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 2561 | case GlobalValue::LinkOnceAnyLinkage: |
| 2562 | case GlobalValue::LinkOnceODRLinkage: |
| 2563 | case GlobalValue::WeakAnyLinkage: |
| 2564 | case GlobalValue::WeakODRLinkage: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2565 | case GlobalValue::DLLExportLinkage: |
| 2566 | if (!isDefine) |
| 2567 | return Error(LinkageLoc, "invalid linkage for function declaration"); |
| 2568 | break; |
| 2569 | case GlobalValue::AppendingLinkage: |
Duncan Sands | 4dc2b39 | 2009-03-11 20:14:15 +0000 | [diff] [blame] | 2570 | case GlobalValue::CommonLinkage: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2571 | return Error(LinkageLoc, "invalid function linkage type"); |
| 2572 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2573 | |
Chris Lattner | 99bb315 | 2009-01-05 08:00:30 +0000 | [diff] [blame] | 2574 | if (!FunctionType::isValidReturnType(RetType) || |
| 2575 | isa<OpaqueType>(RetType)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2576 | return Error(RetTypeLoc, "invalid function return type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2577 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2578 | LocTy NameLoc = Lex.getLoc(); |
Chris Lattner | f570e62 | 2009-02-18 21:48:13 +0000 | [diff] [blame] | 2579 | |
| 2580 | std::string FunctionName; |
| 2581 | if (Lex.getKind() == lltok::GlobalVar) { |
| 2582 | FunctionName = Lex.getStrVal(); |
| 2583 | } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok. |
| 2584 | unsigned NameID = Lex.getUIntVal(); |
| 2585 | |
| 2586 | if (NameID != NumberedVals.size()) |
| 2587 | return TokError("function expected to be numbered '%" + |
| 2588 | utostr(NumberedVals.size()) + "'"); |
| 2589 | } else { |
| 2590 | return TokError("expected function name"); |
| 2591 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2592 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2593 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2594 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2595 | if (Lex.getKind() != lltok::lparen) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2596 | return TokError("expected '(' in function argument list"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2597 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2598 | std::vector<ArgInfo> ArgList; |
| 2599 | bool isVarArg; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2600 | unsigned FuncAttrs; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2601 | std::string Section; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2602 | unsigned Alignment; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2603 | std::string GC; |
| 2604 | |
Chris Lattner | dfd19dd | 2009-01-05 18:34:07 +0000 | [diff] [blame] | 2605 | if (ParseArgumentList(ArgList, isVarArg, false) || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2606 | ParseOptionalAttrs(FuncAttrs, 2) || |
| 2607 | (EatIfPresent(lltok::kw_section) && |
| 2608 | ParseStringConstant(Section)) || |
| 2609 | ParseOptionalAlignment(Alignment) || |
| 2610 | (EatIfPresent(lltok::kw_gc) && |
| 2611 | ParseStringConstant(GC))) |
| 2612 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2613 | |
| 2614 | // If the alignment was parsed as an attribute, move to the alignment field. |
| 2615 | if (FuncAttrs & Attribute::Alignment) { |
| 2616 | Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs); |
| 2617 | FuncAttrs &= ~Attribute::Alignment; |
| 2618 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2619 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2620 | // Okay, if we got here, the function is syntactically valid. Convert types |
| 2621 | // and do semantic checks. |
| 2622 | std::vector<const Type*> ParamTypeList; |
| 2623 | SmallVector<AttributeWithIndex, 8> Attrs; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2624 | // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2625 | // attributes. |
| 2626 | unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; |
| 2627 | if (FuncAttrs & ObsoleteFuncAttrs) { |
| 2628 | RetAttrs |= FuncAttrs & ObsoleteFuncAttrs; |
| 2629 | FuncAttrs &= ~ObsoleteFuncAttrs; |
| 2630 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2631 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2632 | if (RetAttrs != Attribute::None) |
| 2633 | Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2634 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2635 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { |
| 2636 | ParamTypeList.push_back(ArgList[i].Type); |
| 2637 | if (ArgList[i].Attrs != Attribute::None) |
| 2638 | Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); |
| 2639 | } |
| 2640 | |
| 2641 | if (FuncAttrs != Attribute::None) |
| 2642 | Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs)); |
| 2643 | |
| 2644 | AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2645 | |
Benjamin Kramer | f012705 | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 2646 | if (PAL.paramHasAttr(1, Attribute::StructRet) && !RetType->isVoidTy()) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2647 | return Error(RetTypeLoc, "functions with 'sret' argument must return void"); |
| 2648 | |
Owen Anderson | fba933c | 2009-07-01 23:57:11 +0000 | [diff] [blame] | 2649 | const FunctionType *FT = |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 2650 | FunctionType::get(RetType, ParamTypeList, isVarArg); |
| 2651 | const PointerType *PFT = PointerType::getUnqual(FT); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2652 | |
| 2653 | Fn = 0; |
| 2654 | if (!FunctionName.empty()) { |
| 2655 | // If this was a definition of a forward reference, remove the definition |
| 2656 | // from the forward reference table and fill in the forward ref. |
| 2657 | std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI = |
| 2658 | ForwardRefVals.find(FunctionName); |
| 2659 | if (FRVI != ForwardRefVals.end()) { |
| 2660 | Fn = M->getFunction(FunctionName); |
| 2661 | ForwardRefVals.erase(FRVI); |
| 2662 | } else if ((Fn = M->getFunction(FunctionName))) { |
| 2663 | // If this function already exists in the symbol table, then it is |
| 2664 | // multiply defined. We accept a few cases for old backwards compat. |
| 2665 | // FIXME: Remove this stuff for LLVM 3.0. |
| 2666 | if (Fn->getType() != PFT || Fn->getAttributes() != PAL || |
| 2667 | (!Fn->isDeclaration() && isDefine)) { |
| 2668 | // If the redefinition has different type or different attributes, |
| 2669 | // reject it. If both have bodies, reject it. |
| 2670 | return Error(NameLoc, "invalid redefinition of function '" + |
| 2671 | FunctionName + "'"); |
| 2672 | } else if (Fn->isDeclaration()) { |
| 2673 | // Make sure to strip off any argument names so we can't get conflicts. |
| 2674 | for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); |
| 2675 | AI != AE; ++AI) |
| 2676 | AI->setName(""); |
| 2677 | } |
Chris Lattner | 1d871c5 | 2009-10-25 23:22:50 +0000 | [diff] [blame] | 2678 | } else if (M->getNamedValue(FunctionName)) { |
| 2679 | return Error(NameLoc, "redefinition of function '@" + FunctionName + "'"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2680 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2681 | |
Dan Gohman | 4190554 | 2009-08-29 23:37:49 +0000 | [diff] [blame] | 2682 | } else { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2683 | // If this is a definition of a forward referenced function, make sure the |
| 2684 | // types agree. |
| 2685 | std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I |
| 2686 | = ForwardRefValIDs.find(NumberedVals.size()); |
| 2687 | if (I != ForwardRefValIDs.end()) { |
| 2688 | Fn = cast<Function>(I->second.first); |
| 2689 | if (Fn->getType() != PFT) |
| 2690 | return Error(NameLoc, "type of definition and forward reference of '@" + |
| 2691 | utostr(NumberedVals.size()) +"' disagree"); |
| 2692 | ForwardRefValIDs.erase(I); |
| 2693 | } |
| 2694 | } |
| 2695 | |
| 2696 | if (Fn == 0) |
| 2697 | Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M); |
| 2698 | else // Move the forward-reference to the correct spot in the module. |
| 2699 | M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn); |
| 2700 | |
| 2701 | if (FunctionName.empty()) |
| 2702 | NumberedVals.push_back(Fn); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2703 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2704 | Fn->setLinkage((GlobalValue::LinkageTypes)Linkage); |
| 2705 | Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility); |
| 2706 | Fn->setCallingConv(CC); |
| 2707 | Fn->setAttributes(PAL); |
| 2708 | Fn->setAlignment(Alignment); |
| 2709 | Fn->setSection(Section); |
| 2710 | if (!GC.empty()) Fn->setGC(GC.c_str()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2711 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2712 | // Add all of the arguments we parsed to the function. |
| 2713 | Function::arg_iterator ArgIt = Fn->arg_begin(); |
| 2714 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) { |
Chris Lattner | 5bda379 | 2009-11-26 22:48:23 +0000 | [diff] [blame] | 2715 | // If we run out of arguments in the Function prototype, exit early. |
| 2716 | // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above. |
| 2717 | if (ArgIt == Fn->arg_end()) break; |
| 2718 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2719 | // If the argument has a name, insert it into the argument symbol table. |
| 2720 | if (ArgList[i].Name.empty()) continue; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2721 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2722 | // Set the name, if it conflicted, it will be auto-renamed. |
| 2723 | ArgIt->setName(ArgList[i].Name); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2724 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2725 | if (ArgIt->getNameStr() != ArgList[i].Name) |
| 2726 | return Error(ArgList[i].Loc, "redefinition of argument '%" + |
| 2727 | ArgList[i].Name + "'"); |
| 2728 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2729 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2730 | return false; |
| 2731 | } |
| 2732 | |
| 2733 | |
| 2734 | /// ParseFunctionBody |
| 2735 | /// ::= '{' BasicBlock+ '}' |
| 2736 | /// ::= 'begin' BasicBlock+ 'end' // FIXME: remove in LLVM 3.0 |
| 2737 | /// |
| 2738 | bool LLParser::ParseFunctionBody(Function &Fn) { |
| 2739 | if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin) |
| 2740 | return TokError("expected '{' in function body"); |
| 2741 | Lex.Lex(); // eat the {. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2742 | |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 2743 | int FunctionNumber = -1; |
| 2744 | if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1; |
| 2745 | |
| 2746 | PerFunctionState PFS(*this, Fn, FunctionNumber); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2747 | |
Chris Lattner | 2fdf8db | 2010-01-09 19:20:07 +0000 | [diff] [blame] | 2748 | // We need at least one basic block. |
| 2749 | if (Lex.getKind() == lltok::rbrace || Lex.getKind() == lltok::kw_end) |
| 2750 | return TokError("function body requires at least one basic block"); |
| 2751 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2752 | while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end) |
| 2753 | if (ParseBasicBlock(PFS)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2754 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2755 | // Eat the }. |
| 2756 | Lex.Lex(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2757 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2758 | // Verify function is ok. |
Chris Lattner | 09d9ef4 | 2009-10-28 03:39:23 +0000 | [diff] [blame] | 2759 | return PFS.FinishFunction(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2760 | } |
| 2761 | |
| 2762 | /// ParseBasicBlock |
| 2763 | /// ::= LabelStr? Instruction* |
| 2764 | bool LLParser::ParseBasicBlock(PerFunctionState &PFS) { |
| 2765 | // If this basic block starts out with a name, remember it. |
| 2766 | std::string Name; |
| 2767 | LocTy NameLoc = Lex.getLoc(); |
| 2768 | if (Lex.getKind() == lltok::LabelStr) { |
| 2769 | Name = Lex.getStrVal(); |
| 2770 | Lex.Lex(); |
| 2771 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2772 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2773 | BasicBlock *BB = PFS.DefineBB(Name, NameLoc); |
| 2774 | if (BB == 0) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2775 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2776 | std::string NameStr; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2777 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2778 | // Parse the instructions in this block until we get a terminator. |
| 2779 | Instruction *Inst; |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 2780 | SmallVector<std::pair<unsigned, MDNode *>, 4> MetadataOnInst; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2781 | do { |
| 2782 | // This instruction may have three possibilities for a name: a) none |
| 2783 | // specified, b) name specified "%foo =", c) number specified: "%4 =". |
| 2784 | LocTy NameLoc = Lex.getLoc(); |
| 2785 | int NameID = -1; |
| 2786 | NameStr = ""; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2787 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2788 | if (Lex.getKind() == lltok::LocalVarID) { |
| 2789 | NameID = Lex.getUIntVal(); |
| 2790 | Lex.Lex(); |
| 2791 | if (ParseToken(lltok::equal, "expected '=' after instruction id")) |
| 2792 | return true; |
| 2793 | } else if (Lex.getKind() == lltok::LocalVar || |
| 2794 | // FIXME: REMOVE IN LLVM 3.0 |
| 2795 | Lex.getKind() == lltok::StringConstant) { |
| 2796 | NameStr = Lex.getStrVal(); |
| 2797 | Lex.Lex(); |
| 2798 | if (ParseToken(lltok::equal, "expected '=' after instruction name")) |
| 2799 | return true; |
| 2800 | } |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 2801 | |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 2802 | switch (ParseInstruction(Inst, BB, PFS)) { |
| 2803 | default: assert(0 && "Unknown ParseInstruction result!"); |
| 2804 | case InstError: return true; |
| 2805 | case InstNormal: |
| 2806 | // With a normal result, we check to see if the instruction is followed by |
| 2807 | // a comma and metadata. |
| 2808 | if (EatIfPresent(lltok::comma)) |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 2809 | if (ParseInstructionMetadata(MetadataOnInst)) |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 2810 | return true; |
| 2811 | break; |
| 2812 | case InstExtraComma: |
| 2813 | // If the instruction parser ate an extra comma at the end of it, it |
| 2814 | // *must* be followed by metadata. |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 2815 | if (ParseInstructionMetadata(MetadataOnInst)) |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 2816 | return true; |
| 2817 | break; |
| 2818 | } |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 2819 | |
| 2820 | // Set metadata attached with this instruction. |
Chris Lattner | 1340dd3 | 2009-12-30 05:48:36 +0000 | [diff] [blame] | 2821 | for (unsigned i = 0, e = MetadataOnInst.size(); i != e; ++i) |
| 2822 | Inst->setMetadata(MetadataOnInst[i].first, MetadataOnInst[i].second); |
| 2823 | MetadataOnInst.clear(); |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 2824 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2825 | BB->getInstList().push_back(Inst); |
| 2826 | |
| 2827 | // Set the name on the instruction. |
| 2828 | if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true; |
| 2829 | } while (!isa<TerminatorInst>(Inst)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2830 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2831 | return false; |
| 2832 | } |
| 2833 | |
| 2834 | //===----------------------------------------------------------------------===// |
| 2835 | // Instruction Parsing. |
| 2836 | //===----------------------------------------------------------------------===// |
| 2837 | |
| 2838 | /// ParseInstruction - Parse one of the many different instructions. |
| 2839 | /// |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 2840 | int LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, |
| 2841 | PerFunctionState &PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2842 | lltok::Kind Token = Lex.getKind(); |
| 2843 | if (Token == lltok::Eof) |
| 2844 | return TokError("found end of file when expecting more instructions"); |
| 2845 | LocTy Loc = Lex.getLoc(); |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 2846 | unsigned KeywordVal = Lex.getUIntVal(); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2847 | Lex.Lex(); // Eat the keyword. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2848 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2849 | switch (Token) { |
| 2850 | default: return Error(Loc, "expected instruction opcode"); |
| 2851 | // Terminator Instructions. |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2852 | case lltok::kw_unwind: Inst = new UnwindInst(Context); return false; |
| 2853 | case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2854 | case lltok::kw_ret: return ParseRet(Inst, BB, PFS); |
| 2855 | case lltok::kw_br: return ParseBr(Inst, PFS); |
| 2856 | case lltok::kw_switch: return ParseSwitch(Inst, PFS); |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2857 | case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2858 | case lltok::kw_invoke: return ParseInvoke(Inst, PFS); |
| 2859 | // Binary Operators. |
| 2860 | case lltok::kw_add: |
| 2861 | case lltok::kw_sub: |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2862 | case lltok::kw_mul: { |
| 2863 | bool NUW = false; |
| 2864 | bool NSW = false; |
| 2865 | LocTy ModifierLoc = Lex.getLoc(); |
| 2866 | if (EatIfPresent(lltok::kw_nuw)) |
| 2867 | NUW = true; |
| 2868 | if (EatIfPresent(lltok::kw_nsw)) { |
| 2869 | NSW = true; |
| 2870 | if (EatIfPresent(lltok::kw_nuw)) |
| 2871 | NUW = true; |
| 2872 | } |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 2873 | // API compatibility: Accept either integer or floating-point types. |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2874 | bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0); |
| 2875 | if (!Result) { |
| 2876 | if (!Inst->getType()->isIntOrIntVector()) { |
| 2877 | if (NUW) |
| 2878 | return Error(ModifierLoc, "nuw only applies to integer operations"); |
| 2879 | if (NSW) |
| 2880 | return Error(ModifierLoc, "nsw only applies to integer operations"); |
| 2881 | } |
| 2882 | if (NUW) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2883 | cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2884 | if (NSW) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2885 | cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2886 | } |
| 2887 | return Result; |
| 2888 | } |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 2889 | case lltok::kw_fadd: |
| 2890 | case lltok::kw_fsub: |
| 2891 | case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2); |
| 2892 | |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2893 | case lltok::kw_sdiv: { |
| 2894 | bool Exact = false; |
| 2895 | if (EatIfPresent(lltok::kw_exact)) |
| 2896 | Exact = true; |
| 2897 | bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1); |
| 2898 | if (!Result) |
| 2899 | if (Exact) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2900 | cast<BinaryOperator>(Inst)->setIsExact(true); |
Dan Gohman | 59858cf | 2009-07-27 16:11:46 +0000 | [diff] [blame] | 2901 | return Result; |
| 2902 | } |
| 2903 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2904 | case lltok::kw_udiv: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2905 | case lltok::kw_urem: |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 2906 | case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 2907 | case lltok::kw_fdiv: |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 2908 | case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2909 | case lltok::kw_shl: |
| 2910 | case lltok::kw_lshr: |
| 2911 | case lltok::kw_ashr: |
| 2912 | case lltok::kw_and: |
| 2913 | case lltok::kw_or: |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 2914 | case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2915 | case lltok::kw_icmp: |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2916 | case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2917 | // Casts. |
| 2918 | case lltok::kw_trunc: |
| 2919 | case lltok::kw_zext: |
| 2920 | case lltok::kw_sext: |
| 2921 | case lltok::kw_fptrunc: |
| 2922 | case lltok::kw_fpext: |
| 2923 | case lltok::kw_bitcast: |
| 2924 | case lltok::kw_uitofp: |
| 2925 | case lltok::kw_sitofp: |
| 2926 | case lltok::kw_fptoui: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2927 | case lltok::kw_fptosi: |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2928 | case lltok::kw_inttoptr: |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 2929 | case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2930 | // Other. |
| 2931 | case lltok::kw_select: return ParseSelect(Inst, PFS); |
Chris Lattner | 0088a5c | 2009-01-05 08:18:44 +0000 | [diff] [blame] | 2932 | case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2933 | case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS); |
| 2934 | case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS); |
| 2935 | case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS); |
| 2936 | case lltok::kw_phi: return ParsePHI(Inst, PFS); |
| 2937 | case lltok::kw_call: return ParseCall(Inst, PFS, false); |
| 2938 | case lltok::kw_tail: return ParseCall(Inst, PFS, true); |
| 2939 | // Memory. |
Victor Hernandez | 13ad5aa | 2009-10-17 00:00:19 +0000 | [diff] [blame] | 2940 | case lltok::kw_alloca: return ParseAlloc(Inst, PFS); |
| 2941 | case lltok::kw_malloc: return ParseAlloc(Inst, PFS, BB, false); |
Victor Hernandez | 66284e0 | 2009-10-24 04:23:03 +0000 | [diff] [blame] | 2942 | case lltok::kw_free: return ParseFree(Inst, PFS, BB); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2943 | case lltok::kw_load: return ParseLoad(Inst, PFS, false); |
| 2944 | case lltok::kw_store: return ParseStore(Inst, PFS, false); |
| 2945 | case lltok::kw_volatile: |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2946 | if (EatIfPresent(lltok::kw_load)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2947 | return ParseLoad(Inst, PFS, true); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2948 | else if (EatIfPresent(lltok::kw_store)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2949 | return ParseStore(Inst, PFS, true); |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 2950 | else |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2951 | return TokError("expected 'load' or 'store'"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2952 | case lltok::kw_getresult: return ParseGetResult(Inst, PFS); |
| 2953 | case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS); |
| 2954 | case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS); |
| 2955 | case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS); |
| 2956 | } |
| 2957 | } |
| 2958 | |
| 2959 | /// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind. |
| 2960 | bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) { |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2961 | if (Opc == Instruction::FCmp) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 2962 | switch (Lex.getKind()) { |
| 2963 | default: TokError("expected fcmp predicate (e.g. 'oeq')"); |
| 2964 | case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break; |
| 2965 | case lltok::kw_one: P = CmpInst::FCMP_ONE; break; |
| 2966 | case lltok::kw_olt: P = CmpInst::FCMP_OLT; break; |
| 2967 | case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break; |
| 2968 | case lltok::kw_ole: P = CmpInst::FCMP_OLE; break; |
| 2969 | case lltok::kw_oge: P = CmpInst::FCMP_OGE; break; |
| 2970 | case lltok::kw_ord: P = CmpInst::FCMP_ORD; break; |
| 2971 | case lltok::kw_uno: P = CmpInst::FCMP_UNO; break; |
| 2972 | case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break; |
| 2973 | case lltok::kw_une: P = CmpInst::FCMP_UNE; break; |
| 2974 | case lltok::kw_ult: P = CmpInst::FCMP_ULT; break; |
| 2975 | case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break; |
| 2976 | case lltok::kw_ule: P = CmpInst::FCMP_ULE; break; |
| 2977 | case lltok::kw_uge: P = CmpInst::FCMP_UGE; break; |
| 2978 | case lltok::kw_true: P = CmpInst::FCMP_TRUE; break; |
| 2979 | case lltok::kw_false: P = CmpInst::FCMP_FALSE; break; |
| 2980 | } |
| 2981 | } else { |
| 2982 | switch (Lex.getKind()) { |
| 2983 | default: TokError("expected icmp predicate (e.g. 'eq')"); |
| 2984 | case lltok::kw_eq: P = CmpInst::ICMP_EQ; break; |
| 2985 | case lltok::kw_ne: P = CmpInst::ICMP_NE; break; |
| 2986 | case lltok::kw_slt: P = CmpInst::ICMP_SLT; break; |
| 2987 | case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break; |
| 2988 | case lltok::kw_sle: P = CmpInst::ICMP_SLE; break; |
| 2989 | case lltok::kw_sge: P = CmpInst::ICMP_SGE; break; |
| 2990 | case lltok::kw_ult: P = CmpInst::ICMP_ULT; break; |
| 2991 | case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break; |
| 2992 | case lltok::kw_ule: P = CmpInst::ICMP_ULE; break; |
| 2993 | case lltok::kw_uge: P = CmpInst::ICMP_UGE; break; |
| 2994 | } |
| 2995 | } |
| 2996 | Lex.Lex(); |
| 2997 | return false; |
| 2998 | } |
| 2999 | |
| 3000 | //===----------------------------------------------------------------------===// |
| 3001 | // Terminator Instructions. |
| 3002 | //===----------------------------------------------------------------------===// |
| 3003 | |
| 3004 | /// ParseRet - Parse a return instruction. |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 3005 | /// ::= 'ret' void (',' !dbg, !1)* |
| 3006 | /// ::= 'ret' TypeAndValue (',' !dbg, !1)* |
| 3007 | /// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' !dbg, !1)* |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3008 | /// [[obsolete: LLVM 3.0]] |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 3009 | int LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, |
| 3010 | PerFunctionState &PFS) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3011 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 3012 | if (ParseType(Ty, true /*void allowed*/)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3013 | |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 3014 | if (Ty->isVoidTy()) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3015 | Inst = ReturnInst::Create(Context); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3016 | return false; |
| 3017 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3018 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3019 | Value *RV; |
| 3020 | if (ParseValue(Ty, RV, PFS)) return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3021 | |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 3022 | bool ExtraComma = false; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3023 | if (EatIfPresent(lltok::comma)) { |
Devang Patel | 0475c91 | 2009-09-29 00:01:14 +0000 | [diff] [blame] | 3024 | // Parse optional custom metadata, e.g. !dbg |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 3025 | if (Lex.getKind() == lltok::MetadataVar) { |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 3026 | ExtraComma = true; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3027 | } else { |
| 3028 | // The normal case is one return value. |
Chris Lattner | 3f3a0f6 | 2009-12-29 21:25:40 +0000 | [diff] [blame] | 3029 | // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring |
| 3030 | // use of 'ret {i32,i32} {i32 1, i32 2}' |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3031 | SmallVector<Value*, 8> RVs; |
| 3032 | RVs.push_back(RV); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3033 | |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3034 | do { |
Devang Patel | 0475c91 | 2009-09-29 00:01:14 +0000 | [diff] [blame] | 3035 | // If optional custom metadata, e.g. !dbg is seen then this is the |
| 3036 | // end of MRV. |
Chris Lattner | 1d92831 | 2009-12-30 05:02:06 +0000 | [diff] [blame] | 3037 | if (Lex.getKind() == lltok::MetadataVar) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3038 | break; |
| 3039 | if (ParseTypeAndValue(RV, PFS)) return true; |
| 3040 | RVs.push_back(RV); |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3041 | } while (EatIfPresent(lltok::comma)); |
| 3042 | |
| 3043 | RV = UndefValue::get(PFS.getFunction().getReturnType()); |
| 3044 | for (unsigned i = 0, e = RVs.size(); i != e; ++i) { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3045 | Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv"); |
| 3046 | BB->getInstList().push_back(I); |
| 3047 | RV = I; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3048 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3049 | } |
| 3050 | } |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3051 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3052 | Inst = ReturnInst::Create(Context, RV); |
Chris Lattner | f1bc7ce | 2009-12-30 05:23:43 +0000 | [diff] [blame] | 3053 | return ExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3054 | } |
| 3055 | |
| 3056 | |
| 3057 | /// ParseBr |
| 3058 | /// ::= 'br' TypeAndValue |
| 3059 | /// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue |
| 3060 | bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { |
| 3061 | LocTy Loc, Loc2; |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3062 | Value *Op0; |
| 3063 | BasicBlock *Op1, *Op2; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3064 | if (ParseTypeAndValue(Op0, Loc, PFS)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3065 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3066 | if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) { |
| 3067 | Inst = BranchInst::Create(BB); |
| 3068 | return false; |
| 3069 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3070 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3071 | if (Op0->getType() != Type::getInt1Ty(Context)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3072 | return Error(Loc, "branch condition must have 'i1' type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3073 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3074 | if (ParseToken(lltok::comma, "expected ',' after branch condition") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3075 | ParseTypeAndBasicBlock(Op1, Loc, PFS) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3076 | ParseToken(lltok::comma, "expected ',' after true destination") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3077 | ParseTypeAndBasicBlock(Op2, Loc2, PFS)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3078 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3079 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3080 | Inst = BranchInst::Create(Op1, Op2, Op0); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3081 | return false; |
| 3082 | } |
| 3083 | |
| 3084 | /// ParseSwitch |
| 3085 | /// Instruction |
| 3086 | /// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']' |
| 3087 | /// JumpTable |
| 3088 | /// ::= (TypeAndValue ',' TypeAndValue)* |
| 3089 | bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) { |
| 3090 | LocTy CondLoc, BBLoc; |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3091 | Value *Cond; |
| 3092 | BasicBlock *DefaultBB; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3093 | if (ParseTypeAndValue(Cond, CondLoc, PFS) || |
| 3094 | ParseToken(lltok::comma, "expected ',' after switch condition") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3095 | ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3096 | ParseToken(lltok::lsquare, "expected '[' with switch table")) |
| 3097 | return true; |
| 3098 | |
| 3099 | if (!isa<IntegerType>(Cond->getType())) |
| 3100 | return Error(CondLoc, "switch condition must have integer type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3101 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3102 | // Parse the jump table pairs. |
| 3103 | SmallPtrSet<Value*, 32> SeenCases; |
| 3104 | SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table; |
| 3105 | while (Lex.getKind() != lltok::rsquare) { |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3106 | Value *Constant; |
| 3107 | BasicBlock *DestBB; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3108 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3109 | if (ParseTypeAndValue(Constant, CondLoc, PFS) || |
| 3110 | ParseToken(lltok::comma, "expected ',' after case value") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3111 | ParseTypeAndBasicBlock(DestBB, PFS)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3112 | return true; |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3113 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3114 | if (!SeenCases.insert(Constant)) |
| 3115 | return Error(CondLoc, "duplicate case value in switch"); |
| 3116 | if (!isa<ConstantInt>(Constant)) |
| 3117 | return Error(CondLoc, "case value is not a constant integer"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3118 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3119 | Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3120 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3121 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3122 | Lex.Lex(); // Eat the ']'. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3123 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3124 | SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size()); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3125 | for (unsigned i = 0, e = Table.size(); i != e; ++i) |
| 3126 | SI->addCase(Table[i].first, Table[i].second); |
| 3127 | Inst = SI; |
| 3128 | return false; |
| 3129 | } |
| 3130 | |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 3131 | /// ParseIndirectBr |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3132 | /// Instruction |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 3133 | /// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']' |
| 3134 | bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) { |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3135 | LocTy AddrLoc; |
| 3136 | Value *Address; |
| 3137 | if (ParseTypeAndValue(Address, AddrLoc, PFS) || |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 3138 | ParseToken(lltok::comma, "expected ',' after indirectbr address") || |
| 3139 | ParseToken(lltok::lsquare, "expected '[' with indirectbr")) |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3140 | return true; |
| 3141 | |
| 3142 | if (!isa<PointerType>(Address->getType())) |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 3143 | return Error(AddrLoc, "indirectbr address must have pointer type"); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3144 | |
| 3145 | // Parse the destination list. |
| 3146 | SmallVector<BasicBlock*, 16> DestList; |
| 3147 | |
| 3148 | if (Lex.getKind() != lltok::rsquare) { |
| 3149 | BasicBlock *DestBB; |
| 3150 | if (ParseTypeAndBasicBlock(DestBB, PFS)) |
| 3151 | return true; |
| 3152 | DestList.push_back(DestBB); |
| 3153 | |
| 3154 | while (EatIfPresent(lltok::comma)) { |
| 3155 | if (ParseTypeAndBasicBlock(DestBB, PFS)) |
| 3156 | return true; |
| 3157 | DestList.push_back(DestBB); |
| 3158 | } |
| 3159 | } |
| 3160 | |
| 3161 | if (ParseToken(lltok::rsquare, "expected ']' at end of block list")) |
| 3162 | return true; |
| 3163 | |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 3164 | IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size()); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3165 | for (unsigned i = 0, e = DestList.size(); i != e; ++i) |
| 3166 | IBI->addDestination(DestList[i]); |
| 3167 | Inst = IBI; |
| 3168 | return false; |
| 3169 | } |
| 3170 | |
| 3171 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3172 | /// ParseInvoke |
| 3173 | /// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList |
| 3174 | /// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue |
| 3175 | bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { |
| 3176 | LocTy CallLoc = Lex.getLoc(); |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 3177 | unsigned RetAttrs, FnAttrs; |
| 3178 | CallingConv::ID CC; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3179 | PATypeHolder RetType(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3180 | LocTy RetTypeLoc; |
| 3181 | ValID CalleeID; |
| 3182 | SmallVector<ParamInfo, 16> ArgList; |
| 3183 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3184 | BasicBlock *NormalBB, *UnwindBB; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3185 | if (ParseOptionalCallingConv(CC) || |
| 3186 | ParseOptionalAttrs(RetAttrs, 1) || |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 3187 | ParseType(RetType, RetTypeLoc, true /*void allowed*/) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3188 | ParseValID(CalleeID) || |
| 3189 | ParseParameterList(ArgList, PFS) || |
| 3190 | ParseOptionalAttrs(FnAttrs, 2) || |
| 3191 | ParseToken(lltok::kw_to, "expected 'to' in invoke") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3192 | ParseTypeAndBasicBlock(NormalBB, PFS) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3193 | ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3194 | ParseTypeAndBasicBlock(UnwindBB, PFS)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3195 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3196 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3197 | // If RetType is a non-function pointer type, then this is the short syntax |
| 3198 | // for the call, which means that RetType is just the return type. Infer the |
| 3199 | // rest of the function argument types from the arguments that are present. |
| 3200 | const PointerType *PFTy = 0; |
| 3201 | const FunctionType *Ty = 0; |
| 3202 | if (!(PFTy = dyn_cast<PointerType>(RetType)) || |
| 3203 | !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { |
| 3204 | // Pull out the types of all of the arguments... |
| 3205 | std::vector<const Type*> ParamTypes; |
| 3206 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) |
| 3207 | ParamTypes.push_back(ArgList[i].V->getType()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3208 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3209 | if (!FunctionType::isValidReturnType(RetType)) |
| 3210 | return Error(RetTypeLoc, "Invalid result type for LLVM function"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3211 | |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 3212 | Ty = FunctionType::get(RetType, ParamTypes, false); |
| 3213 | PFTy = PointerType::getUnqual(Ty); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3214 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3215 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3216 | // Look up the callee. |
| 3217 | Value *Callee; |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 3218 | if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3219 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3220 | // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional |
| 3221 | // function attributes. |
| 3222 | unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; |
| 3223 | if (FnAttrs & ObsoleteFuncAttrs) { |
| 3224 | RetAttrs |= FnAttrs & ObsoleteFuncAttrs; |
| 3225 | FnAttrs &= ~ObsoleteFuncAttrs; |
| 3226 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3227 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3228 | // Set up the Attributes for the function. |
| 3229 | SmallVector<AttributeWithIndex, 8> Attrs; |
| 3230 | if (RetAttrs != Attribute::None) |
| 3231 | Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3232 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3233 | SmallVector<Value*, 8> Args; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3234 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3235 | // Loop through FunctionType's arguments and ensure they are specified |
| 3236 | // correctly. Also, gather any parameter attributes. |
| 3237 | FunctionType::param_iterator I = Ty->param_begin(); |
| 3238 | FunctionType::param_iterator E = Ty->param_end(); |
| 3239 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { |
| 3240 | const Type *ExpectedTy = 0; |
| 3241 | if (I != E) { |
| 3242 | ExpectedTy = *I++; |
| 3243 | } else if (!Ty->isVarArg()) { |
| 3244 | return Error(ArgList[i].Loc, "too many arguments specified"); |
| 3245 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3246 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3247 | if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) |
| 3248 | return Error(ArgList[i].Loc, "argument is not of expected type '" + |
| 3249 | ExpectedTy->getDescription() + "'"); |
| 3250 | Args.push_back(ArgList[i].V); |
| 3251 | if (ArgList[i].Attrs != Attribute::None) |
| 3252 | Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); |
| 3253 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3254 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3255 | if (I != E) |
| 3256 | return Error(CallLoc, "not enough parameters specified for call"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3257 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3258 | if (FnAttrs != Attribute::None) |
| 3259 | Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3260 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3261 | // Finish off the Attributes and check them |
| 3262 | AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3263 | |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 3264 | InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB, |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3265 | Args.begin(), Args.end()); |
| 3266 | II->setCallingConv(CC); |
| 3267 | II->setAttributes(PAL); |
| 3268 | Inst = II; |
| 3269 | return false; |
| 3270 | } |
| 3271 | |
| 3272 | |
| 3273 | |
| 3274 | //===----------------------------------------------------------------------===// |
| 3275 | // Binary Operators. |
| 3276 | //===----------------------------------------------------------------------===// |
| 3277 | |
| 3278 | /// ParseArithmetic |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 3279 | /// ::= ArithmeticOps TypeAndValue ',' Value |
| 3280 | /// |
| 3281 | /// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, |
| 3282 | /// then any integer operand is allowed, if it is 2, any fp operand is allowed. |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3283 | bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 3284 | unsigned Opc, unsigned OperandType) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3285 | LocTy Loc; Value *LHS, *RHS; |
| 3286 | if (ParseTypeAndValue(LHS, Loc, PFS) || |
| 3287 | ParseToken(lltok::comma, "expected ',' in arithmetic operation") || |
| 3288 | ParseValue(LHS->getType(), RHS, PFS)) |
| 3289 | return true; |
| 3290 | |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 3291 | bool Valid; |
| 3292 | switch (OperandType) { |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 3293 | default: llvm_unreachable("Unknown operand type!"); |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 3294 | case 0: // int or FP. |
| 3295 | Valid = LHS->getType()->isIntOrIntVector() || |
| 3296 | LHS->getType()->isFPOrFPVector(); |
| 3297 | break; |
| 3298 | case 1: Valid = LHS->getType()->isIntOrIntVector(); break; |
| 3299 | case 2: Valid = LHS->getType()->isFPOrFPVector(); break; |
| 3300 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3301 | |
Chris Lattner | e914b59 | 2009-01-05 08:24:46 +0000 | [diff] [blame] | 3302 | if (!Valid) |
| 3303 | return Error(Loc, "invalid operand type for instruction"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3304 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3305 | Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); |
| 3306 | return false; |
| 3307 | } |
| 3308 | |
| 3309 | /// ParseLogical |
| 3310 | /// ::= ArithmeticOps TypeAndValue ',' Value { |
| 3311 | bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS, |
| 3312 | unsigned Opc) { |
| 3313 | LocTy Loc; Value *LHS, *RHS; |
| 3314 | if (ParseTypeAndValue(LHS, Loc, PFS) || |
| 3315 | ParseToken(lltok::comma, "expected ',' in logical operation") || |
| 3316 | ParseValue(LHS->getType(), RHS, PFS)) |
| 3317 | return true; |
| 3318 | |
| 3319 | if (!LHS->getType()->isIntOrIntVector()) |
| 3320 | return Error(Loc,"instruction requires integer or integer vector operands"); |
| 3321 | |
| 3322 | Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); |
| 3323 | return false; |
| 3324 | } |
| 3325 | |
| 3326 | |
| 3327 | /// ParseCompare |
| 3328 | /// ::= 'icmp' IPredicates TypeAndValue ',' Value |
| 3329 | /// ::= 'fcmp' FPredicates TypeAndValue ',' Value |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3330 | bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS, |
| 3331 | unsigned Opc) { |
| 3332 | // Parse the integer/fp comparison predicate. |
| 3333 | LocTy Loc; |
| 3334 | unsigned Pred; |
| 3335 | Value *LHS, *RHS; |
| 3336 | if (ParseCmpPredicate(Pred, Opc) || |
| 3337 | ParseTypeAndValue(LHS, Loc, PFS) || |
| 3338 | ParseToken(lltok::comma, "expected ',' after compare value") || |
| 3339 | ParseValue(LHS->getType(), RHS, PFS)) |
| 3340 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3341 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3342 | if (Opc == Instruction::FCmp) { |
| 3343 | if (!LHS->getType()->isFPOrFPVector()) |
| 3344 | return Error(Loc, "fcmp requires floating point operands"); |
Dan Gohman | 1c8a23c | 2009-08-25 23:17:54 +0000 | [diff] [blame] | 3345 | Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS); |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 3346 | } else { |
| 3347 | assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3348 | if (!LHS->getType()->isIntOrIntVector() && |
| 3349 | !isa<PointerType>(LHS->getType())) |
| 3350 | return Error(Loc, "icmp requires integer operands"); |
Dan Gohman | 1c8a23c | 2009-08-25 23:17:54 +0000 | [diff] [blame] | 3351 | Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3352 | } |
| 3353 | return false; |
| 3354 | } |
| 3355 | |
| 3356 | //===----------------------------------------------------------------------===// |
| 3357 | // Other Instructions. |
| 3358 | //===----------------------------------------------------------------------===// |
| 3359 | |
| 3360 | |
| 3361 | /// ParseCast |
| 3362 | /// ::= CastOpc TypeAndValue 'to' Type |
| 3363 | bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS, |
| 3364 | unsigned Opc) { |
| 3365 | LocTy Loc; Value *Op; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3366 | PATypeHolder DestTy(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3367 | if (ParseTypeAndValue(Op, Loc, PFS) || |
| 3368 | ParseToken(lltok::kw_to, "expected 'to' after cast value") || |
| 3369 | ParseType(DestTy)) |
| 3370 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3371 | |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 3372 | if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) { |
| 3373 | CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3374 | return Error(Loc, "invalid cast opcode for cast from '" + |
| 3375 | Op->getType()->getDescription() + "' to '" + |
| 3376 | DestTy->getDescription() + "'"); |
Chris Lattner | f6f0bdf | 2009-03-01 00:53:13 +0000 | [diff] [blame] | 3377 | } |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3378 | Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy); |
| 3379 | return false; |
| 3380 | } |
| 3381 | |
| 3382 | /// ParseSelect |
| 3383 | /// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue |
| 3384 | bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) { |
| 3385 | LocTy Loc; |
| 3386 | Value *Op0, *Op1, *Op2; |
| 3387 | if (ParseTypeAndValue(Op0, Loc, PFS) || |
| 3388 | ParseToken(lltok::comma, "expected ',' after select condition") || |
| 3389 | ParseTypeAndValue(Op1, PFS) || |
| 3390 | ParseToken(lltok::comma, "expected ',' after select value") || |
| 3391 | ParseTypeAndValue(Op2, PFS)) |
| 3392 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3393 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3394 | if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2)) |
| 3395 | return Error(Loc, Reason); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3396 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3397 | Inst = SelectInst::Create(Op0, Op1, Op2); |
| 3398 | return false; |
| 3399 | } |
| 3400 | |
Chris Lattner | 0088a5c | 2009-01-05 08:18:44 +0000 | [diff] [blame] | 3401 | /// ParseVA_Arg |
| 3402 | /// ::= 'va_arg' TypeAndValue ',' Type |
| 3403 | bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3404 | Value *Op; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3405 | PATypeHolder EltTy(Type::getVoidTy(Context)); |
Chris Lattner | 0088a5c | 2009-01-05 08:18:44 +0000 | [diff] [blame] | 3406 | LocTy TypeLoc; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3407 | if (ParseTypeAndValue(Op, PFS) || |
| 3408 | ParseToken(lltok::comma, "expected ',' after vaarg operand") || |
Chris Lattner | 0088a5c | 2009-01-05 08:18:44 +0000 | [diff] [blame] | 3409 | ParseType(EltTy, TypeLoc)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3410 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3411 | |
Chris Lattner | 0088a5c | 2009-01-05 08:18:44 +0000 | [diff] [blame] | 3412 | if (!EltTy->isFirstClassType()) |
| 3413 | return Error(TypeLoc, "va_arg requires operand with first class type"); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3414 | |
| 3415 | Inst = new VAArgInst(Op, EltTy); |
| 3416 | return false; |
| 3417 | } |
| 3418 | |
| 3419 | /// ParseExtractElement |
| 3420 | /// ::= 'extractelement' TypeAndValue ',' TypeAndValue |
| 3421 | bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { |
| 3422 | LocTy Loc; |
| 3423 | Value *Op0, *Op1; |
| 3424 | if (ParseTypeAndValue(Op0, Loc, PFS) || |
| 3425 | ParseToken(lltok::comma, "expected ',' after extract value") || |
| 3426 | ParseTypeAndValue(Op1, PFS)) |
| 3427 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3428 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3429 | if (!ExtractElementInst::isValidOperands(Op0, Op1)) |
| 3430 | return Error(Loc, "invalid extractelement operands"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3431 | |
Eric Christopher | a3500da | 2009-07-25 02:28:41 +0000 | [diff] [blame] | 3432 | Inst = ExtractElementInst::Create(Op0, Op1); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3433 | return false; |
| 3434 | } |
| 3435 | |
| 3436 | /// ParseInsertElement |
| 3437 | /// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue |
| 3438 | bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { |
| 3439 | LocTy Loc; |
| 3440 | Value *Op0, *Op1, *Op2; |
| 3441 | if (ParseTypeAndValue(Op0, Loc, PFS) || |
| 3442 | ParseToken(lltok::comma, "expected ',' after insertelement value") || |
| 3443 | ParseTypeAndValue(Op1, PFS) || |
| 3444 | ParseToken(lltok::comma, "expected ',' after insertelement value") || |
| 3445 | ParseTypeAndValue(Op2, PFS)) |
| 3446 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3447 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3448 | if (!InsertElementInst::isValidOperands(Op0, Op1, Op2)) |
Eric Christopher | 0aaf4e9 | 2009-07-23 01:01:32 +0000 | [diff] [blame] | 3449 | return Error(Loc, "invalid insertelement operands"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3450 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3451 | Inst = InsertElementInst::Create(Op0, Op1, Op2); |
| 3452 | return false; |
| 3453 | } |
| 3454 | |
| 3455 | /// ParseShuffleVector |
| 3456 | /// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue |
| 3457 | bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { |
| 3458 | LocTy Loc; |
| 3459 | Value *Op0, *Op1, *Op2; |
| 3460 | if (ParseTypeAndValue(Op0, Loc, PFS) || |
| 3461 | ParseToken(lltok::comma, "expected ',' after shuffle mask") || |
| 3462 | ParseTypeAndValue(Op1, PFS) || |
| 3463 | ParseToken(lltok::comma, "expected ',' after shuffle value") || |
| 3464 | ParseTypeAndValue(Op2, PFS)) |
| 3465 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3466 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3467 | if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2)) |
| 3468 | return Error(Loc, "invalid extractelement operands"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3469 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3470 | Inst = new ShuffleVectorInst(Op0, Op1, Op2); |
| 3471 | return false; |
| 3472 | } |
| 3473 | |
| 3474 | /// ParsePHI |
Chris Lattner | c6e2009 | 2009-10-18 05:27:44 +0000 | [diff] [blame] | 3475 | /// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')* |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3476 | int LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3477 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3478 | Value *Op0, *Op1; |
| 3479 | LocTy TypeLoc = Lex.getLoc(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3480 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3481 | if (ParseType(Ty) || |
| 3482 | ParseToken(lltok::lsquare, "expected '[' in phi value list") || |
| 3483 | ParseValue(Ty, Op0, PFS) || |
| 3484 | ParseToken(lltok::comma, "expected ',' after insertelement value") || |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3485 | ParseValue(Type::getLabelTy(Context), Op1, PFS) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3486 | ParseToken(lltok::rsquare, "expected ']' in phi value list")) |
| 3487 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3488 | |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3489 | bool AteExtraComma = false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3490 | SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals; |
| 3491 | while (1) { |
| 3492 | PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1))); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3493 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3494 | if (!EatIfPresent(lltok::comma)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3495 | break; |
| 3496 | |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3497 | if (Lex.getKind() == lltok::MetadataVar) { |
| 3498 | AteExtraComma = true; |
Devang Patel | a43d46f | 2009-10-16 18:45:49 +0000 | [diff] [blame] | 3499 | break; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3500 | } |
Devang Patel | a43d46f | 2009-10-16 18:45:49 +0000 | [diff] [blame] | 3501 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3502 | if (ParseToken(lltok::lsquare, "expected '[' in phi value list") || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3503 | ParseValue(Ty, Op0, PFS) || |
| 3504 | ParseToken(lltok::comma, "expected ',' after insertelement value") || |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3505 | ParseValue(Type::getLabelTy(Context), Op1, PFS) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3506 | ParseToken(lltok::rsquare, "expected ']' in phi value list")) |
| 3507 | return true; |
| 3508 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3509 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3510 | if (!Ty->isFirstClassType()) |
| 3511 | return Error(TypeLoc, "phi node must have first class type"); |
| 3512 | |
| 3513 | PHINode *PN = PHINode::Create(Ty); |
| 3514 | PN->reserveOperandSpace(PHIVals.size()); |
| 3515 | for (unsigned i = 0, e = PHIVals.size(); i != e; ++i) |
| 3516 | PN->addIncoming(PHIVals[i].first, PHIVals[i].second); |
| 3517 | Inst = PN; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3518 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3519 | } |
| 3520 | |
| 3521 | /// ParseCall |
| 3522 | /// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value |
| 3523 | /// ParameterList OptionalAttrs |
| 3524 | bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, |
| 3525 | bool isTail) { |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 3526 | unsigned RetAttrs, FnAttrs; |
| 3527 | CallingConv::ID CC; |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3528 | PATypeHolder RetType(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3529 | LocTy RetTypeLoc; |
| 3530 | ValID CalleeID; |
| 3531 | SmallVector<ParamInfo, 16> ArgList; |
| 3532 | LocTy CallLoc = Lex.getLoc(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3533 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3534 | if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) || |
| 3535 | ParseOptionalCallingConv(CC) || |
| 3536 | ParseOptionalAttrs(RetAttrs, 1) || |
Chris Lattner | a9a9e07 | 2009-03-09 04:49:14 +0000 | [diff] [blame] | 3537 | ParseType(RetType, RetTypeLoc, true /*void allowed*/) || |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3538 | ParseValID(CalleeID) || |
| 3539 | ParseParameterList(ArgList, PFS) || |
| 3540 | ParseOptionalAttrs(FnAttrs, 2)) |
| 3541 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3542 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3543 | // If RetType is a non-function pointer type, then this is the short syntax |
| 3544 | // for the call, which means that RetType is just the return type. Infer the |
| 3545 | // rest of the function argument types from the arguments that are present. |
| 3546 | const PointerType *PFTy = 0; |
| 3547 | const FunctionType *Ty = 0; |
| 3548 | if (!(PFTy = dyn_cast<PointerType>(RetType)) || |
| 3549 | !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { |
| 3550 | // Pull out the types of all of the arguments... |
| 3551 | std::vector<const Type*> ParamTypes; |
| 3552 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) |
| 3553 | ParamTypes.push_back(ArgList[i].V->getType()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3554 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3555 | if (!FunctionType::isValidReturnType(RetType)) |
| 3556 | return Error(RetTypeLoc, "Invalid result type for LLVM function"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3557 | |
Owen Anderson | debcb01 | 2009-07-29 22:17:13 +0000 | [diff] [blame] | 3558 | Ty = FunctionType::get(RetType, ParamTypes, false); |
| 3559 | PFTy = PointerType::getUnqual(Ty); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3560 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3561 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3562 | // Look up the callee. |
| 3563 | Value *Callee; |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 3564 | if (ConvertValIDToValue(PFTy, CalleeID, Callee, &PFS)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3565 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3566 | // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional |
| 3567 | // function attributes. |
| 3568 | unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; |
| 3569 | if (FnAttrs & ObsoleteFuncAttrs) { |
| 3570 | RetAttrs |= FnAttrs & ObsoleteFuncAttrs; |
| 3571 | FnAttrs &= ~ObsoleteFuncAttrs; |
| 3572 | } |
| 3573 | |
| 3574 | // Set up the Attributes for the function. |
| 3575 | SmallVector<AttributeWithIndex, 8> Attrs; |
| 3576 | if (RetAttrs != Attribute::None) |
| 3577 | Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3578 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3579 | SmallVector<Value*, 8> Args; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3580 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3581 | // Loop through FunctionType's arguments and ensure they are specified |
| 3582 | // correctly. Also, gather any parameter attributes. |
| 3583 | FunctionType::param_iterator I = Ty->param_begin(); |
| 3584 | FunctionType::param_iterator E = Ty->param_end(); |
| 3585 | for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { |
| 3586 | const Type *ExpectedTy = 0; |
| 3587 | if (I != E) { |
| 3588 | ExpectedTy = *I++; |
| 3589 | } else if (!Ty->isVarArg()) { |
| 3590 | return Error(ArgList[i].Loc, "too many arguments specified"); |
| 3591 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3592 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3593 | if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) |
| 3594 | return Error(ArgList[i].Loc, "argument is not of expected type '" + |
| 3595 | ExpectedTy->getDescription() + "'"); |
| 3596 | Args.push_back(ArgList[i].V); |
| 3597 | if (ArgList[i].Attrs != Attribute::None) |
| 3598 | Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); |
| 3599 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3600 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3601 | if (I != E) |
| 3602 | return Error(CallLoc, "not enough parameters specified for call"); |
| 3603 | |
| 3604 | if (FnAttrs != Attribute::None) |
| 3605 | Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); |
| 3606 | |
| 3607 | // Finish off the Attributes and check them |
| 3608 | AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3609 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3610 | CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end()); |
| 3611 | CI->setTailCall(isTail); |
| 3612 | CI->setCallingConv(CC); |
| 3613 | CI->setAttributes(PAL); |
| 3614 | Inst = CI; |
| 3615 | return false; |
| 3616 | } |
| 3617 | |
| 3618 | //===----------------------------------------------------------------------===// |
| 3619 | // Memory Instructions. |
| 3620 | //===----------------------------------------------------------------------===// |
| 3621 | |
| 3622 | /// ParseAlloc |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3623 | /// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)? |
| 3624 | /// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)? |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3625 | int LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS, |
| 3626 | BasicBlock* BB, bool isAlloca) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 3627 | PATypeHolder Ty(Type::getVoidTy(Context)); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3628 | Value *Size = 0; |
Chris Lattner | eeb4a84 | 2009-07-02 23:08:13 +0000 | [diff] [blame] | 3629 | LocTy SizeLoc; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3630 | unsigned Alignment = 0; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3631 | if (ParseType(Ty)) return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3632 | |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3633 | bool AteExtraComma = false; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3634 | if (EatIfPresent(lltok::comma)) { |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3635 | if (Lex.getKind() == lltok::kw_align) { |
| 3636 | if (ParseOptionalAlignment(Alignment)) return true; |
| 3637 | } else if (Lex.getKind() == lltok::MetadataVar) { |
| 3638 | AteExtraComma = true; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3639 | } else { |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3640 | if (ParseTypeAndValue(Size, SizeLoc, PFS) || |
| 3641 | ParseOptionalCommaAlign(Alignment, AteExtraComma)) |
| 3642 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3643 | } |
| 3644 | } |
| 3645 | |
Benjamin Kramer | 8c65f6e | 2010-01-05 21:05:54 +0000 | [diff] [blame] | 3646 | if (Size && !Size->getType()->isInteger(32)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3647 | return Error(SizeLoc, "element count must be i32"); |
| 3648 | |
Victor Hernandez | 68afa54 | 2009-10-21 19:11:40 +0000 | [diff] [blame] | 3649 | if (isAlloca) { |
Owen Anderson | 50dead0 | 2009-07-15 23:53:25 +0000 | [diff] [blame] | 3650 | Inst = new AllocaInst(Ty, Size, Alignment); |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3651 | return AteExtraComma ? InstExtraComma : InstNormal; |
Victor Hernandez | 13ad5aa | 2009-10-17 00:00:19 +0000 | [diff] [blame] | 3652 | } |
Victor Hernandez | 68afa54 | 2009-10-21 19:11:40 +0000 | [diff] [blame] | 3653 | |
| 3654 | // Autoupgrade old malloc instruction to malloc call. |
| 3655 | // FIXME: Remove in LLVM 3.0. |
| 3656 | const Type *IntPtrTy = Type::getInt32Ty(Context); |
Victor Hernandez | 9d0b704 | 2009-11-07 00:16:28 +0000 | [diff] [blame] | 3657 | Constant *AllocSize = ConstantExpr::getSizeOf(Ty); |
| 3658 | AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy); |
Victor Hernandez | 68afa54 | 2009-10-21 19:11:40 +0000 | [diff] [blame] | 3659 | if (!MallocF) |
| 3660 | // Prototype malloc as "void *(int32)". |
| 3661 | // This function is renamed as "malloc" in ValidateEndOfModule(). |
Victor Hernandez | 336ea06 | 2009-10-23 00:59:10 +0000 | [diff] [blame] | 3662 | MallocF = cast<Function>( |
| 3663 | M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL)); |
Victor Hernandez | 9d0b704 | 2009-11-07 00:16:28 +0000 | [diff] [blame] | 3664 | Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF); |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3665 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3666 | } |
| 3667 | |
| 3668 | /// ParseFree |
| 3669 | /// ::= 'free' TypeAndValue |
Victor Hernandez | 66284e0 | 2009-10-24 04:23:03 +0000 | [diff] [blame] | 3670 | bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS, |
| 3671 | BasicBlock* BB) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3672 | Value *Val; LocTy Loc; |
| 3673 | if (ParseTypeAndValue(Val, Loc, PFS)) return true; |
| 3674 | if (!isa<PointerType>(Val->getType())) |
| 3675 | return Error(Loc, "operand to free must be a pointer"); |
Victor Hernandez | 66284e0 | 2009-10-24 04:23:03 +0000 | [diff] [blame] | 3676 | Inst = CallInst::CreateFree(Val, BB); |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3677 | return false; |
| 3678 | } |
| 3679 | |
| 3680 | /// ParseLoad |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3681 | /// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)? |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3682 | int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS, |
| 3683 | bool isVolatile) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3684 | Value *Val; LocTy Loc; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3685 | unsigned Alignment = 0; |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3686 | bool AteExtraComma = false; |
| 3687 | if (ParseTypeAndValue(Val, Loc, PFS) || |
| 3688 | ParseOptionalCommaAlign(Alignment, AteExtraComma)) |
| 3689 | return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3690 | |
| 3691 | if (!isa<PointerType>(Val->getType()) || |
| 3692 | !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType()) |
| 3693 | return Error(Loc, "load operand must be a pointer to a first class type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3694 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3695 | Inst = new LoadInst(Val, "", isVolatile, Alignment); |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3696 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3697 | } |
| 3698 | |
| 3699 | /// ParseStore |
Dan Gohman | a119de8 | 2009-06-14 23:30:43 +0000 | [diff] [blame] | 3700 | /// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)? |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3701 | int LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS, |
| 3702 | bool isVolatile) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3703 | Value *Val, *Ptr; LocTy Loc, PtrLoc; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3704 | unsigned Alignment = 0; |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3705 | bool AteExtraComma = false; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3706 | if (ParseTypeAndValue(Val, Loc, PFS) || |
| 3707 | ParseToken(lltok::comma, "expected ',' after store operand") || |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3708 | ParseTypeAndValue(Ptr, PtrLoc, PFS) || |
| 3709 | ParseOptionalCommaAlign(Alignment, AteExtraComma)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3710 | return true; |
Devang Patel | f633a06 | 2009-09-17 23:04:48 +0000 | [diff] [blame] | 3711 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3712 | if (!isa<PointerType>(Ptr->getType())) |
| 3713 | return Error(PtrLoc, "store operand must be a pointer"); |
| 3714 | if (!Val->getType()->isFirstClassType()) |
| 3715 | return Error(Loc, "store operand must be a first class value"); |
| 3716 | if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType()) |
| 3717 | return Error(Loc, "stored value and pointer type do not match"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3718 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3719 | Inst = new StoreInst(Val, Ptr, isVolatile, Alignment); |
Chris Lattner | c3a6c5c | 2009-12-30 05:44:30 +0000 | [diff] [blame] | 3720 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3721 | } |
| 3722 | |
| 3723 | /// ParseGetResult |
Dan Gohman | a119de8 | 2009-06-14 23:30:43 +0000 | [diff] [blame] | 3724 | /// ::= 'getresult' TypeAndValue ',' i32 |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3725 | /// FIXME: Remove support for getresult in LLVM 3.0 |
| 3726 | bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) { |
| 3727 | Value *Val; LocTy ValLoc, EltLoc; |
| 3728 | unsigned Element; |
| 3729 | if (ParseTypeAndValue(Val, ValLoc, PFS) || |
| 3730 | ParseToken(lltok::comma, "expected ',' after getresult operand") || |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3731 | ParseUInt32(Element, EltLoc)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3732 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3733 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3734 | if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) |
| 3735 | return Error(ValLoc, "getresult inst requires an aggregate operand"); |
| 3736 | if (!ExtractValueInst::getIndexedType(Val->getType(), Element)) |
| 3737 | return Error(EltLoc, "invalid getresult index for value"); |
| 3738 | Inst = ExtractValueInst::Create(Val, Element); |
| 3739 | return false; |
| 3740 | } |
| 3741 | |
| 3742 | /// ParseGetElementPtr |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 3743 | /// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)* |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3744 | int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3745 | Value *Ptr, *Val; LocTy Loc, EltLoc; |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 3746 | |
Dan Gohman | dcb40a3 | 2009-07-29 15:58:36 +0000 | [diff] [blame] | 3747 | bool InBounds = EatIfPresent(lltok::kw_inbounds); |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 3748 | |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3749 | if (ParseTypeAndValue(Ptr, Loc, PFS)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3750 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3751 | if (!isa<PointerType>(Ptr->getType())) |
| 3752 | return Error(Loc, "base of getelementptr must be a pointer"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3753 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3754 | SmallVector<Value*, 16> Indices; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3755 | bool AteExtraComma = false; |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3756 | while (EatIfPresent(lltok::comma)) { |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3757 | if (Lex.getKind() == lltok::MetadataVar) { |
| 3758 | AteExtraComma = true; |
Devang Patel | 6225d64 | 2009-10-13 18:49:55 +0000 | [diff] [blame] | 3759 | break; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3760 | } |
Chris Lattner | 3ed88ef | 2009-01-02 08:05:26 +0000 | [diff] [blame] | 3761 | if (ParseTypeAndValue(Val, EltLoc, PFS)) return true; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3762 | if (!isa<IntegerType>(Val->getType())) |
| 3763 | return Error(EltLoc, "getelementptr index must be an integer"); |
| 3764 | Indices.push_back(Val); |
| 3765 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3766 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3767 | if (!GetElementPtrInst::getIndexedType(Ptr->getType(), |
| 3768 | Indices.begin(), Indices.end())) |
| 3769 | return Error(Loc, "invalid getelementptr indices"); |
| 3770 | Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end()); |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 3771 | if (InBounds) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 3772 | cast<GetElementPtrInst>(Inst)->setIsInBounds(true); |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3773 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3774 | } |
| 3775 | |
| 3776 | /// ParseExtractValue |
| 3777 | /// ::= 'extractvalue' TypeAndValue (',' uint32)+ |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3778 | int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3779 | Value *Val; LocTy Loc; |
| 3780 | SmallVector<unsigned, 4> Indices; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3781 | bool AteExtraComma; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3782 | if (ParseTypeAndValue(Val, Loc, PFS) || |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3783 | ParseIndexList(Indices, AteExtraComma)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3784 | return true; |
| 3785 | |
| 3786 | if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) |
| 3787 | return Error(Loc, "extractvalue operand must be array or struct"); |
| 3788 | |
| 3789 | if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), |
| 3790 | Indices.end())) |
| 3791 | return Error(Loc, "invalid indices for extractvalue"); |
| 3792 | Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end()); |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3793 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3794 | } |
| 3795 | |
| 3796 | /// ParseInsertValue |
| 3797 | /// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+ |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3798 | int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3799 | Value *Val0, *Val1; LocTy Loc0, Loc1; |
| 3800 | SmallVector<unsigned, 4> Indices; |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3801 | bool AteExtraComma; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3802 | if (ParseTypeAndValue(Val0, Loc0, PFS) || |
| 3803 | ParseToken(lltok::comma, "expected comma after insertvalue operand") || |
| 3804 | ParseTypeAndValue(Val1, Loc1, PFS) || |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3805 | ParseIndexList(Indices, AteExtraComma)) |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3806 | return true; |
Chris Lattner | 628c13a | 2009-12-30 05:14:00 +0000 | [diff] [blame] | 3807 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3808 | if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) |
| 3809 | return Error(Loc0, "extractvalue operand must be array or struct"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 3810 | |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3811 | if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), |
| 3812 | Indices.end())) |
| 3813 | return Error(Loc0, "invalid indices for insertvalue"); |
| 3814 | Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end()); |
Chris Lattner | a7d7f2c | 2009-12-30 05:27:33 +0000 | [diff] [blame] | 3815 | return AteExtraComma ? InstExtraComma : InstNormal; |
Chris Lattner | df98617 | 2009-01-02 07:01:27 +0000 | [diff] [blame] | 3816 | } |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 3817 | |
| 3818 | //===----------------------------------------------------------------------===// |
| 3819 | // Embedded metadata. |
| 3820 | //===----------------------------------------------------------------------===// |
| 3821 | |
| 3822 | /// ParseMDNodeVector |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 3823 | /// ::= Element (',' Element)* |
| 3824 | /// Element |
| 3825 | /// ::= 'null' | TypeAndValue |
Victor Hernandez | bf170d4 | 2010-01-05 22:22:14 +0000 | [diff] [blame] | 3826 | bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts, |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 3827 | PerFunctionState *PFS) { |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 3828 | do { |
Chris Lattner | a735239 | 2009-12-30 04:42:57 +0000 | [diff] [blame] | 3829 | // Null is a special case since it is typeless. |
| 3830 | if (EatIfPresent(lltok::kw_null)) { |
| 3831 | Elts.push_back(0); |
| 3832 | continue; |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 3833 | } |
Chris Lattner | a735239 | 2009-12-30 04:42:57 +0000 | [diff] [blame] | 3834 | |
| 3835 | Value *V = 0; |
| 3836 | PATypeHolder Ty(Type::getVoidTy(Context)); |
| 3837 | ValID ID; |
Victor Hernandez | bf170d4 | 2010-01-05 22:22:14 +0000 | [diff] [blame] | 3838 | if (ParseType(Ty) || ParseValID(ID, PFS) || |
Victor Hernandez | 92f238d | 2010-01-11 22:31:58 +0000 | [diff] [blame] | 3839 | ConvertValIDToValue(Ty, ID, V, PFS)) |
Chris Lattner | a735239 | 2009-12-30 04:42:57 +0000 | [diff] [blame] | 3840 | return true; |
| 3841 | |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 3842 | Elts.push_back(V); |
Nick Lewycky | 21cc446 | 2009-04-04 07:22:01 +0000 | [diff] [blame] | 3843 | } while (EatIfPresent(lltok::comma)); |
| 3844 | |
| 3845 | return false; |
| 3846 | } |