LLVM API Documentation
00001 //===-- X86IntelAsmPrinter.cpp - Convert X86 LLVM code to Intel assembly --===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file contains a printer that converts from our internal representation 00011 // of machine-dependent LLVM code to Intel format assembly language. 00012 // This printer is the output mechanism used by `llc'. 00013 // 00014 //===----------------------------------------------------------------------===// 00015 00016 #define DEBUG_TYPE "asm-printer" 00017 #include "X86IntelAsmPrinter.h" 00018 #include "X86InstrInfo.h" 00019 #include "X86TargetAsmInfo.h" 00020 #include "X86.h" 00021 #include "llvm/CallingConv.h" 00022 #include "llvm/Constants.h" 00023 #include "llvm/DerivedTypes.h" 00024 #include "llvm/Module.h" 00025 #include "llvm/ADT/Statistic.h" 00026 #include "llvm/ADT/StringExtras.h" 00027 #include "llvm/Assembly/Writer.h" 00028 #include "llvm/CodeGen/DwarfWriter.h" 00029 #include "llvm/MC/MCStreamer.h" 00030 #include "llvm/Target/TargetAsmInfo.h" 00031 #include "llvm/Target/TargetLoweringObjectFile.h" 00032 #include "llvm/Target/TargetOptions.h" 00033 #include "llvm/Support/ErrorHandling.h" 00034 #include "llvm/Support/Mangler.h" 00035 using namespace llvm; 00036 00037 STATISTIC(EmittedInsts, "Number of machine instrs printed"); 00038 00039 static X86MachineFunctionInfo calculateFunctionInfo(const Function *F, 00040 const TargetData *TD) { 00041 X86MachineFunctionInfo Info; 00042 uint64_t Size = 0; 00043 00044 switch (F->getCallingConv()) { 00045 case CallingConv::X86_StdCall: 00046 Info.setDecorationStyle(StdCall); 00047 break; 00048 case CallingConv::X86_FastCall: 00049 Info.setDecorationStyle(FastCall); 00050 break; 00051 default: 00052 return Info; 00053 } 00054 00055 unsigned argNum = 1; 00056 for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end(); 00057 AI != AE; ++AI, ++argNum) { 00058 const Type* Ty = AI->getType(); 00059 00060 // 'Dereference' type in case of byval parameter attribute 00061 if (F->paramHasAttr(argNum, Attribute::ByVal)) 00062 Ty = cast<PointerType>(Ty)->getElementType(); 00063 00064 // Size should be aligned to DWORD boundary 00065 Size += ((TD->getTypeAllocSize(Ty) + 3)/4)*4; 00066 } 00067 00068 // We're not supporting tooooo huge arguments :) 00069 Info.setBytesToPopOnReturn((unsigned int)Size); 00070 return Info; 00071 } 00072 00073 00074 /// decorateName - Query FunctionInfoMap and use this information for various 00075 /// name decoration. 00076 void X86IntelAsmPrinter::decorateName(std::string &Name, 00077 const GlobalValue *GV) { 00078 const Function *F = dyn_cast<Function>(GV); 00079 if (!F) return; 00080 00081 // We don't want to decorate non-stdcall or non-fastcall functions right now 00082 unsigned CC = F->getCallingConv(); 00083 if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall) 00084 return; 00085 00086 FMFInfoMap::const_iterator info_item = FunctionInfoMap.find(F); 00087 00088 const X86MachineFunctionInfo *Info; 00089 if (info_item == FunctionInfoMap.end()) { 00090 // Calculate apropriate function info and populate map 00091 FunctionInfoMap[F] = calculateFunctionInfo(F, TM.getTargetData()); 00092 Info = &FunctionInfoMap[F]; 00093 } else { 00094 Info = &info_item->second; 00095 } 00096 00097 const FunctionType *FT = F->getFunctionType(); 00098 switch (Info->getDecorationStyle()) { 00099 case None: 00100 break; 00101 case StdCall: 00102 // "Pure" variadic functions do not receive @0 suffix. 00103 if (!FT->isVarArg() || (FT->getNumParams() == 0) || 00104 (FT->getNumParams() == 1 && F->hasStructRetAttr())) 00105 Name += '@' + utostr_32(Info->getBytesToPopOnReturn()); 00106 break; 00107 case FastCall: 00108 // "Pure" variadic functions do not receive @0 suffix. 00109 if (!FT->isVarArg() || (FT->getNumParams() == 0) || 00110 (FT->getNumParams() == 1 && F->hasStructRetAttr())) 00111 Name += '@' + utostr_32(Info->getBytesToPopOnReturn()); 00112 00113 if (Name[0] == '_') 00114 Name[0] = '@'; 00115 else 00116 Name = '@' + Name; 00117 00118 break; 00119 default: 00120 llvm_unreachable("Unsupported DecorationStyle"); 00121 } 00122 } 00123 00124 /// runOnMachineFunction - This uses the printMachineInstruction() 00125 /// method to print assembly for each instruction. 00126 /// 00127 bool X86IntelAsmPrinter::runOnMachineFunction(MachineFunction &MF) { 00128 this->MF = &MF; 00129 SetupMachineFunction(MF); 00130 O << "\n\n"; 00131 00132 // Print out constants referenced by the function 00133 EmitConstantPool(MF.getConstantPool()); 00134 00135 // Print out labels for the function. 00136 const Function *F = MF.getFunction(); 00137 unsigned CC = F->getCallingConv(); 00138 unsigned FnAlign = MF.getAlignment(); 00139 00140 // Populate function information map. Actually, We don't want to populate 00141 // non-stdcall or non-fastcall functions' information right now. 00142 if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall) 00143 FunctionInfoMap[F] = *MF.getInfo<X86MachineFunctionInfo>(); 00144 00145 decorateName(CurrentFnName, F); 00146 00147 OutStreamer.SwitchSection(getObjFileLowering().SectionForGlobal(F, Mang, TM)); 00148 00149 switch (F->getLinkage()) { 00150 default: llvm_unreachable("Unsupported linkage type!"); 00151 case Function::PrivateLinkage: 00152 case Function::LinkerPrivateLinkage: 00153 case Function::InternalLinkage: 00154 EmitAlignment(FnAlign); 00155 break; 00156 case Function::DLLExportLinkage: 00157 DLLExportedFns.insert(CurrentFnName); 00158 //FALLS THROUGH 00159 case Function::ExternalLinkage: 00160 O << "\tpublic " << CurrentFnName << "\n"; 00161 EmitAlignment(FnAlign); 00162 break; 00163 } 00164 00165 O << CurrentFnName << "\tproc near\n"; 00166 00167 // Print out code for the function. 00168 for (MachineFunction::const_iterator I = MF.begin(), E = MF.end(); 00169 I != E; ++I) { 00170 // Print a label for the basic block if there are any predecessors. 00171 if (!I->pred_empty()) { 00172 printBasicBlockLabel(I, true, true); 00173 O << '\n'; 00174 } 00175 for (MachineBasicBlock::const_iterator II = I->begin(), E = I->end(); 00176 II != E; ++II) { 00177 // Print the assembly for the instruction. 00178 printMachineInstruction(II); 00179 } 00180 } 00181 00182 // Print out jump tables referenced by the function. 00183 EmitJumpTableInfo(MF.getJumpTableInfo(), MF); 00184 00185 O << CurrentFnName << "\tendp\n"; 00186 00187 // We didn't modify anything. 00188 return false; 00189 } 00190 00191 void X86IntelAsmPrinter::printSSECC(const MachineInstr *MI, unsigned Op) { 00192 unsigned char value = MI->getOperand(Op).getImm(); 00193 assert(value <= 7 && "Invalid ssecc argument!"); 00194 switch (value) { 00195 case 0: O << "eq"; break; 00196 case 1: O << "lt"; break; 00197 case 2: O << "le"; break; 00198 case 3: O << "unord"; break; 00199 case 4: O << "neq"; break; 00200 case 5: O << "nlt"; break; 00201 case 6: O << "nle"; break; 00202 case 7: O << "ord"; break; 00203 } 00204 } 00205 00206 void X86IntelAsmPrinter::printOp(const MachineOperand &MO, 00207 const char *Modifier) { 00208 switch (MO.getType()) { 00209 case MachineOperand::MO_Register: { 00210 if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) { 00211 unsigned Reg = MO.getReg(); 00212 if (Modifier && strncmp(Modifier, "subreg", strlen("subreg")) == 0) { 00213 EVT VT = (strcmp(Modifier,"subreg64") == 0) ? 00214 MVT::i64 : ((strcmp(Modifier, "subreg32") == 0) ? MVT::i32 : 00215 ((strcmp(Modifier,"subreg16") == 0) ? MVT::i16 :MVT::i8)); 00216 Reg = getX86SubSuperRegister(Reg, VT); 00217 } 00218 O << TRI->getName(Reg); 00219 } else 00220 O << "reg" << MO.getReg(); 00221 return; 00222 } 00223 case MachineOperand::MO_Immediate: 00224 O << MO.getImm(); 00225 return; 00226 case MachineOperand::MO_JumpTableIndex: { 00227 bool isMemOp = Modifier && !strcmp(Modifier, "mem"); 00228 if (!isMemOp) O << "OFFSET "; 00229 O << TAI->getPrivateGlobalPrefix() << "JTI" << getFunctionNumber() 00230 << "_" << MO.getIndex(); 00231 return; 00232 } 00233 case MachineOperand::MO_ConstantPoolIndex: { 00234 bool isMemOp = Modifier && !strcmp(Modifier, "mem"); 00235 if (!isMemOp) O << "OFFSET "; 00236 O << "[" << TAI->getPrivateGlobalPrefix() << "CPI" 00237 << getFunctionNumber() << "_" << MO.getIndex(); 00238 printOffset(MO.getOffset()); 00239 O << "]"; 00240 return; 00241 } 00242 case MachineOperand::MO_GlobalAddress: { 00243 bool isMemOp = Modifier && !strcmp(Modifier, "mem"); 00244 GlobalValue *GV = MO.getGlobal(); 00245 std::string Name = Mang->getMangledName(GV); 00246 decorateName(Name, GV); 00247 00248 if (!isMemOp) O << "OFFSET "; 00249 00250 // Handle dllimport linkage. 00251 // FIXME: This should be fixed with full support of stdcall & fastcall 00252 // CC's 00253 if (MO.getTargetFlags() == X86II::MO_DLLIMPORT) 00254 O << "__imp_"; 00255 00256 O << Name; 00257 printOffset(MO.getOffset()); 00258 return; 00259 } 00260 case MachineOperand::MO_ExternalSymbol: { 00261 O << TAI->getGlobalPrefix() << MO.getSymbolName(); 00262 return; 00263 } 00264 default: 00265 O << "<unknown operand type>"; return; 00266 } 00267 } 00268 00269 void X86IntelAsmPrinter::print_pcrel_imm(const MachineInstr *MI, unsigned OpNo){ 00270 const MachineOperand &MO = MI->getOperand(OpNo); 00271 switch (MO.getType()) { 00272 default: llvm_unreachable("Unknown pcrel immediate operand"); 00273 case MachineOperand::MO_Immediate: 00274 O << MO.getImm(); 00275 return; 00276 case MachineOperand::MO_MachineBasicBlock: 00277 printBasicBlockLabel(MO.getMBB(), false, false, false); 00278 return; 00279 00280 case MachineOperand::MO_GlobalAddress: { 00281 GlobalValue *GV = MO.getGlobal(); 00282 std::string Name = Mang->getMangledName(GV); 00283 decorateName(Name, GV); 00284 00285 // Handle dllimport linkage. 00286 // FIXME: This should be fixed with full support of stdcall & fastcall 00287 // CC's 00288 if (MO.getTargetFlags() == X86II::MO_DLLIMPORT) 00289 O << "__imp_"; 00290 O << Name; 00291 printOffset(MO.getOffset()); 00292 return; 00293 } 00294 00295 case MachineOperand::MO_ExternalSymbol: 00296 O << TAI->getGlobalPrefix() << MO.getSymbolName(); 00297 return; 00298 } 00299 } 00300 00301 00302 void X86IntelAsmPrinter::printLeaMemReference(const MachineInstr *MI, 00303 unsigned Op, 00304 const char *Modifier) { 00305 const MachineOperand &BaseReg = MI->getOperand(Op); 00306 int ScaleVal = MI->getOperand(Op+1).getImm(); 00307 const MachineOperand &IndexReg = MI->getOperand(Op+2); 00308 const MachineOperand &DispSpec = MI->getOperand(Op+3); 00309 00310 O << "["; 00311 bool NeedPlus = false; 00312 if (BaseReg.getReg()) { 00313 printOp(BaseReg, Modifier); 00314 NeedPlus = true; 00315 } 00316 00317 if (IndexReg.getReg()) { 00318 if (NeedPlus) O << " + "; 00319 if (ScaleVal != 1) 00320 O << ScaleVal << "*"; 00321 printOp(IndexReg, Modifier); 00322 NeedPlus = true; 00323 } 00324 00325 if (DispSpec.isGlobal() || DispSpec.isCPI() || 00326 DispSpec.isJTI()) { 00327 if (NeedPlus) 00328 O << " + "; 00329 printOp(DispSpec, "mem"); 00330 } else { 00331 int DispVal = DispSpec.getImm(); 00332 if (DispVal || (!BaseReg.getReg() && !IndexReg.getReg())) { 00333 if (NeedPlus) { 00334 if (DispVal > 0) 00335 O << " + "; 00336 else { 00337 O << " - "; 00338 DispVal = -DispVal; 00339 } 00340 } 00341 O << DispVal; 00342 } 00343 } 00344 O << "]"; 00345 } 00346 00347 void X86IntelAsmPrinter::printMemReference(const MachineInstr *MI, unsigned Op, 00348 const char *Modifier) { 00349 assert(isMem(MI, Op) && "Invalid memory reference!"); 00350 MachineOperand Segment = MI->getOperand(Op+4); 00351 if (Segment.getReg()) { 00352 printOperand(MI, Op+4, Modifier); 00353 O << ':'; 00354 } 00355 printLeaMemReference(MI, Op, Modifier); 00356 } 00357 00358 void X86IntelAsmPrinter::printPICJumpTableSetLabel(unsigned uid, 00359 const MachineBasicBlock *MBB) const { 00360 if (!TAI->getSetDirective()) 00361 return; 00362 00363 O << TAI->getSetDirective() << ' ' << TAI->getPrivateGlobalPrefix() 00364 << getFunctionNumber() << '_' << uid << "_set_" << MBB->getNumber() << ','; 00365 printBasicBlockLabel(MBB, false, false, false); 00366 O << '-' << "\"L" << getFunctionNumber() << "$pb\"'\n"; 00367 } 00368 00369 void X86IntelAsmPrinter::printPICLabel(const MachineInstr *MI, unsigned Op) { 00370 O << "L" << getFunctionNumber() << "$pb\n"; 00371 O << "L" << getFunctionNumber() << "$pb:"; 00372 } 00373 00374 bool X86IntelAsmPrinter::printAsmMRegister(const MachineOperand &MO, 00375 const char Mode) { 00376 unsigned Reg = MO.getReg(); 00377 switch (Mode) { 00378 default: return true; // Unknown mode. 00379 case 'b': // Print QImode register 00380 Reg = getX86SubSuperRegister(Reg, MVT::i8); 00381 break; 00382 case 'h': // Print QImode high register 00383 Reg = getX86SubSuperRegister(Reg, MVT::i8, true); 00384 break; 00385 case 'w': // Print HImode register 00386 Reg = getX86SubSuperRegister(Reg, MVT::i16); 00387 break; 00388 case 'k': // Print SImode register 00389 Reg = getX86SubSuperRegister(Reg, MVT::i32); 00390 break; 00391 } 00392 00393 O << TRI->getName(Reg); 00394 return false; 00395 } 00396 00397 /// PrintAsmOperand - Print out an operand for an inline asm expression. 00398 /// 00399 bool X86IntelAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 00400 unsigned AsmVariant, 00401 const char *ExtraCode) { 00402 // Does this asm operand have a single letter operand modifier? 00403 if (ExtraCode && ExtraCode[0]) { 00404 if (ExtraCode[1] != 0) return true; // Unknown modifier. 00405 00406 switch (ExtraCode[0]) { 00407 default: return true; // Unknown modifier. 00408 case 'b': // Print QImode register 00409 case 'h': // Print QImode high register 00410 case 'w': // Print HImode register 00411 case 'k': // Print SImode register 00412 return printAsmMRegister(MI->getOperand(OpNo), ExtraCode[0]); 00413 } 00414 } 00415 00416 printOperand(MI, OpNo); 00417 return false; 00418 } 00419 00420 bool X86IntelAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, 00421 unsigned OpNo, 00422 unsigned AsmVariant, 00423 const char *ExtraCode) { 00424 if (ExtraCode && ExtraCode[0]) 00425 return true; // Unknown modifier. 00426 printMemReference(MI, OpNo); 00427 return false; 00428 } 00429 00430 /// printMachineInstruction -- Print out a single X86 LLVM instruction 00431 /// MI in Intel syntax to the current output stream. 00432 /// 00433 void X86IntelAsmPrinter::printMachineInstruction(const MachineInstr *MI) { 00434 ++EmittedInsts; 00435 00436 // Call the autogenerated instruction printer routines. 00437 printInstruction(MI); 00438 } 00439 00440 bool X86IntelAsmPrinter::doInitialization(Module &M) { 00441 bool Result = AsmPrinter::doInitialization(M); 00442 00443 Mang->markCharUnacceptable('.'); 00444 00445 O << "\t.686\n\t.MMX\n\t.XMM\n\t.model flat\n\n"; 00446 00447 // Emit declarations for external functions. 00448 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 00449 if (I->isDeclaration()) { 00450 std::string Name = Mang->getMangledName(I); 00451 decorateName(Name, I); 00452 00453 O << "\tEXTERN " ; 00454 if (I->hasDLLImportLinkage()) { 00455 O << "__imp_"; 00456 } 00457 O << Name << ":near\n"; 00458 } 00459 00460 // Emit declarations for external globals. Note that VC++ always declares 00461 // external globals to have type byte, and if that's good enough for VC++... 00462 for (Module::const_global_iterator I = M.global_begin(), E = M.global_end(); 00463 I != E; ++I) { 00464 if (I->isDeclaration()) { 00465 std::string Name = Mang->getMangledName(I); 00466 00467 O << "\tEXTERN " ; 00468 if (I->hasDLLImportLinkage()) { 00469 O << "__imp_"; 00470 } 00471 O << Name << ":byte\n"; 00472 } 00473 } 00474 00475 return Result; 00476 } 00477 00478 void X86IntelAsmPrinter::PrintGlobalVariable(const GlobalVariable *GV) { 00479 // Check to see if this is a special global used by LLVM, if so, emit it. 00480 if (GV->isDeclaration() || 00481 EmitSpecialLLVMGlobal(GV)) 00482 return; 00483 00484 const TargetData *TD = TM.getTargetData(); 00485 00486 std::string name = Mang->getMangledName(GV); 00487 Constant *C = GV->getInitializer(); 00488 unsigned Align = TD->getPreferredAlignmentLog(GV); 00489 bool bCustomSegment = false; 00490 00491 switch (GV->getLinkage()) { 00492 case GlobalValue::CommonLinkage: 00493 case GlobalValue::LinkOnceAnyLinkage: 00494 case GlobalValue::LinkOnceODRLinkage: 00495 case GlobalValue::WeakAnyLinkage: 00496 case GlobalValue::WeakODRLinkage: 00497 // FIXME: make a MCSection. 00498 O << name << "?\tSEGEMNT PARA common 'COMMON'\n"; 00499 bCustomSegment = true; 00500 // FIXME: the default alignment is 16 bytes, but 1, 2, 4, and 256 00501 // are also available. 00502 break; 00503 case GlobalValue::AppendingLinkage: 00504 // FIXME: make a MCSection. 00505 O << name << "?\tSEGMENT PARA public 'DATA'\n"; 00506 bCustomSegment = true; 00507 // FIXME: the default alignment is 16 bytes, but 1, 2, 4, and 256 00508 // are also available. 00509 break; 00510 case GlobalValue::DLLExportLinkage: 00511 DLLExportedGVs.insert(name); 00512 // FALL THROUGH 00513 case GlobalValue::ExternalLinkage: 00514 O << "\tpublic " << name << "\n"; 00515 // FALL THROUGH 00516 case GlobalValue::InternalLinkage: 00517 OutStreamer.SwitchSection(getObjFileLowering().getDataSection()); 00518 break; 00519 default: 00520 llvm_unreachable("Unknown linkage type!"); 00521 } 00522 00523 if (!bCustomSegment) 00524 EmitAlignment(Align, GV); 00525 00526 O << name << ":"; 00527 if (VerboseAsm) 00528 O.PadToColumn(TAI->getCommentColumn()); 00529 O << TAI->getCommentString() 00530 << " " << GV->getName(); 00531 O << '\n'; 00532 00533 EmitGlobalConstant(C); 00534 00535 if (bCustomSegment) 00536 O << name << "?\tends\n"; 00537 } 00538 00539 bool X86IntelAsmPrinter::doFinalization(Module &M) { 00540 // Output linker support code for dllexported globals 00541 if (!DLLExportedGVs.empty() || !DLLExportedFns.empty()) { 00542 O << "; WARNING: The following code is valid only with MASM v8.x" 00543 << "and (possible) higher\n" 00544 << "; This version of MASM is usually shipped with Microsoft " 00545 << "Visual Studio 2005\n" 00546 << "; or (possible) further versions. Unfortunately, there is no " 00547 << "way to support\n" 00548 << "; dllexported symbols in the earlier versions of MASM in fully " 00549 << "automatic way\n\n"; 00550 O << "_drectve\t segment info alias('.drectve')\n"; 00551 00552 for (StringSet<>::iterator i = DLLExportedGVs.begin(), 00553 e = DLLExportedGVs.end(); 00554 i != e; ++i) 00555 O << "\t db ' /EXPORT:" << i->getKeyData() << ",data'\n"; 00556 00557 for (StringSet<>::iterator i = DLLExportedFns.begin(), 00558 e = DLLExportedFns.end(); 00559 i != e; ++i) 00560 O << "\t db ' /EXPORT:" << i->getKeyData() << "'\n"; 00561 00562 O << "_drectve\t ends\n"; 00563 } 00564 00565 // Bypass X86SharedAsmPrinter::doFinalization(). 00566 bool Result = AsmPrinter::doFinalization(M); 00567 O << "\tend\n"; 00568 return Result; 00569 } 00570 00571 void X86IntelAsmPrinter::EmitString(const ConstantArray *CVA) const { 00572 unsigned NumElts = CVA->getNumOperands(); 00573 if (NumElts) { 00574 // ML does not have escape sequences except '' for '. It also has a maximum 00575 // string length of 255. 00576 unsigned len = 0; 00577 bool inString = false; 00578 for (unsigned i = 0; i < NumElts; i++) { 00579 int n = cast<ConstantInt>(CVA->getOperand(i))->getZExtValue() & 255; 00580 if (len == 0) 00581 O << "\tdb "; 00582 00583 if (n >= 32 && n <= 127) { 00584 if (!inString) { 00585 if (len > 0) { 00586 O << ",'"; 00587 len += 2; 00588 } else { 00589 O << "'"; 00590 len++; 00591 } 00592 inString = true; 00593 } 00594 if (n == '\'') { 00595 O << "'"; 00596 len++; 00597 } 00598 O << char(n); 00599 } else { 00600 if (inString) { 00601 O << "'"; 00602 len++; 00603 inString = false; 00604 } 00605 if (len > 0) { 00606 O << ","; 00607 len++; 00608 } 00609 O << n; 00610 len += 1 + (n > 9) + (n > 99); 00611 } 00612 00613 if (len > 60) { 00614 if (inString) { 00615 O << "'"; 00616 inString = false; 00617 } 00618 O << "\n"; 00619 len = 0; 00620 } 00621 } 00622 00623 if (len > 0) { 00624 if (inString) 00625 O << "'"; 00626 O << "\n"; 00627 } 00628 } 00629 } 00630 00631 // Include the auto-generated portion of the assembly writer. 00632 #include "X86GenAsmWriter1.inc"