43#define DEBUG_TYPE "asm-printer"
52 std::unique_ptr<MCStreamer> Streamer)
53 :
AsmPrinter(TM, std::move(Streamer)), ST(
nullptr),
TII(
nullptr) {}
54 bool ModuleSectionsEmitted;
63 void outputMCInst(
MCInst &Inst);
66 void outputGlobalRequirements();
67 void outputEntryPoints();
68 void outputDebugSourceAndStrings(
const Module &M);
69 void outputOpExtInstImports(
const Module &M);
70 void outputOpMemoryModel();
71 void outputOpFunctionEnd();
72 void outputExtFuncDecls();
74 SPIRV::ExecutionMode::ExecutionMode EM,
75 unsigned ExpectMDOps, int64_t DefVal);
76 void outputExecutionModeFromNumthreadsAttribute(
78 SPIRV::ExecutionMode::ExecutionMode EM);
79 void outputExecutionMode(
const Module &M);
80 void outputAnnotations(
const Module &M);
81 void outputModuleSections();
83 return MF->getFunction()
90 void emitFunctionHeader()
override;
105void SPIRVAsmPrinter::getAnalysisUsage(
AnalysisUsage &AU)
const {
112void SPIRVAsmPrinter::emitEndOfAsmFile(
Module &M) {
113 if (ModuleSectionsEmitted ==
false) {
114 outputModuleSections();
115 ModuleSectionsEmitted =
true;
124 unsigned Bound = 2 * (
ST->getBound() + 1) + NLabels;
125 if (
MCAssembler *Asm = OutStreamer->getAssemblerPtr())
127 .setBuildVersion(Major, Minor, Bound);
130void SPIRVAsmPrinter::emitFunctionHeader() {
131 if (ModuleSectionsEmitted ==
false) {
132 outputModuleSections();
133 ModuleSectionsEmitted =
true;
137 TII =
ST->getInstrInfo();
140 if (isVerbose() && !isHidden()) {
141 OutStreamer->getCommentOS()
142 <<
"-- Begin function "
146 auto Section = getObjFileLowering().SectionForGlobal(&
F, TM);
147 MF->setSection(Section);
150void SPIRVAsmPrinter::outputOpFunctionEnd() {
152 FunctionEndInst.
setOpcode(SPIRV::OpFunctionEnd);
153 outputMCInst(FunctionEndInst);
156void SPIRVAsmPrinter::emitFunctionBodyEnd() {
158 outputOpFunctionEnd();
169 outputMCInst(LabelInst);
171 LabeledMBB.insert(&
MBB);
183 if (
MI.getOpcode() == SPIRV::OpFunction)
191void SPIRVAsmPrinter::printOperand(
const MachineInstr *
MI,
int OpNum,
233bool SPIRVAsmPrinter::PrintAsmOperand(
const MachineInstr *
MI,
unsigned OpNo,
235 if (ExtraCode && ExtraCode[0])
244 return TII->isHeaderInstr(*
MI) ||
MI->getOpcode() == SPIRV::OpFunction ||
245 MI->getOpcode() == SPIRV::OpFunctionParameter;
248void SPIRVAsmPrinter::outputMCInst(
MCInst &Inst) {
249 OutStreamer->emitInstruction(Inst, *OutContext.getSubtargetInfo());
255 MCInstLowering.
lower(
MI, TmpInst, MAI);
256 outputMCInst(TmpInst);
260 SPIRV_MC::verifyInstructionPredicates(
MI->getOpcode(),
261 getSubtargetInfo().getFeatureBits());
263 if (!MAI->getSkipEmission(
MI))
264 outputInstruction(
MI);
270 assert(
MI->getParent()->getNumber() == MF->front().getNumber() &&
271 "OpFunction is not in the front MBB of MF");
272 emitOpLabel(*
MI->getParent());
278 outputInstruction(
MI);
281void SPIRVAsmPrinter::outputDebugSourceAndStrings(
const Module &M) {
283 for (
auto &Str : MAI->SrcExt) {
285 Inst.
setOpcode(SPIRV::OpSourceExtension);
300void SPIRVAsmPrinter::outputOpExtInstImports(
const Module &M) {
301 for (
auto &
CU : MAI->ExtInstSetMap) {
302 unsigned Set =
CU.first;
308 static_cast<SPIRV::InstructionSet::InstructionSet
>(Set)),
314void SPIRVAsmPrinter::outputOpMemoryModel() {
326void SPIRVAsmPrinter::outputEntryPoints() {
330 assert(
MI->getOpcode() == SPIRV::OpVariable);
331 auto SC =
static_cast<SPIRV::StorageClass::StorageClass
>(
332 MI->getOperand(2).getImm());
338 SC == SPIRV::StorageClass::Input ||
SC == SPIRV::StorageClass::Output) {
340 Register Reg = MAI->getRegisterAlias(MF,
MI->getOperand(0).getReg());
349 MCInstLowering.
lower(
MI, TmpInst, MAI);
354 outputMCInst(TmpInst);
359void SPIRVAsmPrinter::outputGlobalRequirements() {
361 MAI->Reqs.checkSatisfiable(*ST);
363 for (
const auto &Cap : MAI->Reqs.getMinimalCapabilities()) {
371 for (
const auto &Ext : MAI->Reqs.getExtensions()) {
375 SPIRV::OperandCategory::ExtensionOperand, Ext),
382void SPIRVAsmPrinter::outputExtFuncDecls() {
387 for (;
I != E; ++
I) {
388 outputInstruction(*
I);
389 if ((
I + 1) == E || (*(
I + 1))->
getOpcode() == SPIRV::OpFunction)
390 outputOpFunctionEnd();
402 if (
IntegerType *IntTy = dyn_cast<IntegerType>(Ty)) {
403 switch (IntTy->getIntegerBitWidth()) {
417 Type *EleTy = VecTy->getElementType();
418 unsigned Size = VecTy->getNumElements();
427 if (
auto *CMeta = dyn_cast<ConstantAsMetadata>(MDOp)) {
431 }
else if (
auto *CE = dyn_cast<Function>(
C)) {
440void SPIRVAsmPrinter::outputExecutionModeFromMDNode(
442 unsigned ExpectMDOps, int64_t DefVal) {
450 unsigned NodeSz =
Node->getNumOperands();
451 if (ExpectMDOps > 0 && NodeSz < ExpectMDOps)
452 for (
unsigned i = NodeSz; i < ExpectMDOps; ++i)
457void SPIRVAsmPrinter::outputExecutionModeFromNumthreadsAttribute(
459 SPIRV::ExecutionMode::ExecutionMode EM) {
460 assert(Attr.
isValid() &&
"Function called with an invalid attribute.");
469 assert(NumThreads.size() == 3 &&
"invalid numthreads");
472 [[maybe_unused]]
bool Result = NumThreads[i].getAsInteger(10, V);
473 assert(!Result &&
"Failed to parse numthreads");
480void SPIRVAsmPrinter::outputExecutionMode(
const Module &M) {
483 for (
unsigned i = 0; i <
Node->getNumOperands(); i++) {
490 for (
auto FI =
M.begin(), E =
M.end(); FI != E; ++FI) {
498 if (
MDNode *
Node =
F.getMetadata(
"reqd_work_group_size"))
499 outputExecutionModeFromMDNode(FReg,
Node, SPIRV::ExecutionMode::LocalSize,
502 outputExecutionModeFromNumthreadsAttribute(
503 FReg, Attr, SPIRV::ExecutionMode::LocalSize);
504 if (
MDNode *
Node =
F.getMetadata(
"work_group_size_hint"))
505 outputExecutionModeFromMDNode(FReg,
Node,
506 SPIRV::ExecutionMode::LocalSizeHint, 3, 1);
507 if (
MDNode *
Node =
F.getMetadata(
"intel_reqd_sub_group_size"))
508 outputExecutionModeFromMDNode(FReg,
Node,
509 SPIRV::ExecutionMode::SubgroupSize, 0, 0);
510 if (
MDNode *
Node =
F.getMetadata(
"vec_type_hint")) {
514 unsigned EM =
static_cast<unsigned>(SPIRV::ExecutionMode::VecTypeHint);
520 if (
ST->isOpenCLEnv() && !
M.getNamedMetadata(
"spirv.ExecutionMode") &&
521 !
M.getNamedMetadata(
"opencl.enable.FP_CONTRACT")) {
525 unsigned EM =
static_cast<unsigned>(SPIRV::ExecutionMode::ContractionOff);
532void SPIRVAsmPrinter::outputAnnotations(
const Module &M) {
535 for (
auto F =
M.global_begin(), E =
M.global_end();
F != E; ++
F) {
536 if ((*F).getName() !=
"llvm.global.annotations")
545 if (!isa<Function>(AnnotatedVar))
549 if (!
Reg.isValid()) {
553 DiagMsg =
"Unknown function in llvm.global.annotations: " + DiagMsg;
566 unsigned Dec =
static_cast<unsigned>(SPIRV::Decoration::UserSemantic);
574void SPIRVAsmPrinter::outputModuleSections() {
575 const Module *
M = MMI->getModule();
578 TII =
ST->getInstrInfo();
580 assert(ST &&
TII && MAI && M &&
"Module analysis is required");
583 outputGlobalRequirements();
585 outputOpExtInstImports(*M);
587 outputOpMemoryModel();
591 outputExecutionMode(*M);
594 outputDebugSourceAndStrings(*M);
600 outputAnnotations(*M);
609 outputExtFuncDecls();
614bool SPIRVAsmPrinter::doInitialization(
Module &M) {
615 ModuleSectionsEmitted =
false;
#define LLVM_EXTERNAL_VISIBILITY
This file defines the DenseMap class.
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
const HexagonInstrInfo * TII
This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static void addOpsFromMDNode(MDNode *MDN, MCInst &Inst, SPIRV::ModuleAnalysisInfo *MAI)
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeSPIRVAsmPrinter()
static bool isFuncOrHeaderInstr(const MachineInstr *MI, const SPIRVInstrInfo *TII)
static unsigned encodeVecTypeHint(Type *Ty)
#define SPIRV_BACKEND_SERVICE_FUN_NAME
static bool printOperand(raw_ostream &OS, const SelectionDAG *G, const SDValue Value)
static std::optional< unsigned > getOpcode(ArrayRef< VPValue * > Values)
Returns the opcode of Values or ~0 if they do not all agree.
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
This class is intended to be used as a driving class for all asm writers.
virtual void emitInstruction(const MachineInstr *)
Targets should implement this to emit instructions.
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
virtual void emitBasicBlockEnd(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the end of a basic block.
const MCAsmInfo * MAI
Target Asm Printer information.
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
virtual void emitEndOfAsmFile(Module &)
This virtual method can be overridden by targets that want to emit something at the end of their file...
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
void getAnalysisUsage(AnalysisUsage &AU) const override
Record analysis usage.
virtual void emitBasicBlockStart(const MachineBasicBlock &MBB)
Targets can override this to emit stuff at the start of a basic block.
virtual void emitFunctionBodyEnd()
Targets can override this to emit stuff after the last basic block in the function.
virtual void emitFunctionEntryLabel()
EmitFunctionEntryLabel - Emit the label that is the entrypoint for the function.
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
StringRef getValueAsString() const
Return the attribute's value as a string.
bool isValid() const
Return true if the attribute is any kind of attribute.
ConstantArray - Constant Array Declarations.
This is the shared class of boolean and integer constants.
This is an important base class in LLVM.
This class represents an Operation in the Expression.
Implements a dense probed hash-table based set.
Class to represent fixed width SIMD vectors.
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
Class to represent integer types.
Instances of this class represent a single low-level machine instruction.
void addOperand(const MCOperand Op)
void setOpcode(unsigned Op)
static MCOperand createReg(MCRegister Reg)
static MCOperand createImm(int64_t Val)
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
StringRef getName() const
getName - Get the symbol name.
ArrayRef< MDOperand > operands() const
Tracking metadata reference owned by Metadata.
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
Representation of each machine instruction.
MachineOperand class - Representation of each machine instruction operand.
const GlobalValue * getGlobal() const
MachineBasicBlock * getMBB() const
const BlockAddress * getBlockAddress() const
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
const char * getSymbolName() const
Register getReg() const
getReg - Returns the register number.
const ConstantFP * getFPImm() const
@ MO_Immediate
Immediate operand.
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
@ MO_GlobalAddress
Address of a global value.
@ MO_BlockAddress
Address of a basic block.
@ MO_MachineBasicBlock
MachineBasicBlock reference.
@ MO_Register
Register operand.
@ MO_ExternalSymbol
Name of external global symbol.
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
@ MO_FPImmediate
Floating-point immediate operand.
A Module instance is used to store all the information related to an LLVM module.
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
static const char * getRegisterName(MCRegister Reg)
void lower(const MachineInstr *MI, MCInst &OutMI, SPIRV::ModuleAnalysisInfo *MAI) const
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
typename SuperClass::iterator iterator
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Primary interface to the complete machine description for the target machine.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isFloatTy() const
Return true if this is 'float', a 32-bit IEEE fp type.
bool isHalfTy() const
Return true if this is 'half', a 16-bit IEEE fp type.
bool isDoubleTy() const
Return true if this is 'double', a 64-bit IEEE fp type.
Value * getOperand(unsigned i) const
LLVM Value Representation.
void print(raw_ostream &O, bool IsForDebug=false) const
Implement operator<< on Value.
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs and address space casts.
Represents a version number in the form major[.minor[.subminor[.build]]].
unsigned getMajor() const
Retrieve the major version number.
std::optional< unsigned > getMinor() const
Retrieve the minor version number, if provided.
std::pair< iterator, bool > insert(const ValueT &V)
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
@ MB_DebugModuleProcessed
Reg
All possible values of the reg field in the ModR/M byte.
NodeAddr< FuncNode * > Func
This is an optimization pass for GlobalISel generic memory operations.
Target & getTheSPIRV32Target()
bool getConstantStringInfo(const Value *V, StringRef &Str, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
std::string getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category, int32_t Value)
bool isEntryPoint(const Function &F)
Target & getTheSPIRV64Target()
Target & getTheSPIRVLogicalTarget()
Type * getMDOperandAsType(const MDNode *N, unsigned I)
void addStringImm(const StringRef &Str, MCInst &Inst)
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
static struct SPIRV::ModuleAnalysisInfo MAI
Register getFuncReg(const Function *F)