[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:27 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 = "";
----------------
topperc wrote:
Use `ListSeparator`
https://github.com/llvm/llvm-project/pull/214107
More information about the llvm-branch-commits
mailing list