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