Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 1 | //===- COFFAsmParser.cpp - COFF Assembly Parser ---------------------------===// |
| 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 | #include "llvm/MC/MCParser/MCAsmParserExtension.h" |
Jim Grosbach | f2a35fb | 2011-07-25 17:55:35 +0000 | [diff] [blame] | 11 | #include "llvm/ADT/StringSwitch.h" |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/Twine.h" |
| 13 | #include "llvm/MC/MCAsmInfo.h" |
| 14 | #include "llvm/MC/MCContext.h" |
| 15 | #include "llvm/MC/MCParser/MCAsmLexer.h" |
Evan Cheng | 0e6a052 | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 16 | #include "llvm/MC/MCRegisterInfo.h" |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 17 | #include "llvm/MC/MCSectionCOFF.h" |
| 18 | #include "llvm/MC/MCStreamer.h" |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 19 | #include "llvm/MC/MCExpr.h" |
Evan Cheng | 94b9550 | 2011-07-26 00:24:13 +0000 | [diff] [blame^] | 20 | #include "llvm/MC/MCTargetAsmParser.h" |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 21 | #include "llvm/Support/COFF.h" |
| 22 | using namespace llvm; |
| 23 | |
| 24 | namespace { |
| 25 | |
| 26 | class COFFAsmParser : public MCAsmParserExtension { |
| 27 | template<bool (COFFAsmParser::*Handler)(StringRef, SMLoc)> |
| 28 | void AddDirectiveHandler(StringRef Directive) { |
| 29 | getParser().AddDirectiveHandler(this, Directive, |
| 30 | HandleDirective<COFFAsmParser, Handler>); |
| 31 | } |
| 32 | |
| 33 | bool ParseSectionSwitch(StringRef Section, |
| 34 | unsigned Characteristics, |
| 35 | SectionKind Kind); |
| 36 | |
| 37 | virtual void Initialize(MCAsmParser &Parser) { |
| 38 | // Call the base implementation. |
| 39 | MCAsmParserExtension::Initialize(Parser); |
| 40 | |
| 41 | AddDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveText>(".text"); |
| 42 | AddDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveData>(".data"); |
| 43 | AddDirectiveHandler<&COFFAsmParser::ParseSectionDirectiveBSS>(".bss"); |
| 44 | AddDirectiveHandler<&COFFAsmParser::ParseDirectiveDef>(".def"); |
| 45 | AddDirectiveHandler<&COFFAsmParser::ParseDirectiveScl>(".scl"); |
| 46 | AddDirectiveHandler<&COFFAsmParser::ParseDirectiveType>(".type"); |
| 47 | AddDirectiveHandler<&COFFAsmParser::ParseDirectiveEndef>(".endef"); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 48 | |
| 49 | // Win64 EH directives. |
| 50 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartProc>( |
| 51 | ".seh_proc"); |
| 52 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProc>( |
| 53 | ".seh_endproc"); |
| 54 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveStartChained>( |
| 55 | ".seh_startchained"); |
| 56 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndChained>( |
| 57 | ".seh_endchained"); |
| 58 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandler>( |
| 59 | ".seh_handler"); |
| 60 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveHandlerData>( |
| 61 | ".seh_handlerdata"); |
| 62 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushReg>( |
| 63 | ".seh_pushreg"); |
| 64 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSetFrame>( |
| 65 | ".seh_setframe"); |
| 66 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveAllocStack>( |
| 67 | ".seh_stackalloc"); |
| 68 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveReg>( |
| 69 | ".seh_savereg"); |
| 70 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveSaveXMM>( |
| 71 | ".seh_savexmm"); |
| 72 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectivePushFrame>( |
| 73 | ".seh_pushframe"); |
| 74 | AddDirectiveHandler<&COFFAsmParser::ParseSEHDirectiveEndProlog>( |
| 75 | ".seh_endprologue"); |
Jim Grosbach | f2a35fb | 2011-07-25 17:55:35 +0000 | [diff] [blame] | 76 | AddDirectiveHandler<&COFFAsmParser::ParseDirectiveSymbolAttribute>(".weak"); |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 77 | } |
| 78 | |
| 79 | bool ParseSectionDirectiveText(StringRef, SMLoc) { |
| 80 | return ParseSectionSwitch(".text", |
| 81 | COFF::IMAGE_SCN_CNT_CODE |
| 82 | | COFF::IMAGE_SCN_MEM_EXECUTE |
| 83 | | COFF::IMAGE_SCN_MEM_READ, |
| 84 | SectionKind::getText()); |
| 85 | } |
| 86 | bool ParseSectionDirectiveData(StringRef, SMLoc) { |
| 87 | return ParseSectionSwitch(".data", |
| 88 | COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
| 89 | | COFF::IMAGE_SCN_MEM_READ |
| 90 | | COFF::IMAGE_SCN_MEM_WRITE, |
| 91 | SectionKind::getDataRel()); |
| 92 | } |
| 93 | bool ParseSectionDirectiveBSS(StringRef, SMLoc) { |
| 94 | return ParseSectionSwitch(".bss", |
| 95 | COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA |
| 96 | | COFF::IMAGE_SCN_MEM_READ |
| 97 | | COFF::IMAGE_SCN_MEM_WRITE, |
| 98 | SectionKind::getBSS()); |
| 99 | } |
| 100 | |
| 101 | bool ParseDirectiveDef(StringRef, SMLoc); |
| 102 | bool ParseDirectiveScl(StringRef, SMLoc); |
| 103 | bool ParseDirectiveType(StringRef, SMLoc); |
| 104 | bool ParseDirectiveEndef(StringRef, SMLoc); |
| 105 | |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 106 | // Win64 EH directives. |
| 107 | bool ParseSEHDirectiveStartProc(StringRef, SMLoc); |
| 108 | bool ParseSEHDirectiveEndProc(StringRef, SMLoc); |
| 109 | bool ParseSEHDirectiveStartChained(StringRef, SMLoc); |
| 110 | bool ParseSEHDirectiveEndChained(StringRef, SMLoc); |
| 111 | bool ParseSEHDirectiveHandler(StringRef, SMLoc); |
| 112 | bool ParseSEHDirectiveHandlerData(StringRef, SMLoc); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 113 | bool ParseSEHDirectivePushReg(StringRef, SMLoc); |
| 114 | bool ParseSEHDirectiveSetFrame(StringRef, SMLoc); |
| 115 | bool ParseSEHDirectiveAllocStack(StringRef, SMLoc); |
| 116 | bool ParseSEHDirectiveSaveReg(StringRef, SMLoc); |
| 117 | bool ParseSEHDirectiveSaveXMM(StringRef, SMLoc); |
| 118 | bool ParseSEHDirectivePushFrame(StringRef, SMLoc); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 119 | bool ParseSEHDirectiveEndProlog(StringRef, SMLoc); |
| 120 | |
| 121 | bool ParseAtUnwindOrAtExcept(bool &unwind, bool &except); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 122 | bool ParseSEHRegisterNumber(unsigned &RegNo); |
Jim Grosbach | f2a35fb | 2011-07-25 17:55:35 +0000 | [diff] [blame] | 123 | bool ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc); |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 124 | public: |
| 125 | COFFAsmParser() {} |
| 126 | }; |
| 127 | |
| 128 | } // end annonomous namespace. |
| 129 | |
Jim Grosbach | f2a35fb | 2011-07-25 17:55:35 +0000 | [diff] [blame] | 130 | /// ParseDirectiveSymbolAttribute |
| 131 | /// ::= { ".weak", ... } [ identifier ( , identifier )* ] |
| 132 | bool COFFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) { |
| 133 | MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive) |
| 134 | .Case(".weak", MCSA_Weak) |
| 135 | .Default(MCSA_Invalid); |
| 136 | assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!"); |
| 137 | if (getLexer().isNot(AsmToken::EndOfStatement)) { |
| 138 | for (;;) { |
| 139 | StringRef Name; |
| 140 | |
| 141 | if (getParser().ParseIdentifier(Name)) |
| 142 | return TokError("expected identifier in directive"); |
| 143 | |
| 144 | MCSymbol *Sym = getContext().GetOrCreateSymbol(Name); |
| 145 | |
| 146 | getStreamer().EmitSymbolAttribute(Sym, Attr); |
| 147 | |
| 148 | if (getLexer().is(AsmToken::EndOfStatement)) |
| 149 | break; |
| 150 | |
| 151 | if (getLexer().isNot(AsmToken::Comma)) |
| 152 | return TokError("unexpected token in directive"); |
| 153 | Lex(); |
| 154 | } |
| 155 | } |
| 156 | |
| 157 | Lex(); |
| 158 | return false; |
| 159 | } |
| 160 | |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 161 | bool COFFAsmParser::ParseSectionSwitch(StringRef Section, |
| 162 | unsigned Characteristics, |
| 163 | SectionKind Kind) { |
| 164 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 165 | return TokError("unexpected token in section switching directive"); |
| 166 | Lex(); |
| 167 | |
| 168 | getStreamer().SwitchSection(getContext().getCOFFSection( |
| 169 | Section, Characteristics, Kind)); |
| 170 | |
| 171 | return false; |
| 172 | } |
| 173 | |
| 174 | bool COFFAsmParser::ParseDirectiveDef(StringRef, SMLoc) { |
| 175 | StringRef SymbolName; |
| 176 | |
| 177 | if (getParser().ParseIdentifier(SymbolName)) |
| 178 | return TokError("expected identifier in directive"); |
| 179 | |
| 180 | MCSymbol *Sym = getContext().GetOrCreateSymbol(SymbolName); |
| 181 | |
| 182 | getStreamer().BeginCOFFSymbolDef(Sym); |
| 183 | |
| 184 | Lex(); |
| 185 | return false; |
| 186 | } |
| 187 | |
| 188 | bool COFFAsmParser::ParseDirectiveScl(StringRef, SMLoc) { |
| 189 | int64_t SymbolStorageClass; |
| 190 | if (getParser().ParseAbsoluteExpression(SymbolStorageClass)) |
| 191 | return true; |
| 192 | |
| 193 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 194 | return TokError("unexpected token in directive"); |
| 195 | |
| 196 | Lex(); |
| 197 | getStreamer().EmitCOFFSymbolStorageClass(SymbolStorageClass); |
| 198 | return false; |
| 199 | } |
| 200 | |
| 201 | bool COFFAsmParser::ParseDirectiveType(StringRef, SMLoc) { |
| 202 | int64_t Type; |
| 203 | if (getParser().ParseAbsoluteExpression(Type)) |
| 204 | return true; |
| 205 | |
| 206 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 207 | return TokError("unexpected token in directive"); |
| 208 | |
| 209 | Lex(); |
| 210 | getStreamer().EmitCOFFSymbolType(Type); |
| 211 | return false; |
| 212 | } |
| 213 | |
| 214 | bool COFFAsmParser::ParseDirectiveEndef(StringRef, SMLoc) { |
| 215 | Lex(); |
| 216 | getStreamer().EndCOFFSymbolDef(); |
| 217 | return false; |
| 218 | } |
| 219 | |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 220 | bool COFFAsmParser::ParseSEHDirectiveStartProc(StringRef, SMLoc) { |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 221 | StringRef SymbolID; |
| 222 | if (getParser().ParseIdentifier(SymbolID)) |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 223 | return true; |
| 224 | |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 225 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 226 | return TokError("unexpected token in directive"); |
| 227 | |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 228 | MCSymbol *Symbol = getContext().GetOrCreateSymbol(SymbolID); |
| 229 | |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 230 | Lex(); |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 231 | getStreamer().EmitWin64EHStartProc(Symbol); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 232 | return false; |
| 233 | } |
| 234 | |
| 235 | bool COFFAsmParser::ParseSEHDirectiveEndProc(StringRef, SMLoc) { |
| 236 | Lex(); |
| 237 | getStreamer().EmitWin64EHEndProc(); |
| 238 | return false; |
| 239 | } |
| 240 | |
| 241 | bool COFFAsmParser::ParseSEHDirectiveStartChained(StringRef, SMLoc) { |
| 242 | Lex(); |
| 243 | getStreamer().EmitWin64EHStartChained(); |
| 244 | return false; |
| 245 | } |
| 246 | |
| 247 | bool COFFAsmParser::ParseSEHDirectiveEndChained(StringRef, SMLoc) { |
| 248 | Lex(); |
| 249 | getStreamer().EmitWin64EHEndChained(); |
| 250 | return false; |
| 251 | } |
| 252 | |
| 253 | bool COFFAsmParser::ParseSEHDirectiveHandler(StringRef, SMLoc) { |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 254 | StringRef SymbolID; |
| 255 | if (getParser().ParseIdentifier(SymbolID)) |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 256 | return true; |
| 257 | |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 258 | if (getLexer().isNot(AsmToken::Comma)) |
| 259 | return TokError("you must specify one or both of @unwind or @except"); |
| 260 | Lex(); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 261 | bool unwind = false, except = false; |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 262 | if (ParseAtUnwindOrAtExcept(unwind, except)) |
| 263 | return true; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 264 | if (getLexer().is(AsmToken::Comma)) { |
| 265 | Lex(); |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 266 | if (ParseAtUnwindOrAtExcept(unwind, except)) |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 267 | return true; |
| 268 | } |
| 269 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 270 | return TokError("unexpected token in directive"); |
| 271 | |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 272 | MCSymbol *handler = getContext().GetOrCreateSymbol(SymbolID); |
| 273 | |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 274 | Lex(); |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 275 | getStreamer().EmitWin64EHHandler(handler, unwind, except); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 276 | return false; |
| 277 | } |
| 278 | |
| 279 | bool COFFAsmParser::ParseSEHDirectiveHandlerData(StringRef, SMLoc) { |
| 280 | Lex(); |
| 281 | getStreamer().EmitWin64EHHandlerData(); |
| 282 | return false; |
| 283 | } |
| 284 | |
| 285 | bool COFFAsmParser::ParseSEHDirectivePushReg(StringRef, SMLoc L) { |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 286 | unsigned Reg; |
| 287 | if (ParseSEHRegisterNumber(Reg)) |
| 288 | return true; |
| 289 | |
| 290 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 291 | return TokError("unexpected token in directive"); |
| 292 | |
| 293 | Lex(); |
| 294 | getStreamer().EmitWin64EHPushReg(Reg); |
| 295 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 296 | } |
| 297 | |
| 298 | bool COFFAsmParser::ParseSEHDirectiveSetFrame(StringRef, SMLoc L) { |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 299 | unsigned Reg; |
| 300 | int64_t Off; |
| 301 | if (ParseSEHRegisterNumber(Reg)) |
| 302 | return true; |
Charles Davis | 410ef2b | 2011-05-25 21:43:45 +0000 | [diff] [blame] | 303 | if (getLexer().isNot(AsmToken::Comma)) |
| 304 | return TokError("you must specify a stack pointer offset"); |
| 305 | |
| 306 | Lex(); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 307 | SMLoc startLoc = getLexer().getLoc(); |
| 308 | if (getParser().ParseAbsoluteExpression(Off)) |
| 309 | return true; |
| 310 | |
| 311 | if (Off & 0x0F) |
| 312 | return Error(startLoc, "offset is not a multiple of 16"); |
| 313 | |
| 314 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 315 | return TokError("unexpected token in directive"); |
| 316 | |
| 317 | Lex(); |
| 318 | getStreamer().EmitWin64EHSetFrame(Reg, Off); |
| 319 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 320 | } |
| 321 | |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 322 | bool COFFAsmParser::ParseSEHDirectiveAllocStack(StringRef, SMLoc) { |
| 323 | int64_t Size; |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 324 | SMLoc startLoc = getLexer().getLoc(); |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 325 | if (getParser().ParseAbsoluteExpression(Size)) |
| 326 | return true; |
| 327 | |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 328 | if (Size & 7) |
| 329 | return Error(startLoc, "size is not a multiple of 8"); |
| 330 | |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 331 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 332 | return TokError("unexpected token in directive"); |
| 333 | |
| 334 | Lex(); |
| 335 | getStreamer().EmitWin64EHAllocStack(Size); |
| 336 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | bool COFFAsmParser::ParseSEHDirectiveSaveReg(StringRef, SMLoc L) { |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 340 | unsigned Reg; |
| 341 | int64_t Off; |
| 342 | if (ParseSEHRegisterNumber(Reg)) |
| 343 | return true; |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 344 | if (getLexer().isNot(AsmToken::Comma)) |
Charles Davis | 410ef2b | 2011-05-25 21:43:45 +0000 | [diff] [blame] | 345 | return TokError("you must specify an offset on the stack"); |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 346 | |
| 347 | Lex(); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 348 | SMLoc startLoc = getLexer().getLoc(); |
| 349 | if (getParser().ParseAbsoluteExpression(Off)) |
| 350 | return true; |
| 351 | |
| 352 | if (Off & 7) |
| 353 | return Error(startLoc, "size is not a multiple of 8"); |
| 354 | |
| 355 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 356 | return TokError("unexpected token in directive"); |
| 357 | |
| 358 | Lex(); |
| 359 | // FIXME: Err on %xmm* registers |
| 360 | getStreamer().EmitWin64EHSaveReg(Reg, Off); |
| 361 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 362 | } |
| 363 | |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 364 | // FIXME: This method is inherently x86-specific. It should really be in the |
| 365 | // x86 backend. |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 366 | bool COFFAsmParser::ParseSEHDirectiveSaveXMM(StringRef, SMLoc L) { |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 367 | unsigned Reg; |
| 368 | int64_t Off; |
| 369 | if (ParseSEHRegisterNumber(Reg)) |
| 370 | return true; |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 371 | if (getLexer().isNot(AsmToken::Comma)) |
Charles Davis | 410ef2b | 2011-05-25 21:43:45 +0000 | [diff] [blame] | 372 | return TokError("you must specify an offset on the stack"); |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 373 | |
| 374 | Lex(); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 375 | SMLoc startLoc = getLexer().getLoc(); |
| 376 | if (getParser().ParseAbsoluteExpression(Off)) |
| 377 | return true; |
| 378 | |
| 379 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 380 | return TokError("unexpected token in directive"); |
| 381 | |
| 382 | if (Off & 0x0F) |
| 383 | return Error(startLoc, "offset is not a multiple of 16"); |
| 384 | |
| 385 | Lex(); |
| 386 | // FIXME: Err on non-%xmm* registers |
| 387 | getStreamer().EmitWin64EHSaveXMM(Reg, Off); |
| 388 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 389 | } |
| 390 | |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 391 | bool COFFAsmParser::ParseSEHDirectivePushFrame(StringRef, SMLoc) { |
Charles Davis | 4726816 | 2011-05-25 04:08:15 +0000 | [diff] [blame] | 392 | bool Code = false; |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 393 | StringRef CodeID; |
Charles Davis | 4726816 | 2011-05-25 04:08:15 +0000 | [diff] [blame] | 394 | if (getLexer().is(AsmToken::At)) { |
| 395 | SMLoc startLoc = getLexer().getLoc(); |
| 396 | Lex(); |
| 397 | if (!getParser().ParseIdentifier(CodeID)) { |
| 398 | if (CodeID != "code") |
| 399 | return Error(startLoc, "expected @code"); |
| 400 | Code = true; |
| 401 | } |
Charles Davis | 16e1b3f | 2011-05-23 16:43:09 +0000 | [diff] [blame] | 402 | } |
| 403 | |
| 404 | if (getLexer().isNot(AsmToken::EndOfStatement)) |
| 405 | return TokError("unexpected token in directive"); |
| 406 | |
| 407 | Lex(); |
| 408 | getStreamer().EmitWin64EHPushFrame(Code); |
| 409 | return false; |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | bool COFFAsmParser::ParseSEHDirectiveEndProlog(StringRef, SMLoc) { |
| 413 | Lex(); |
| 414 | getStreamer().EmitWin64EHEndProlog(); |
| 415 | return false; |
| 416 | } |
| 417 | |
| 418 | bool COFFAsmParser::ParseAtUnwindOrAtExcept(bool &unwind, bool &except) { |
| 419 | StringRef identifier; |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 420 | if (getLexer().isNot(AsmToken::At)) |
| 421 | return TokError("a handler attribute must begin with '@'"); |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 422 | SMLoc startLoc = getLexer().getLoc(); |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 423 | Lex(); |
| 424 | if (getParser().ParseIdentifier(identifier)) |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 425 | return Error(startLoc, "expected @unwind or @except"); |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 426 | if (identifier == "unwind") |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 427 | unwind = true; |
Charles Davis | 3092132 | 2011-05-25 01:33:42 +0000 | [diff] [blame] | 428 | else if (identifier == "except") |
Charles Davis | fbc539f | 2011-05-22 21:12:15 +0000 | [diff] [blame] | 429 | except = true; |
| 430 | else |
| 431 | return Error(startLoc, "expected @unwind or @except"); |
| 432 | return false; |
| 433 | } |
| 434 | |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 435 | bool COFFAsmParser::ParseSEHRegisterNumber(unsigned &RegNo) { |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 436 | SMLoc startLoc = getLexer().getLoc(); |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 437 | if (getLexer().is(AsmToken::Percent)) { |
Evan Cheng | 0e6a052 | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 438 | const MCRegisterInfo &MRI = getContext().getRegisterInfo(); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 439 | SMLoc endLoc; |
| 440 | unsigned LLVMRegNo; |
| 441 | if (getParser().getTargetParser().ParseRegister(LLVMRegNo,startLoc,endLoc)) |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 442 | return true; |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 443 | |
Evan Cheng | 0e6a052 | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 444 | #if 0 |
| 445 | // FIXME: TargetAsmInfo::getCalleeSavedRegs() commits a serious layering |
| 446 | // violation so this validation code is disabled. |
| 447 | |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 448 | // Check that this is a non-volatile register. |
Evan Cheng | 1be0e27 | 2011-07-15 02:09:41 +0000 | [diff] [blame] | 449 | const unsigned *NVRegs = TAI.getCalleeSavedRegs(); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 450 | unsigned i; |
| 451 | for (i = 0; NVRegs[i] != 0; ++i) |
| 452 | if (NVRegs[i] == LLVMRegNo) |
| 453 | break; |
| 454 | if (NVRegs[i] == 0) |
| 455 | return Error(startLoc, "expected non-volatile register"); |
Evan Cheng | 0e6a052 | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 456 | #endif |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 457 | |
Evan Cheng | 0e6a052 | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 458 | int SEHRegNo = MRI.getSEHRegNum(LLVMRegNo); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 459 | if (SEHRegNo < 0) |
| 460 | return Error(startLoc,"register can't be represented in SEH unwind info"); |
| 461 | RegNo = SEHRegNo; |
| 462 | } |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 463 | else { |
| 464 | int64_t n; |
| 465 | if (getParser().ParseAbsoluteExpression(n)) |
| 466 | return true; |
| 467 | if (n > 15) |
| 468 | return Error(startLoc, "register number is too high"); |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 469 | RegNo = n; |
Charles Davis | 575630c | 2011-05-25 04:51:25 +0000 | [diff] [blame] | 470 | } |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 471 | |
Charles Davis | 3b32d02 | 2011-05-24 20:06:30 +0000 | [diff] [blame] | 472 | return false; |
| 473 | } |
| 474 | |
Michael J. Spencer | 7d49004 | 2010-10-09 11:01:07 +0000 | [diff] [blame] | 475 | namespace llvm { |
| 476 | |
| 477 | MCAsmParserExtension *createCOFFAsmParser() { |
| 478 | return new COFFAsmParser; |
| 479 | } |
| 480 | |
| 481 | } |