[llvm-branch-commits] [llvm] [3/7][PISA] Add PISA register file, instruction set, and MC layer (PR #214107)
Craig Topper via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Nov 3 14:49:30 PST 2026
================
@@ -0,0 +1,588 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements the PISA target streamer.
+///
+//===----------------------------------------------------------------------===//
+
+#include "MCTargetDesc/PISATargetStreamer.h"
+#include "MCTargetDesc/PISAMCTargetDesc.h"
+#include "MCTargetDesc/PISARegEncoder.h"
+#include "PISAInstPrinter.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/CodeGenTypes/LowLevelType.h"
+#include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/PISAAddrSpace.h"
+
+using namespace llvm;
+using namespace llvm::PISA;
+
+PISA::StorageSpace PISA::mapAddrSpaceToStorageSpace(unsigned AS) {
+ switch (PISAAS::AddressSpace(AS)) {
+ case PISAAS::AddressSpace::PRIVATE:
+ return PISA::StorageSpace::PRIVATE;
+ case PISAAS::AddressSpace::GLOBAL:
+ return PISA::StorageSpace::GLOBAL;
+ case PISAAS::AddressSpace::CONSTANT:
+ return PISA::StorageSpace::CONSTANT;
+ case PISAAS::AddressSpace::SHARED:
+ return PISA::StorageSpace::SHARED;
+ case PISAAS::AddressSpace::GENERIC:
+ return PISA::StorageSpace::GENERIC;
+ }
+ llvm_unreachable("Unexpected address space!");
+}
+
+static StringRef getStorageSpaceRepr(PISA::StorageSpace SS) {
+ switch (SS) {
+ case PISA::StorageSpace::PRIVATE:
+ return "private";
+ case PISA::StorageSpace::GLOBAL:
+ return "global";
+ case PISA::StorageSpace::CONSTANT:
+ return "const";
+ case PISA::StorageSpace::SHARED:
+ return "shared";
+ case PISA::StorageSpace::GENERIC:
+ return "generic";
+ }
+ llvm_unreachable("Invalid storage space!");
+}
+
+static StringRef getParamASRepr(PISAAS::AddressSpace AS) {
+ switch (AS) {
+ case PISAAS::AddressSpace::GLOBAL:
+ return "global";
+ case PISAAS::AddressSpace::CONSTANT:
+ return "const";
+ case PISAAS::AddressSpace::SHARED:
+ return "shared";
+ case PISAAS::AddressSpace::GENERIC:
+ return "generic";
+ default:
+ break;
+ }
+ llvm_unreachable("Invalid parameter address space!");
+}
+
+StringRef PISA::getLinkageTyName(PISA::LinkageTy Linkage) {
+ switch (Linkage) {
+ case DEFAULT:
+ return "default";
+ case EXPORT:
+ return "export";
+ case IMPORT:
+ return "import";
+ }
+ llvm_unreachable("Invalid linkage type!");
+}
+
+static StringRef getFunctionDirectiveRepr(bool IsKernel) {
+ return IsKernel ? ".kernel" : ".function";
+}
+
+static std::string getKernelAttributeRepr(const KernelAttribute &Attr) {
+
+ DenseMap<PISA::KernelAttributeType, StringRef> AvailableMetadataNodeTypes = {
+ {PISA::KernelAttributeType::REQD_WORK_GROUP_SIZE,
+ ".reqd_work_group_size"},
+ {PISA::KernelAttributeType::VEC_TYPE_HINT, ".vec_type_hint"}};
+
+ std::string Result;
+ DenseMap<PISA::KernelAttributeType, StringRef>::iterator It =
+ AvailableMetadataNodeTypes.find(Attr.KernelAttrType);
+ if (It != AvailableMetadataNodeTypes.end()) {
+ Result = It->second;
+ }
+
+ switch (Attr.KernelAttrType) {
+ case llvm::PISA::KernelAttributeType::REQD_WORK_GROUP_SIZE: {
+ Result += "(";
+ const std::vector<uint32_t> &Values =
+ std::get<std::vector<uint32_t>>(Attr.KernelAttrValues);
+ if (!Values.empty()) {
+ Result +=
+ std::accumulate(std::next(Values.begin()), Values.end(),
+ std::to_string(Values.front()),
+ [](const std::string &Acc, uint32_t El) {
+ return Acc + std::string(", ") + std::to_string(El);
+ });
+ }
+ Result += ")";
+ } break;
+ case llvm::PISA::KernelAttributeType::VEC_TYPE_HINT: {
+ Result += "(";
+ const std::string &Arg = std::get<std::string>(Attr.KernelAttrValues);
+ Result += Arg;
+ Result += ")";
+ } break;
+ }
+ return Result;
+}
+
+static void emitTypeString(uint32_t TypeSizeInBits, uint32_t NumElts,
+ raw_ostream &OS) {
+ assert(NumElts > 0);
+ if (NumElts == 1 && TypeSizeInBits == 1) {
+ OS << ".pred";
+ return;
+ }
+
+ if (NumElts > 1)
+ OS << ".v" << NumElts;
+ OS << "." << TypeSizeInBits << "b";
+}
+
+static void emitTypeString(const LLT &T, raw_ostream &OS) {
+ uint32_t TypeBitSize = T.getScalarSizeInBits();
+ uint32_t NumElts = T.isVector() ? T.getNumElements() : 1;
+ emitTypeString(TypeBitSize, NumElts, OS);
+}
+
+static void printOffset(int64_t Val, raw_ostream &OS) {
+ // Print an immediate offset only when it is nonzero.
+ if (Val > 0) {
+ OS << "+" << format("%" PRId64, Val);
+ } else if (Val < 0) {
+ if (Val == std::numeric_limits<int64_t>::min())
+ OS << "-" << format("%" PRIu64, Val);
+ else
+ OS << "-" << format("%" PRId64, -Val);
+ }
+}
+
+namespace {
+
+class PISATargetAsmStreamer final : public PISATargetStreamer {
+ formatted_raw_ostream &OS;
+ const MCAsmInfo *MAI = nullptr;
+ void printName(raw_ostream &OS, StringRef Name) {
+ PISAInstPrinter::printSymbolName(OS, Name, MAI);
+ }
+
+public:
+ PISATargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
+ : PISATargetStreamer(S), OS(OS), MAI(&S.getContext().getAsmInfo()) {}
+ ~PISATargetAsmStreamer() override;
+
+ StringRef emitHeader(const PISA::HeaderDcl &HD) override {
+ if (HD.Version != 0)
+ OS << ".version " << (HD.Version / 100) << "." << (HD.Version % 100)
+ << ";\n";
+ if (!HD.Target.empty())
+ OS << ".target " << HD.Target << ";\n";
+ return HD.Target;
+ }
+
+ void emitGlobalVariable(const PISA::GlobalVariableDcl &GV) override {
+ if (GV.Dcl.Linkage != PISA::LinkageTy::DEFAULT)
+ OS << "." << getLinkageTyName(GV.Dcl.Linkage) << " ";
+
+ // globals must have .const or .global addrspace
+ switch (GV.Dcl.SS) {
+ case PISA::StorageSpace::GLOBAL:
+ OS << ".global ";
+ break;
+ case PISA::StorageSpace::CONSTANT:
+ OS << ".const ";
+ break;
+ default:
+ llvm_unreachable("Invalid storage space for global variables");
+ }
+
+ OS << " .align " << GV.Dcl.Alignment.value() << " ";
+
+ if (!GV.Dcl.Section.empty())
+ OS << ".section(\"" << GV.Dcl.Section << "\") ";
+
+ if (!GV.Dcl.HostAccessName.empty())
+ OS << ".host_access(\"" << GV.Dcl.HostAccessName << "\") ";
+
+ OS << "@";
+ printName(OS, GV.Dcl.Name);
+
+ if (GV.Init.Initializer.empty()) {
+ OS << "[" << GV.Dcl.Size << "]";
+ } else {
+ OS << " = { ";
+ for (uint64_t I = 0; I < GV.Init.Initializer.size(); ++I) {
+ const PISA::VariableInit::InitElement &X = GV.Init.Initializer[I];
+ OS << ((I == 0) ? "" : ", ");
+ DenseMap<uint64_t, PISA::VariableInit::SpecialEntry>::const_iterator
+ Iter = GV.Init.Exprs.find(I);
+ if (Iter != GV.Init.Exprs.end()) {
+ const PISA::VariableInit::SpecialEntry &Entry = Iter->second;
+ if (const PISA::VariableInit::GlobalExpr *G =
+ std::get_if<PISA::VariableInit::GlobalExpr>(&Entry)) {
+ OS << "." << X.Type.getSizeInBits() << "b ";
+ OS << "@" << G->Name;
+ printOffset(G->Offset, OS);
+ } else if (const PISA::VariableInit::Zeros *Z =
+ std::get_if<PISA::VariableInit::Zeros>(&Entry)) {
+ OS << ".zero " << Z->N;
+ } else {
+ llvm_unreachable("unknown construct!");
+ }
+ } else {
+ TypeSize SizeInBits = X.Type.getSizeInBits();
+ OS << "." << SizeInBits << "b ";
+ OS << format_hex(X.Value & maskTrailingOnes<uint64_t>(SizeInBits), 1);
+ }
+ }
+ OS << " }";
+ }
+
+ OS << ";\n";
+ }
+
+ void emitFunctionSignature(const PISA::FunctionSignature &Sig) override {
+ if (!Sig.DN.IsKernel) {
+ switch (Sig.DN.Linkage) {
+ case PISA::LinkageTy::EXPORT:
+ OS << ".export ";
+ break;
+ case PISA::LinkageTy::IMPORT:
+ OS << ".import ";
+ break;
+ default:
+ break;
+ }
+ }
+
+ OS << getFunctionDirectiveRepr(Sig.DN.IsKernel) << " ";
+
+ for (const PISA::KernelAttribute &KernelAttr : Sig.DN.KernelAttrs) {
+ OS << getKernelAttributeRepr(KernelAttr) << " ";
+ }
+
+ if (!Sig.DN.IsKernel) {
+ if (Sig.DN.RetLLT.isValid())
+ emitTypeString(Sig.DN.RetLLT, OS);
+ else
+ OS << "void";
+ OS << " ";
+ }
+
+ OS << "@";
+ printName(OS, Sig.DN.Name);
+
+ OS << "(";
+ if (!Sig.DN.IsKernel) {
+ const char *Sep = "";
+ for (const PISA::FunctionParameter &Param : Sig.FunctionParams) {
+ OS << Sep << ".reg ";
+ emitTypeString(Param.Ty, OS);
+ OS << " " << Param.Prefix << Param.Idx;
+ Sep = ", ";
+ }
+ } else {
+ const char *Sep = "";
+ unsigned I = 0;
+ for (const PISA::KernelParameter &Param : Sig.KernelParams) {
+ OS << Sep << ".param[" << Param.Size << "] ";
+ if (Param.hasAlign())
+ OS << ".align(" << Param.Align << ") ";
+ if (Param.hasAS())
+ OS << ".addrspace("
+ << getParamASRepr(static_cast<PISAAS::AddressSpace>(Param.AS))
+ << ") ";
+ if (Param.hasPtrAlign())
+ OS << ".ptr_align(" << Param.PtrAlign << ") ";
+ if (!Param.ArgName.empty())
+ OS << "%" << Param.ArgName;
+ else
+ OS << "%arg" << I;
+ I++;
+ Sep = ", ";
+ }
+ }
+
+ OS << ")";
+
+ OS << "\n";
+ }
+
+ void emitFunctionDeclaration(const PISA::FunctionDeclaration &Dcl) override {
+ assert(!Dcl.DN.IsKernel);
+
+ if (Dcl.DN.Linkage != PISA::LinkageTy::IMPORT) {
+ return;
+ }
+
+ OS << ".import ";
+ OS << getFunctionDirectiveRepr(Dcl.DN.IsKernel) << " ";
+
+ if (Dcl.DN.RetLLT.isValid()) {
+ emitTypeString(Dcl.DN.RetLLT, OS);
+ } else
+ OS << "void";
+
+ OS << " @";
+ printName(OS, Dcl.DN.Name);
+
+ OS << "(";
+ const char *Sep = "";
+ for (const PISA::FunctionDeclParam &Param : Dcl.FunctionParams) {
+ OS << Sep << ".reg ";
+ emitTypeString(Param.Ty, OS);
+ Sep = ", ";
+ }
+ OS << ");";
+ }
+
+ void addRegDcl(unsigned NumElts, unsigned EltSize, unsigned RegType,
+ RegNamesRange RegNames, bool MustAdd) override {
+ llvm_unreachable("Never used.");
+ }
+
+ void emitRegDcls(const PISA::RegDcls &Dcls,
+ const PISA::DataTypes &DTs) override {
+ for (const std::pair<std::tuple<unsigned, unsigned, unsigned>,
+ PISA::TypeInfo> &Entry : DTs) {
+ const std::tuple<unsigned, unsigned, unsigned> &Key = Entry.first;
+ const PISA::TypeInfo &TI = Entry.second;
+ // Skip if 0 registers of this type were declared
+ if (TI.RegStart == TI.RegCounter)
+ continue;
+
+ unsigned NumElts = std::get<0>(Key);
+ unsigned BitWidth = std::get<1>(Key);
+ unsigned RegType = std::get<2>(Key);
+
+ switch (RegType) {
+ case PISA::RegEncoder::PRED:
+ OS << "\t.pred ";
+ break;
+ case PISA::RegEncoder::REG:
+ OS << "\t.reg ";
+ emitTypeString(BitWidth, NumElts, OS);
+ OS << " ";
+ break;
+ default:
+ llvm_unreachable("unknown reg type!");
+ }
+
+ // Do not use range syntax if only 5 or fewer registers were declared
+ if (TI.RegCounter - TI.RegStart <= 5) {
+ for (unsigned I = TI.RegStart; I < TI.RegCounter; ++I) {
+ if (I != TI.RegStart)
+ OS << ", ";
+ OS << TI.Prefix << I;
+ }
+ OS << ";\n";
+ } else {
+ OS << TI.Prefix << "<" << TI.RegStart << "~" << (TI.RegCounter)
+ << ">;\n";
+ }
+ }
+ }
+
+ void addLocalVariableDecl(const PISA::LocalVariableDcl &V) override {
+ OS << "\t." << getStorageSpaceRepr(V.SS) << " ";
+ OS << ".align " << V.Alignment.value() << " ";
+ OS << "@";
+ // If PISA comes from PISA reader StackIndex won't be set, so we fall
+ // back and use already parsed name.
+ if (V.StackIndex == -1) {
+ OS << V.Name;
+ } else {
+ OS << "R" << V.StackIndex;
+ }
+ OS << '[' << V.Size << "];\n";
+ }
+
+ void emitLocalVariableDcls(const PISA::LocalVariableDcls &Dcls) override {
+ for (const PISA::LocalVariableDcl &V : Dcls.Vars)
+ addLocalVariableDecl(V);
+ }
+
+ void emitFuncBodyStart() override { OS << "{\n"; }
+ void emitFuncBodyEnd() override { OS << "}\n"; }
+
+ bool isAsmStreamer() const override { return true; }
+ int getCurLine() const override {
+ // getLine() in OS is 0 based
+ return OS.getLine() + 1;
+ }
+};
+
+class PISATargetELFStreamer final : public PISATargetStreamer {
+public:
+ PISATargetELFStreamer(MCStreamer &S) : PISATargetStreamer(S) {}
+ ~PISATargetELFStreamer() override;
+
+ StringRef emitHeader(const PISA::HeaderDcl &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitGlobalVariable(const PISA::GlobalVariableDcl &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitFunctionSignature(const PISA::FunctionSignature &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitFunctionDeclaration(const PISA::FunctionDeclaration &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitRegDcls(const PISA::RegDcls &, const PISA::DataTypes &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitLocalVariableDcls(const PISA::LocalVariableDcls &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitFuncBodyStart() override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void emitFuncBodyEnd() override { llvm_unreachable("Not implemented yet!"); }
+
+ void addRegDcl(unsigned NumElts, unsigned EltSize, unsigned RegType,
+ RegNamesRange RegNames, bool MustAdd = true) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+ void addLocalVariableDecl(const PISA::LocalVariableDcl &) override {
+ llvm_unreachable("Not implemented yet!");
+ }
+};
+
+class PISATargetNullStreamer final : public PISATargetStreamer {
+public:
+ PISATargetNullStreamer(MCStreamer &S) : PISATargetStreamer(S) {}
+ ~PISATargetNullStreamer() override;
+
+ StringRef emitHeader(const PISA::HeaderDcl &) override { return ""; }
+ void emitGlobalVariable(const PISA::GlobalVariableDcl &) override {}
+ void emitFunctionSignature(const PISA::FunctionSignature &) override {}
+ void emitFunctionDeclaration(const PISA::FunctionDeclaration &) override {}
+ void emitRegDcls(const PISA::RegDcls &, const PISA::DataTypes &) override {}
+ void emitLocalVariableDcls(const PISA::LocalVariableDcls &) override {}
+ void emitFuncBodyStart() override {}
+ void emitFuncBodyEnd() override {}
+
+ void addRegDcl(unsigned NumElts, unsigned EltSize, unsigned RegType,
+ RegNamesRange RegNames, bool MustAdd = true) override {}
+ void addLocalVariableDecl(const PISA::LocalVariableDcl &) override {}
+};
+
+} // namespace
+
+PISATargetStreamer::~PISATargetStreamer() = default;
+PISATargetAsmStreamer::~PISATargetAsmStreamer() = default;
+PISATargetELFStreamer::~PISATargetELFStreamer() = default;
+PISATargetNullStreamer::~PISATargetNullStreamer() = default;
+
+MCTargetStreamer *
+llvm::createPISAAsmTargetStreamer(MCStreamer &S, formatted_raw_ostream &OS,
+ MCInstPrinter *InstPrinter) {
+ return new PISATargetAsmStreamer(S, OS);
+}
+
+MCTargetStreamer *
+llvm::createPISAObjectTargetStreamer(MCStreamer &S,
+ const MCSubtargetInfo &STI) {
+ const Triple &TT = STI.getTargetTriple();
+ if (TT.isOSBinFormatELF())
+ return new PISATargetELFStreamer(S);
+ return nullptr;
+}
+
+MCTargetStreamer *llvm::createPISANullTargetStreamer(MCStreamer &S) {
+ return new PISATargetNullStreamer(S);
+}
+
+DataType DataTypes::getTypeFromLLT(LLT Ty) {
+ unsigned NumElts = Ty.isScalar() ? 1 : Ty.getNumElements();
+ unsigned EltSize = Ty.getScalarSizeInBits();
+ unsigned RegType =
+ EltSize == 1 ? PISA::RegEncoder::PRED : PISA::RegEncoder::REG;
+ return DataType{NumElts, EltSize, RegType};
+}
+
+LLT DataTypes::getLLTFromType(const DataType &Ty) {
+ if (Ty.NumElts == 1) {
+ return LLT::integer(Ty.EltSize);
+ }
+ return LLT::vector(ElementCount::getFixed(Ty.NumElts), Ty.EltSize);
+}
+
+std::string DataTypes::getPrefixFromLLT(LLT Ty) {
+ unsigned NumElts = Ty.isScalar() ? 1 : Ty.getNumElements();
+ unsigned EltSize = Ty.getScalarSizeInBits();
+ std::string Prefix = "%";
+
+ const DenseMap<unsigned, StringRef> VectorPrefixes = {
----------------
topperc wrote:
Seems a little weird to use a DenseMap here.
https://github.com/llvm/llvm-project/pull/214107
More information about the llvm-branch-commits
mailing list