================ @@ -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) ? "" : ", "); ---------------- topperc wrote:
Can this use `ListSeparator` from llvm/include/llvm/ADT/StringExtras.h instead of using `I==0`? Would that allow you to use a range-based loop? 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
