//===-- X86AsmPrinter.cpp - Convert X86 LLVM code to AT&T assembly --------===////// The LLVM Compiler Infrastructure//// This file is distributed under the University of Illinois Open Source// License. See LICENSE.TXT for details.////===----------------------------------------------------------------------===////// This file contains a printer that converts from our internal representation// of machine-dependent LLVM code to X86 machine code.////===----------------------------------------------------------------------===//#include"X86AsmPrinter.h"#include"InstPrinter/X86ATTInstPrinter.h"#include"MCTargetDesc/X86BaseInfo.h"#include"X86InstrInfo.h"#include"X86MachineFunctionInfo.h"#include"llvm/ADT/SmallString.h"#include"llvm/CodeGen/MachineConstantPool.h"#include"llvm/CodeGen/MachineModuleInfoImpls.h"#include"llvm/CodeGen/MachineValueType.h"#include"llvm/CodeGen/TargetLoweringObjectFileImpl.h"#include"llvm/IR/DebugInfo.h"#include"llvm/IR/DerivedTypes.h"#include"llvm/IR/Mangler.h"#include"llvm/IR/Module.h"#include"llvm/IR/Type.h"#include"llvm/MC/MCAsmInfo.h"#include"llvm/MC/MCContext.h"#include"llvm/MC/MCExpr.h"#include"llvm/MC/MCSectionCOFF.h"#include"llvm/MC/MCSectionMachO.h"#include"llvm/MC/MCStreamer.h"#include"llvm/MC/MCSymbol.h"#include"llvm/Support/COFF.h"#include"llvm/Support/Debug.h"#include"llvm/Support/ErrorHandling.h"#include"llvm/Support/TargetRegistry.h"usingnamespacellvm;//===----------------------------------------------------------------------===//// Primitive Helper Functions.//===----------------------------------------------------------------------===///// runOnMachineFunction - Emit the function body.///boolX86AsmPrinter::runOnMachineFunction(MachineFunction&MF){Subtarget=&MF.getSubtarget<X86Subtarget>();SMShadowTracker.startFunction(MF);SetupMachineFunction(MF);if(Subtarget->isTargetCOFF()){boolIntrn=MF.getFunction()->hasInternalLinkage();OutStreamer.BeginCOFFSymbolDef(CurrentFnSym);OutStreamer.EmitCOFFSymbolStorageClass(Intrn?COFF::IMAGE_SYM_CLASS_STATIC:COFF::IMAGE_SYM_CLASS_EXTERNAL);OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_FUNCTION<<COFF::SCT_COMPLEX_TYPE_SHIFT);OutStreamer.EndCOFFSymbolDef();}// Have common code print out the function header with linkage info etc.EmitFunctionHeader();// Emit the rest of the function body.EmitFunctionBody();// We didn't modify anything.returnfalse;}/// printSymbolOperand - Print a raw symbol reference operand. This handles/// jump tables, constant pools, global address and external symbols, all of/// which print to a label with various suffixes for relocation types etc.staticvoidprintSymbolOperand(X86AsmPrinter&P,constMachineOperand&MO,raw_ostream&O){switch(MO.getType()){default:llvm_unreachable("unknown symbol type!");caseMachineOperand::MO_ConstantPoolIndex:O<<*P.GetCPISymbol(MO.getIndex());P.printOffset(MO.getOffset(),O);break;caseMachineOperand::MO_GlobalAddress:{constGlobalValue*GV=MO.getGlobal();MCSymbol*GVSym;if(MO.getTargetFlags()==X86II::MO_DARWIN_STUB)GVSym=P.getSymbolWithGlobalValueBase(GV,"$stub");elseif(MO.getTargetFlags()==X86II::MO_DARWIN_NONLAZY||MO.getTargetFlags()==X86II::MO_DARWIN_NONLAZY_PIC_BASE||MO.getTargetFlags()==X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE)GVSym=P.getSymbolWithGlobalValueBase(GV,"$non_lazy_ptr");elseGVSym=P.getSymbol(GV);// Handle dllimport linkage.if(MO.getTargetFlags()==X86II::MO_DLLIMPORT)GVSym=P.OutContext.GetOrCreateSymbol(Twine("__imp_")+GVSym->getName());if(MO.getTargetFlags()==X86II::MO_DARWIN_NONLAZY||MO.getTargetFlags()==X86II::MO_DARWIN_NONLAZY_PIC_BASE){MCSymbol*Sym=P.getSymbolWithGlobalValueBase(GV,"$non_lazy_ptr");MachineModuleInfoImpl::StubValueTy&StubSym=P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getGVStubEntry(Sym);if(!StubSym.getPointer())StubSym=MachineModuleInfoImpl::StubValueTy(P.getSymbol(GV),!GV->hasInternalLinkage());}elseif(MO.getTargetFlags()==X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE){MCSymbol*Sym=P.getSymbolWithGlobalValueBase(GV,"$non_lazy_ptr");MachineModuleInfoImpl::StubValueTy&StubSym=P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getHiddenGVStubEntry(Sym);if(!StubSym.getPointer())StubSym=MachineModuleInfoImpl::StubValueTy(P.getSymbol(GV),!GV->hasInternalLinkage());}elseif(MO.getTargetFlags()==X86II::MO_DARWIN_STUB){MCSymbol*Sym=P.getSymbolWithGlobalValueBase(GV,"$stub");MachineModuleInfoImpl::StubValueTy&StubSym=P.MMI->getObjFileInfo<MachineModuleInfoMachO>().getFnStubEntry(Sym);if(!StubSym.getPointer())StubSym=MachineModuleInfoImpl::StubValueTy(P.getSymbol(GV),!GV->hasInternalLinkage());}// If the name begins with a dollar-sign, enclose it in parens. We do this// to avoid having it look like an integer immediate to the assembler.if(GVSym->getName()[0]!='$')O<<*GVSym;elseO<<'('<<*GVSym<<')';P.printOffset(MO.getOffset(),O);break;}}switch(MO.getTargetFlags()){default:llvm_unreachable("Unknown target flag on GV operand");caseX86II::MO_NO_FLAG:// No flag.break;caseX86II::MO_DARWIN_NONLAZY:caseX86II::MO_DLLIMPORT:caseX86II::MO_DARWIN_STUB:// These affect the name of the symbol, not any suffix.break;caseX86II::MO_GOT_ABSOLUTE_ADDRESS:O<<" + [.-"<<*P.MF->getPICBaseSymbol()<<']';break;caseX86II::MO_PIC_BASE_OFFSET:caseX86II::MO_DARWIN_NONLAZY_PIC_BASE:caseX86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE:O<<'-'<<*P.MF->getPICBaseSymbol();break;caseX86II::MO_TLSGD:O<<"@TLSGD";break;caseX86II::MO_TLSLD:O<<"@TLSLD";break;caseX86II::MO_TLSLDM:O<<"@TLSLDM";break;caseX86II::MO_GOTTPOFF:O<<"@GOTTPOFF";break;caseX86II::MO_INDNTPOFF:O<<"@INDNTPOFF";break;caseX86II::MO_TPOFF:O<<"@TPOFF";break;caseX86II::MO_DTPOFF:O<<"@DTPOFF";break;caseX86II::MO_NTPOFF:O<<"@NTPOFF";break;caseX86II::MO_GOTNTPOFF:O<<"@GOTNTPOFF";break;caseX86II::MO_GOTPCREL:O<<"@GOTPCREL";break;caseX86II::MO_GOT:O<<"@GOT";break;caseX86II::MO_GOTOFF:O<<"@GOTOFF";break;caseX86II::MO_PLT:O<<"@PLT";break;caseX86II::MO_TLVP:O<<"@TLVP";break;caseX86II::MO_TLVP_PIC_BASE:O<<"@TLVP"<<'-'<<*P.MF->getPICBaseSymbol();break;caseX86II::MO_SECREL:O<<"@SECREL32";break;}}staticvoidprintOperand(X86AsmPrinter&P,constMachineInstr*MI,unsignedOpNo,raw_ostream&O,constchar*Modifier=nullptr,unsignedAsmVariant=0);/// printPCRelImm - This is used to print an immediate value that ends up/// being encoded as a pc-relative value. These print slightly differently, for/// example, a $ is not emitted.staticvoidprintPCRelImm(X86AsmPrinter&P,constMachineInstr*MI,unsignedOpNo,raw_ostream&O){constMachineOperand&MO=MI->getOperand(OpNo);switch(MO.getType()){default:llvm_unreachable("Unknown pcrel immediate operand");caseMachineOperand::MO_Register:// pc-relativeness was handled when computing the value in the reg.printOperand(P,MI,OpNo,O);return;caseMachineOperand::MO_Immediate:O<<MO.getImm();return;caseMachineOperand::MO_GlobalAddress:printSymbolOperand(P,MO,O);return;}}staticvoidprintOperand(X86AsmPrinter&P,constMachineInstr*MI,unsignedOpNo,raw_ostream&O,constchar*Modifier,unsignedAsmVariant){constMachineOperand&MO=MI->getOperand(OpNo);switch(MO.getType()){default:llvm_unreachable("unknown operand type!");caseMachineOperand::MO_Register:{// FIXME: Enumerating AsmVariant, so we can remove magic number.if(AsmVariant==0)O<<'%';unsignedReg=MO.getReg();if(Modifier&&strncmp(Modifier,"subreg",strlen("subreg"))==0){MVT::SimpleValueTypeVT=(strcmp(Modifier+6,"64")==0)?MVT::i64:((strcmp(Modifier+6,"32")==0)?MVT::i32:((strcmp(Modifier+6,"16")==0)?MVT::i16:MVT::i8));Reg=getX86SubSuperRegister(Reg,VT);}O<<X86ATTInstPrinter::getRegisterName(Reg);return;}caseMachineOperand::MO_Immediate:if(AsmVariant==0)O<<'$';O<<MO.getImm();return;caseMachineOperand::MO_GlobalAddress:{if(AsmVariant==0)O<<'$';printSymbolOperand(P,MO,O);break;}}}staticvoidprintLeaMemReference(X86AsmPrinter&P,constMachineInstr*MI,unsignedOp,raw_ostream&O,constchar*Modifier=nullptr){constMachineOperand&BaseReg=MI->getOperand(Op+X86::AddrBaseReg);constMachineOperand&IndexReg=MI->getOperand(Op+X86::AddrIndexReg);constMachineOperand&DispSpec=MI->getOperand(Op+X86::AddrDisp);// If we really don't want to print out (rip), don't.boolHasBaseReg=BaseReg.getReg()!=0;if(HasBaseReg&&Modifier&&!strcmp(Modifier,"no-rip")&&BaseReg.getReg()==X86::RIP)HasBaseReg=false;// HasParenPart - True if we will print out the () part of the mem ref.boolHasParenPart=IndexReg.getReg()||HasBaseReg;switch(DispSpec.getType()){default:llvm_unreachable("unknown operand type!");caseMachineOperand::MO_Immediate:{intDispVal=DispSpec.getImm();if(DispVal||!HasParenPart)O<<DispVal;break;}caseMachineOperand::MO_GlobalAddress:caseMachineOperand::MO_ConstantPoolIndex:printSymbolOperand(P,DispSpec,O);}if(Modifier&&strcmp(Modifier,"H")==0)O<<"+8";if(HasParenPart){assert(IndexReg.getReg()!=X86::ESP&&"X86 doesn't allow scaling by ESP");O<<'(';if(HasBaseReg)printOperand(P,MI,Op+X86::AddrBaseReg,O,Modifier);if(IndexReg.getReg()){O<<',';printOperand(P,MI,Op+X86::AddrIndexReg,O,Modifier);unsignedScaleVal=MI->getOperand(Op+X86::AddrScaleAmt).getImm();if(ScaleVal!=1)O<<','<<ScaleVal;}O<<')';}}staticvoidprintMemReference(X86AsmPrinter&P,constMachineInstr*MI,unsignedOp,raw_ostream&O,constchar*Modifier=nullptr){assert(isMem(MI,Op)&&"Invalid memory reference!");constMachineOperand&Segment=MI->getOperand(Op+X86::AddrSegmentReg);if(Segment.getReg()){printOperand(P,MI,Op+X86::AddrSegmentReg,O,Modifier);O<<':';}printLeaMemReference(P,MI,Op,O,Modifier);}staticvoidprintIntelMemReference(X86AsmPrinter&P,constMachineInstr*MI,unsignedOp,raw_ostream&O,constchar*Modifier=nullptr,unsignedAsmVariant=1){constMachineOperand&BaseReg=MI->getOperand(Op+X86::AddrBaseReg);unsignedScaleVal=MI->getOperand(Op+X86::AddrScaleAmt).getImm();constMachineOperand&IndexReg=MI->getOperand(Op+X86::AddrIndexReg);constMachineOperand&DispSpec=MI->getOperand(Op+X86::AddrDisp);constMachineOperand&SegReg=MI->getOperand(Op+X86::AddrSegmentReg);// If this has a segment register, print it.if(SegReg.getReg()){printOperand(P,MI,Op+X86::AddrSegmentReg,O,Modifier,AsmVariant);O<<':';}O<<'[';boolNeedPlus=false;if(BaseReg.getReg()){printOperand(P,MI,Op+X86::AddrBaseReg,O,Modifier,AsmVariant);NeedPlus=true;}if(IndexReg.getReg()){if(NeedPlus)O<<" + ";if(ScaleVal!=1)O<<ScaleVal<<'*';printOperand(P,MI,Op+X86::AddrIndexReg,O,Modifier,AsmVariant);NeedPlus=true;}if(!DispSpec.isImm()){if(NeedPlus)O<<" + ";printOperand(P,MI,Op+X86::AddrDisp,O,Modifier,AsmVariant);}else{int64_tDispVal=DispSpec.getImm();if(DispVal||(!IndexReg.getReg()&&!BaseReg.getReg())){if(NeedPlus){if(DispVal>0)O<<" + ";else{O<<" - ";DispVal=-DispVal;}}O<<DispVal;}}O<<']';}staticboolprintAsmMRegister(X86AsmPrinter&P,constMachineOperand&MO,charMode,raw_ostream&O){unsignedReg=MO.getReg();switch(Mode){default:returntrue;// Unknown mode.case'b':// Print QImode registerReg=getX86SubSuperRegister(Reg,MVT::i8);break;case'h':// Print QImode high registerReg=getX86SubSuperRegister(Reg,MVT::i8,true);break;case'w':// Print HImode registerReg=getX86SubSuperRegister(Reg,MVT::i16);break;case'k':// Print SImode registerReg=getX86SubSuperRegister(Reg,MVT::i32);break;case'q':// Print 64-bit register names if 64-bit integer registers are available.// Otherwise, print 32-bit register names.MVT::SimpleValueTypeTy=P.getSubtarget().is64Bit()?MVT::i64:MVT::i32;Reg=getX86SubSuperRegister(Reg,Ty);break;}O<<'%'<<X86ATTInstPrinter::getRegisterName(Reg);returnfalse;}/// PrintAsmOperand - Print out an operand for an inline asm expression.///boolX86AsmPrinter::PrintAsmOperand(constMachineInstr*MI,unsignedOpNo,unsignedAsmVariant,constchar*ExtraCode,raw_ostream&O){// Does this asm operand have a single letter operand modifier?if(ExtraCode&&ExtraCode[0]){if(ExtraCode[1]!=0)returntrue;// Unknown modifier.constMachineOperand&MO=MI->getOperand(OpNo);switch(ExtraCode[0]){default:// See if this is a generic print operandreturnAsmPrinter::PrintAsmOperand(MI,OpNo,AsmVariant,ExtraCode,O);case'a':// This is an address. Currently only 'i' and 'r' are expected.switch(MO.getType()){default:returntrue;caseMachineOperand::MO_Immediate:O<<MO.getImm();returnfalse;caseMachineOperand::MO_ConstantPoolIndex:caseMachineOperand::MO_JumpTableIndex:caseMachineOperand::MO_ExternalSymbol:llvm_unreachable("unexpected operand type!");caseMachineOperand::MO_GlobalAddress:printSymbolOperand(*this,MO,O);if(Subtarget->isPICStyleRIPRel())O<<"(%rip)";returnfalse;caseMachineOperand::MO_Register:O<<'(';printOperand(*this,MI,OpNo,O);O<<')';returnfalse;}case'c':// Don't print "$" before a global var name or constant.switch(MO.getType()){default:printOperand(*this,MI,OpNo,O);break;caseMachineOperand::MO_Immediate:O<<MO.getImm();break;caseMachineOperand::MO_ConstantPoolIndex:caseMachineOperand::MO_JumpTableIndex:caseMachineOperand::MO_ExternalSymbol:llvm_unreachable("unexpected operand type!");caseMachineOperand::MO_GlobalAddress:printSymbolOperand(*this,MO,O);break;}returnfalse;case'A':// Print '*' before a register (it must be a register)if(MO.isReg()){O<<'*';printOperand(*this,MI,OpNo,O);returnfalse;}returntrue;case'b':// Print QImode registercase'h':// Print QImode high registercase'w':// Print HImode registercase'k':// Print SImode registercase'q':// Print DImode registerif(MO.isReg())returnprintAsmMRegister(*this,MO,ExtraCode[0],O);printOperand(*this,MI,OpNo,O);returnfalse;case'P':// This is the operand of a call, treat specially.printPCRelImm(*this,MI,OpNo,O);returnfalse;case'n':// Negate the immediate or print a '-' before the operand.// Note: this is a temporary solution. It should be handled target// independently as part of the 'MC' work.if(MO.isImm()){O<<-MO.getImm();returnfalse;}O<<'-';}}printOperand(*this,MI,OpNo,O,/*Modifier*/nullptr,AsmVariant);returnfalse;}boolX86AsmPrinter::PrintAsmMemoryOperand(constMachineInstr*MI,unsignedOpNo,unsignedAsmVariant,constchar*ExtraCode,raw_ostream&O){if(AsmVariant){printIntelMemReference(*this,MI,OpNo,O);returnfalse;}if(ExtraCode&&ExtraCode[0]){if(ExtraCode[1]!=0)returntrue;// Unknown modifier.switch(ExtraCode[0]){default:returntrue;// Unknown modifier.case'b':// Print QImode registercase'h':// Print QImode high registercase'w':// Print HImode registercase'k':// Print SImode registercase'q':// Print SImode register// These only apply to registers, ignore on mem.break;case'H':printMemReference(*this,MI,OpNo,O,"H");returnfalse;case'P':// Don't print @PLT, but do print as memory.printMemReference(*this,MI,OpNo,O,"no-rip");returnfalse;}}printMemReference(*this,MI,OpNo,O);returnfalse;}voidX86AsmPrinter::EmitStartOfAsmFile(Module&M){TripleTT(TM.getTargetTriple());if(TT.isOSBinFormatMachO())OutStreamer.SwitchSection(getObjFileLowering().getTextSection());if(TT.isOSBinFormatCOFF()){// Emit an absolute @feat.00 symbol. This appears to be some kind of// compiler features bitfield read by link.exe.if(TT.getArch()==Triple::x86){MCSymbol*S=MMI->getContext().GetOrCreateSymbol(StringRef("@feat.00"));OutStreamer.BeginCOFFSymbolDef(S);OutStreamer.EmitCOFFSymbolStorageClass(COFF::IMAGE_SYM_CLASS_STATIC);OutStreamer.EmitCOFFSymbolType(COFF::IMAGE_SYM_DTYPE_NULL);OutStreamer.EndCOFFSymbolDef();// According to the PE-COFF spec, the LSB of this value marks the object// for "registered SEH". This means that all SEH handler entry points// must be registered in .sxdata. Use of any unregistered handlers will// cause the process to terminate immediately. LLVM does not know how to// register any SEH handlers, so its object files should be safe.S->setAbsolute();OutStreamer.EmitSymbolAttribute(S,MCSA_Global);OutStreamer.EmitAssignment(S,MCConstantExpr::Create(int64_t(1),MMI->getContext()));}}}staticvoidemitNonLazySymbolPointer(MCStreamer&OutStreamer,MCSymbol*StubLabel,MachineModuleInfoImpl::StubValueTy&MCSym){// L_foo$stub:OutStreamer.EmitLabel(StubLabel);// .indirect_symbol _fooOutStreamer.EmitSymbolAttribute(MCSym.getPointer(),MCSA_IndirectSymbol);if(MCSym.getInt())// External to current translation unit.OutStreamer.EmitIntValue(0,4/*size*/);else// Internal to current translation unit.//// When we place the LSDA into the TEXT section, the type info// pointers need to be indirect and pc-rel. We accomplish this by// using NLPs; however, sometimes the types are local to the file.// We need to fill in the value for the NLP in those cases.OutStreamer.EmitValue(MCSymbolRefExpr::Create(MCSym.getPointer(),OutStreamer.getContext()),4/*size*/);}MCSymbol*X86AsmPrinter::GetCPISymbol(unsignedCPID)const{if(Subtarget->isTargetKnownWindowsMSVC()){constMachineConstantPoolEntry&CPE=MF->getConstantPool()->getConstants()[CPID];if(!CPE.isMachineConstantPoolEntry()){SectionKindKind=CPE.getSectionKind(TM.getDataLayout());constConstant*C=CPE.Val.ConstVal;if(constMCSectionCOFF*S=dyn_cast<MCSectionCOFF>(getObjFileLowering().getSectionForConstant(Kind,C))){if(MCSymbol*Sym=S->getCOMDATSymbol()){if(Sym->isUndefined())OutStreamer.EmitSymbolAttribute(Sym,MCSA_Global);returnSym;}}}}returnAsmPrinter::GetCPISymbol(CPID);}voidX86AsmPrinter::GenerateExportDirective(constMCSymbol*Sym,boolIsData){SmallString<128>Directive;raw_svector_ostreamOS(Directive);StringRefName=Sym->getName();TripleTT(TM.getTargetTriple());if(TT.isKnownWindowsMSVCEnvironment())OS<<" /EXPORT:";elseOS<<" -export:";if((TT.isWindowsGNUEnvironment()||TT.isWindowsCygwinEnvironment())&&(Name[0]==getDataLayout().getGlobalPrefix()))Name=Name.drop_front();OS<<Name;if(IsData){if(TT.isKnownWindowsMSVCEnvironment())OS<<",DATA";elseOS<<",data";}OS.flush();OutStreamer.EmitBytes(Directive);}voidX86AsmPrinter::EmitEndOfAsmFile(Module&M){TripleTT(TM.getTargetTriple());if(TT.isOSBinFormatMachO()){// All darwin targets use mach-o.MachineModuleInfoMachO&MMIMacho=MMI->getObjFileInfo<MachineModuleInfoMachO>();// Output stubs for dynamically-linked functions.MachineModuleInfoMachO::SymbolListTyStubs;Stubs=MMIMacho.GetFnStubList();if(!Stubs.empty()){constMCSection*TheSection=OutContext.getMachOSection("__IMPORT","__jump_table",MachO::S_SYMBOL_STUBS|MachO::S_ATTR_SELF_MODIFYING_CODE|MachO::S_ATTR_PURE_INSTRUCTIONS,5,SectionKind::getMetadata());OutStreamer.SwitchSection(TheSection);for(constauto&Stub:Stubs){// L_foo$stub:OutStreamer.EmitLabel(Stub.first);// .indirect_symbol _fooOutStreamer.EmitSymbolAttribute(Stub.second.getPointer(),MCSA_IndirectSymbol);// hlt; hlt; hlt; hlt; hlt hlt = 0xf4.constcharHltInsts[]="\xf4\xf4\xf4\xf4\xf4";OutStreamer.EmitBytes(StringRef(HltInsts,5));}Stubs.clear();OutStreamer.AddBlankLine();}// Output stubs for external and common global variables.Stubs=MMIMacho.GetGVStubList();if(!Stubs.empty()){constMCSection*TheSection=OutContext.getMachOSection("__IMPORT","__pointers",MachO::S_NON_LAZY_SYMBOL_POINTERS,SectionKind::getMetadata());OutStreamer.SwitchSection(TheSection);for(auto&Stub:Stubs)emitNonLazySymbolPointer(OutStreamer,Stub.first,Stub.second);Stubs.clear();OutStreamer.AddBlankLine();}Stubs=MMIMacho.GetHiddenGVStubList();if(!Stubs.empty()){constMCSection*TheSection=OutContext.getMachOSection("__IMPORT","__pointers",MachO::S_NON_LAZY_SYMBOL_POINTERS,SectionKind::getMetadata());OutStreamer.SwitchSection(TheSection);for(auto&Stub:Stubs)emitNonLazySymbolPointer(OutStreamer,Stub.first,Stub.second);Stubs.clear();OutStreamer.AddBlankLine();}SM.serializeToStackMapSection();// Funny Darwin hack: This flag tells the linker that no global symbols// contain code that falls through to other global symbols (e.g. the obvious// implementation of multiple entry points). If this doesn't occur, the// linker can safely perform dead code stripping. Since LLVM never// generates code that does this, it is always safe to set.OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);}if(TT.isKnownWindowsMSVCEnvironment()&&MMI->usesVAFloatArgument()){StringRefSymbolName=(TT.getArch()==Triple::x86_64)?"_fltused":"__fltused";MCSymbol*S=MMI->getContext().GetOrCreateSymbol(SymbolName);OutStreamer.EmitSymbolAttribute(S,MCSA_Global);}if(TT.isOSBinFormatCOFF()){// Necessary for dllexport supportstd::vector<constMCSymbol*>DLLExportedFns,DLLExportedGlobals;for(constauto&Function:M)if(Function.hasDLLExportStorageClass()&&!Function.isDeclaration())DLLExportedFns.push_back(getSymbol(&Function));for(constauto&Global:M.globals())if(Global.hasDLLExportStorageClass()&&!Global.isDeclaration())DLLExportedGlobals.push_back(getSymbol(&Global));for(constauto&Alias:M.aliases()){if(!Alias.hasDLLExportStorageClass())continue;if(Alias.getType()->getElementType()->isFunctionTy())DLLExportedFns.push_back(getSymbol(&Alias));elseDLLExportedGlobals.push_back(getSymbol(&Alias));}// Output linker support code for dllexported globals on windows.if(!DLLExportedGlobals.empty()||!DLLExportedFns.empty()){constTargetLoweringObjectFileCOFF&TLOFCOFF=static_cast<constTargetLoweringObjectFileCOFF&>(getObjFileLowering());OutStreamer.SwitchSection(TLOFCOFF.getDrectveSection());for(auto&Symbol:DLLExportedGlobals)GenerateExportDirective(Symbol,/*IsData=*/true);for(auto&Symbol:DLLExportedFns)GenerateExportDirective(Symbol,/*IsData=*/false);}}if(TT.isOSBinFormatELF()){constTargetLoweringObjectFileELF&TLOFELF=static_cast<constTargetLoweringObjectFileELF&>(getObjFileLowering());MachineModuleInfoELF&MMIELF=MMI->getObjFileInfo<MachineModuleInfoELF>();// Output stubs for external and common global variables.MachineModuleInfoELF::SymbolListTyStubs=MMIELF.GetGVStubList();if(!Stubs.empty()){OutStreamer.SwitchSection(TLOFELF.getDataRelSection());constDataLayout*TD=TM.getDataLayout();for(constauto&Stub:Stubs){OutStreamer.EmitLabel(Stub.first);OutStreamer.EmitSymbolValue(Stub.second.getPointer(),TD->getPointerSize());}Stubs.clear();}SM.serializeToStackMapSection();}}//===----------------------------------------------------------------------===//// Target Registry Stuff//===----------------------------------------------------------------------===//// Force static initialization.extern"C"voidLLVMInitializeX86AsmPrinter(){RegisterAsmPrinter<X86AsmPrinter>X(TheX86_32Target);RegisterAsmPrinter<X86AsmPrinter>Y(TheX86_64Target);}