================
@@ -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 = "";
----------------
topperc wrote:

Use `ListSeparator`

https://github.com/llvm/llvm-project/pull/214107
_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to