[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