[llvm-branch-commits] [llvm] [3/7][PISA] Add PISA register file, instruction set, and MC layer (PR #214107)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Tue Aug 4 17:52:09 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
@llvm/pr-subscribers-llvm-mc
Author: Michal Paszkowski (michalpaszkowski)
<details>
<summary>Changes</summary>
Add the PISA register file and register-bank descriptions, the instruction
formats and definitions, and the MC/assembly layer (instruction printer,
register and code encoders, target streamer, MC target description and the
supporting enums), replacing the stub descriptions from
the initial target skeleton.
This provides the instruction-set description and assembly-emission
foundation. The GlobalISel lowering and instruction selection that consume it
are added in the following changes.
---
Patch is 358.40 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/214107.diff
39 Files Affected:
- (modified) llvm/include/llvm/IR/CallingConv.h (+4)
- (modified) llvm/include/llvm/MC/MCInst.h (+20)
- (added) llvm/include/llvm/Target/PISA/MnemonicOperand.td (+344)
- (modified) llvm/lib/MC/MCInst.cpp (+2)
- (modified) llvm/lib/Target/PISA/CMakeLists.txt (+12-1)
- (modified) llvm/lib/Target/PISA/MCTargetDesc/CMakeLists.txt (+4)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISABaseInfo.h (+44)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISAEnum.cpp (+19)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISAEnum.h (+65)
- (modified) llvm/lib/Target/PISA/MCTargetDesc/PISAInstPrinter.cpp (+394-11)
- (modified) llvm/lib/Target/PISA/MCTargetDesc/PISAInstPrinter.h (+83-1)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISAMCExpr.cpp (+31)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISAMCExpr.h (+54)
- (modified) llvm/lib/Target/PISA/MCTargetDesc/PISAMCTargetDesc.cpp (+19-6)
- (modified) llvm/lib/Target/PISA/MCTargetDesc/PISAMCTargetDesc.h (+24)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISARegEncoder.cpp (+183)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISARegEncoder.h (+73)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISATargetStreamer.cpp (+572)
- (added) llvm/lib/Target/PISA/MCTargetDesc/PISATargetStreamer.h (+286)
- (modified) llvm/lib/Target/PISA/PISA.td (+11-3)
- (added) llvm/lib/Target/PISA/PISACacheCtrlMMRA.h (+92)
- (added) llvm/lib/Target/PISA/PISACombine.td (+1075)
- (added) llvm/lib/Target/PISA/PISADefines.h (+52)
- (added) llvm/lib/Target/PISA/PISAGenericOpcodes.td (+99)
- (added) llvm/lib/Target/PISA/PISAHelpers.h (+38)
- (added) llvm/lib/Target/PISA/PISAInstrFormats.td (+834)
- (modified) llvm/lib/Target/PISA/PISAInstrInfo.cpp (+448-1)
- (modified) llvm/lib/Target/PISA/PISAInstrInfo.h (+31)
- (modified) llvm/lib/Target/PISA/PISAInstrInfo.td (+2512-12)
- (added) llvm/lib/Target/PISA/PISAMCInstLower.cpp (+134)
- (added) llvm/lib/Target/PISA/PISAMCInstLower.h (+103)
- (added) llvm/lib/Target/PISA/PISARegManager.cpp (+62)
- (added) llvm/lib/Target/PISA/PISARegManager.h (+47)
- (added) llvm/lib/Target/PISA/PISARegisterBanks.td (+15)
- (modified) llvm/lib/Target/PISA/PISARegisterInfo.cpp (+267-5)
- (modified) llvm/lib/Target/PISA/PISARegisterInfo.h (+55)
- (modified) llvm/lib/Target/PISA/PISARegisterInfo.td (+242-12)
- (added) llvm/lib/Target/PISA/PISAUtils.cpp (+52)
- (added) llvm/lib/Target/PISA/PISAUtils.h (+36)
``````````diff
diff --git a/llvm/include/llvm/IR/CallingConv.h b/llvm/include/llvm/IR/CallingConv.h
index 249c512dda532..7992dac627a76 100644
--- a/llvm/include/llvm/IR/CallingConv.h
+++ b/llvm/include/llvm/IR/CallingConv.h
@@ -297,6 +297,9 @@ namespace CallingConv {
/// stateless compartment.
CHERIoT_LibraryCall = 127,
+ /// Used for PISA kernel functions.
+ PISA_KERNEL = 183,
+
/// The highest possible ID. Must be some 2^k - 1.
MaxID = 1023
};
@@ -323,6 +326,7 @@ constexpr bool isCallableCC(CallingConv::ID CC) {
case CallingConv::AMDGPU_PS:
case CallingConv::AMDGPU_VS:
case CallingConv::SPIR_KERNEL:
+ case CallingConv::PISA_KERNEL:
case CallingConv::PTX_Kernel:
return false;
default:
diff --git a/llvm/include/llvm/MC/MCInst.h b/llvm/include/llvm/MC/MCInst.h
index b0db6b8408da5..adba42f4ac1fa 100644
--- a/llvm/include/llvm/MC/MCInst.h
+++ b/llvm/include/llvm/MC/MCInst.h
@@ -42,6 +42,7 @@ class MCOperand {
kInvalid, ///< Uninitialized.
kRegister, ///< Register operand.
kImmediate, ///< Immediate operand.
+ kHFPImmediate, ///< Half-floating-point immediate operand.
kSFPImmediate, ///< Single-floating-point immediate operand.
kDFPImmediate, ///< Double-Floating-point immediate operand.
kExpr, ///< Relocatable immediate operand.
@@ -52,6 +53,7 @@ class MCOperand {
union {
unsigned RegVal;
int64_t ImmVal;
+ uint16_t HFPImmVal;
uint32_t SFPImmVal;
uint64_t FPImmVal;
const MCExpr *ExprVal;
@@ -64,6 +66,7 @@ class MCOperand {
bool isValid() const { return Kind != kInvalid; }
bool isReg() const { return Kind == kRegister; }
bool isImm() const { return Kind == kImmediate; }
+ bool isHFPImm() const { return Kind == kHFPImmediate; }
bool isSFPImm() const { return Kind == kSFPImmediate; }
bool isDFPImm() const { return Kind == kDFPImmediate; }
bool isExpr() const { return Kind == kExpr; }
@@ -91,6 +94,16 @@ class MCOperand {
ImmVal = Val;
}
+ uint16_t getHFPImm() const {
+ assert(isHFPImm() && "This is not an HFP immediate");
+ return HFPImmVal;
+ }
+
+ void setHFPImm(uint16_t Val) {
+ assert(isHFPImm() && "This is not an HFP immediate");
+ HFPImmVal = Val;
+ }
+
uint32_t getSFPImm() const {
assert(isSFPImm() && "This is not an SFP immediate");
return SFPImmVal;
@@ -149,6 +162,13 @@ class MCOperand {
return Op;
}
+ static MCOperand createHFPImm(uint16_t Val) {
+ MCOperand Op;
+ Op.Kind = kHFPImmediate;
+ Op.HFPImmVal = Val;
+ return Op;
+ }
+
static MCOperand createSFPImm(uint32_t Val) {
MCOperand Op;
Op.Kind = kSFPImmediate;
diff --git a/llvm/include/llvm/Target/PISA/MnemonicOperand.td b/llvm/include/llvm/Target/PISA/MnemonicOperand.td
new file mode 100644
index 0000000000000..ecdfe71282df5
--- /dev/null
+++ b/llvm/include/llvm/Target/PISA/MnemonicOperand.td
@@ -0,0 +1,344 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// DAG operator used for dag representation of a condition flag: (cflag FlagName value)
+// These are used in EnumOptionOpnd to represent certain
+def cflag;
+
+// Function to find index of a item from a list of string.
+// Note that tablegen does not allow recursive definition.
+class getIndexFromList<list<string> slist, string item> {
+ int Idx = !cond(!and(!ge(!size(slist),1), !eq(slist[0],item)) : 0,
+ !and(!ge(!size(slist),2), !eq(slist[1],item)) : 1,
+ !and(!ge(!size(slist),3), !eq(slist[2],item)) : 2,
+ !and(!ge(!size(slist),4), !eq(slist[3],item)) : 3,
+ !and(!ge(!size(slist),5), !eq(slist[4],item)) : 4,
+ !and(!ge(!size(slist),6), !eq(slist[5],item)) : 5,
+ !and(!ge(!size(slist),7), !eq(slist[6],item)) : 6,
+ !and(!ge(!size(slist),8), !eq(slist[7],item)) : 7,
+ !and(!ge(!size(slist),9), !eq(slist[8],item)) : 8,
+ !and(!ge(!size(slist),10),!eq(slist[9],item)) : 9,
+ !and(!ge(!size(slist),11),!eq(slist[10],item)) : 10,
+ !and(!ge(!size(slist),12),!eq(slist[11],item)) : 11,
+ !and(!ge(!size(slist),13),!eq(slist[12],item)) : 12,
+ !and(!ge(!size(slist),14),!eq(slist[13],item)) : 13,
+ !and(!ge(!size(slist),15),!eq(slist[14],item)) : 14,
+ !and(!ge(!size(slist),16),!eq(slist[15],item)) : 15,
+ true : -1);
+}
+
+// Flags are encoded from msb - 1 - numflags to lsb
+class getShiftedFlag<list<string> cFlagNames, string flagName> {
+ defvar LsbIdx = !sub(!sub(!size(cFlagNames), 1), getIndexFromList<cFlagNames, flagName>.Idx);
+ bits<16> enc = !shl(1, LsbIdx);
+}
+
+// Get bits enabled for all flags in daglist regardless of the value.
+// e.g. if flag f1 is positioned at 2^2 and f2 in 2^0,
+// [(cflag "f1", true), (cflag "f2", false)] -> {... 0, 1, 0, 1}
+class EncodeCFlagMask<list<string> cFlagNames, list<dag> cFlags> {
+ bits<16> enc = !foldl(0, cFlags, acc, fdag,
+ !or(getShiftedFlag<cFlagNames, !getdagarg<string>(fdag, "name")>.enc, acc));
+}
+
+// Get bits enables for all flags in daglist if the value is true.
+// e.g. if flag f1 is positioned at 2^2 and f2 in 2^0,
+// [(cflag "f1", true), (cflag "f2", false)] -> {... 0, 1, 0, 0}
+class EncodeCFlag<list<string> cFlagNames, list<dag> cFlags> {
+ bits<16> enc = !foldl(0, cFlags, acc, fdag,
+ !or(!and(!getdagarg<bit>(fdag, "val"),
+ getShiftedFlag<cFlagNames, !getdagarg<string>(fdag, "name")>.enc),
+ acc));
+}
+
+
+// ----- Definitions for EnumOptions.
+// Base definitions for operands that have a value selected from a
+// set of limited options.
+
+// Convert list of flag bits into a single accumulated value in bits<16>
+class EncodeCFlagFromList<list<bit> bitList> {
+ bits<16> enc = !foldl(0, bitList, acc, flag, !or(!shl(acc, 1), flag));
+}
+
+// Enum to list all type of EnumOptions
+def EnumOptionClass: GenericEnum {
+ let FilterClass = "EnumOptionClassEntry";
+ let NameField = "EnumName";
+}
+
+// Lookup name string for enum types
+def EnumOptionStrTable : GenericTable {
+ let FilterClass = "EnumOptionClassEntry";
+ let CppTypeName = "EnumOptionStrEntry";
+ let Fields = ["Type", "Str"];
+ string TypeOf_Type = "EnumOptionClass";
+ let PrimaryKey = ["Type"];
+ let PrimaryKeyName = "lookupEnumOptionStr";
+}
+
+class EnumOptionClassEntry<string name> {
+ EnumOptionClassEntry Type = !cast<EnumOptionClassEntry>(NAME);
+ string EnumName = "EO_"#name;
+ string Str = name;
+}
+
+// Base class used to define per option enum entries
+class EnumOptionEntry<EnumOptionClassEntry ClassID, string name, int val, string enumPrefix="", string optStr=!tolower(name), string enumName="", list<bit> cFlags=[]> {
+ EnumOptionClassEntry OptClass = ClassID;
+ EnumOptionEntry EnumValue = !cast<EnumOptionEntry>(NAME);
+ string OptStr = optStr;
+
+ // Capitalize the name and add prefix for enum type
+ string EnumName = !cond(!not(!empty(enumName)) : enumName,
+ !empty(enumPrefix) : !toupper(name),
+ true : enumPrefix#"_"#!toupper(name));
+
+ // Need "bits<bit_size> Value" in all inheriting classes
+ bits<32> Value = val;
+
+ // Flags to classify the enum values
+ bits<16> CFlagEnc = EncodeCFlagFromList<cFlags>.enc;
+}
+
+// Store EnumOption related info
+class EnumOptionInfo<EnumOptionClassEntry OptID, ValueType vt, string enumPrefix,
+ bit isMandatory, int defaultVal,
+ Operand opnd, list<string> cFlagNames> {
+ EnumOptionClassEntry OptClassID = OptID;
+ ValueType VT = vt;
+ string EnumPrefix = enumPrefix;
+ bit IsMandatory = isMandatory;
+ int DefaultVal = defaultVal;
+ Operand Opnd = opnd;
+ list<string> CFlagNames = cFlagNames;
+}
+
+class EnumOptionEntryDef<EnumOptionInfo info, string name, int val, string optStr=!tolower(name), string enumName="">
+ : EnumOptionEntry<info.OptClassID, name, val, info.EnumPrefix, optStr, enumName>;
+
+def EnumOptionTable : GenericTable {
+ let FilterClass = "EnumOptionEntry";
+ let Fields = ["OptClass", "Value", "OptStr", "CFlagEnc"];
+ string TypeOf_OptClass = "EnumOptionClass";
+ // FIXME: Is there a way to get EnumName printed in the table
+ // rather than int literals?
+ let PrimaryKey = ["OptClass", "Value"];
+ let PrimaryKeyName = "lookupEnumOptionByValue";
+}
+
+def lookupEnumOptionByOptStr : SearchIndex {
+ let Table = EnumOptionTable;
+ let Key = ["OptClass", "OptStr"];
+}
+
+def lookupEnumOptionsWithClass : SearchIndex {
+ let Table = EnumOptionTable;
+ let Key = ["OptClass"];
+}
+
+// Base for defining enum and lookup tables
+multiclass EnumTypeDef<string EnumEntryClassName=NAME#"Entry", string enumPrefix=""> {
+ // Define enum definition
+ // User must define a entry class named as EnumEntryClassName by inheriting EnumOptionEntry
+ def NAME : GenericEnum {
+ let FilterClass = EnumEntryClassName;
+ let NameField = "EnumName";
+ let ValueField = "Value";
+ string EnumPrefix = enumPrefix;
+ }
+}
+
+class EnumOptionOpndPMC<string name,
+ string optClassStr,
+ bit isMandatory = false,
+ int defaultVal = 0,
+ bits<16> CFlagMask = 0,
+ bits<16> CFlagCond = 0> : AsmOperandClass {
+ let Name = name;
+ let ParserMethod = "parseEnumOptionOpnd("#optClassStr#","#isMandatory#","#defaultVal#")";
+ let ParserMethod = "parseEnumOptionOpnd("#optClassStr#","#isMandatory#","#CFlagMask#","#CFlagCond#","#defaultVal#")";
+ let PredicateMethod = "isEnumOptionOpnd("#optClassStr#")";
+ let RenderMethod = "addEnumOptionOpnd("#optClassStr#")";
+}
+
+class EnumOptionOpnd<ValueType vt,
+ string opndName,
+ EnumOptionClassEntry optClassID,
+ bit isMandatory = false,
+ int defaultVal = 0> : Operand<vt> {
+ // Mask that need to filter relevant flags
+ bits<16> CFlagMask = 0;
+ // Matched value after masking
+ bits<16> CFlagCond = 0;
+ let OperandType = "OPERAND_IMMEDIATE";
+ let PrintMethod = "printEnumOption("#optClassID.EnumName#","#isMandatory#","#defaultVal#")";
+ let ParserMatchClass = EnumOptionOpndPMC<opndName, optClassID.EnumName, isMandatory, defaultVal, CFlagMask, CFlagCond>;
+}
+
+multiclass EnumOptionOpndDef<
+ ValueType vt,
+ string enumPrefix,
+ bit isMandatory = false,
+ int defaultVal = 0,
+ list<string> cFlagNames = [],
+ string EnumEntryClassName = NAME#"Entry"> {
+ // Define enum type representing the enum class
+ defvar TypeName = NAME#"ClassID";
+ def TypeName : EnumOptionClassEntry<NAME>;
+ defvar optClassID = !cast<EnumOptionClassEntry>(TypeName);
+ defm NAME : EnumTypeDef<EnumEntryClassName, enumPrefix>;
+
+ defvar OpndName = NAME#"Opnd";
+ def OpndName
+ : EnumOptionOpnd<vt, EnumEntryClassName#"Opnd", optClassID, isMandatory, defaultVal> ;
+ def NAME#"EnumOptionInfo"
+ : EnumOptionInfo<optClassID, vt, enumPrefix,
+ isMandatory, defaultVal,
+ !cast<Operand>(OpndName), cFlagNames>;
+}
+
+class EnumOptionIDEntry;
+
+def EnumOptionID : GenericEnum {
+ let FilterClass = "EnumOptionIDEntry";
+}
+
+class EnumOptionTableEntry<string optstr>{
+ EnumOptionIDEntry OptID = !cast<EnumOptionIDEntry>(NAME);
+ string OptStr = optstr;
+}
+
+class EnumOptionOpndParserMatchClass<string OptID> : AsmOperandClass {
+ let Name = NAME;
+ let ParserMethod = "parseEnumOptionOpnd("#OptID#")";
+ let PredicateMethod = "isEnumOptionOpnd("#OptID#")";
+ let RenderMethod = "addEnumOptionOpnd("#OptID#")";
+}
+
+class EnumOptionOpndWithDefaultOps<
+ string OptID, EnumOptionOpndParserMatchClass pmc, bit isMandatory = false,
+ int defaultVal = 0> :
+ OperandWithDefaultOps<i32, (ops(i32 defaultVal))> {
+ let OperandType = "OPERAND_IMMEDIATE";
+ let MIOperandInfo = (ops i32imm);
+ let PrintMethod = "printEnumOption("#OptID#","#isMandatory#","#defaultVal#")";
+ let ParserMatchClass = pmc;
+}
+
+multiclass EnumOptionOpndWithDefaultOpsDef<
+ string enumPrefix, bit isMandatory = false, int defaultVal = 0,
+ string EnumEntryClassName = NAME#"Entry"> {
+ defvar TypeName = NAME#"ClassID";
+ def TypeName : EnumOptionClassEntry<NAME>;
+ defvar optClassID = !cast<EnumOptionClassEntry>(TypeName);
+ defm NAME : EnumTypeDef<EnumEntryClassName, enumPrefix>;
+
+ defvar OptID = "EO_"#NAME;
+ defvar OpndName = NAME#"Opnd";
+
+ def NAME#"OpndPMC" : EnumOptionOpndParserMatchClass<OptID> {
+ let ParserMethod = "parseEnumOptionOpnd("#OptID#","#isMandatory#",0,0,"#defaultVal#")";
+ }
+
+ def OpndName : EnumOptionOpndWithDefaultOps<
+ OptID, !cast<EnumOptionOpndParserMatchClass>(NAME#"OpndPMC"), isMandatory,
+ defaultVal>;
+}
+
+// Selects subset of given enum types to be used as an operand type.
+// cFlags are condition flags used to confine enum values to ones
+// that matches given flag name and values.
+// e.g. [(cflag "MyFlag1", true), (cflag "MyFlag2", false)] can be given
+// to only select enum values with MyFlag1 = true and MyFlag2 = false.
+class EnumOptionSubsetOpnd<EnumOptionInfo EOInfo, list<dag> cFlags>
+ : EnumOptionOpnd<EOInfo.VT, NAME#"Opnd", EOInfo.OptClassID, EOInfo.IsMandatory, EOInfo.DefaultVal> {
+ // This is used to mask only relevant flag bits this operand needs to match
+ let CFlagMask = EncodeCFlagMask<EOInfo.CFlagNames, cFlags>.enc;
+ // Flags values to be matched after masking.
+ let CFlagCond = EncodeCFlag<EOInfo.CFlagNames, cFlags>.enc;
+}
+
+// EnableFlag: Tells which bool value is valid for the option
+// 1: Accept only disabled, 2: Accept only enabled, 3: Accept both
+class BoolOptionOpndParserMatchClass<string OptID, int EnableFlag=3> : AsmOperandClass {
+ let Name = NAME;
+ let ParserMethod = "parseBoolOptionOpnd("#OptID#", "#EnableFlag#")";
+ let PredicateMethod = "isBoolOptionOpnd("#OptID#","#EnableFlag#")";
+ let RenderMethod = "addBoolOptionOpnd("#OptID#")";
+}
+
+class BoolOptionOpnd<string OptID, BoolOptionOpndParserMatchClass pmc> : Operand<i16> {
+ let OperandType = "OPERAND_IMMEDIATE";
+
+ // Pass optString as name
+ let PrintMethod = "printBoolOptionOpnd("#OptID#")";
+ let ParserMatchClass = pmc;
+}
+
+class BoolOptionOpndWithDefaultOps<string OptID, BoolOptionOpndParserMatchClass pmc, bit defaultVal = 0> : OperandWithDefaultOps<i16, (ops(i16 defaultVal))> {
+ let OperandType = "OPERAND_IMMEDIATE";
+
+ // Pass optString as name
+ let PrintMethod = "printBoolOptionOpnd("#OptID#")";
+ let ParserMatchClass = pmc;
+}
+
+// Assign IDs for each bool options
+def BoolOptionID : GenericEnum {
+ let FilterClass = "BoolOptionIDEntry";
+}
+
+// Table with option id to option string mapping
+def BoolOptionTable : GenericTable {
+ let FilterClass = "BoolOptionTableEntry";
+ let Fields = ["OptID", "OptStr"];
+ string TypeOf_OptID = "BoolOptionID";
+ let PrimaryKey = ["OptID"];
+ let PrimaryKeyName = "lookupBoolOptionByID";
+}
+
+def lookupBoolOptionByOptStr : SearchIndex {
+ let Table = BoolOptionTable;
+ let Key = ["OptStr"];
+}
+
+class BoolOptionIDEntry;
+
+class BoolOptionTableEntry<string optstr>{
+ BoolOptionIDEntry OptID = !cast<BoolOptionIDEntry>(NAME);
+ string OptStr = optstr;
+}
+
+// Dummy entry to ensure BoolOptionTable is never empty
+def BO_DUMMY_ : BoolOptionIDEntry, BoolOptionTableEntry<"">;
+
+multiclass DefBoolOptionOpndType<string OptID, int EnableFlag = 3> {
+ defvar PMCName = NAME#"OpndPMC";
+ def PMCName : BoolOptionOpndParserMatchClass<OptID, EnableFlag>;
+ def NAME#"Opnd" : BoolOptionOpnd<OptID, !cast<BoolOptionOpndParserMatchClass>(PMCName)>;
+}
+
+// DisabledOpnd type does not accept option but creates MIR operand with false value
+// EnabledOpnd mandates optional field to be present and create true operand
+multiclass BoolOptionOpndDef<string OptStr=!tolower(NAME), bit DefineDerivedOpnds = false> {
+ def "BO_"#NAME : BoolOptionIDEntry, BoolOptionTableEntry<OptStr>;
+ defvar OptID = "BO_"#NAME;
+ defm NAME : DefBoolOptionOpndType<OptID, 3>;
+ if DefineDerivedOpnds then {
+ defm NAME#"Disabled" : DefBoolOptionOpndType<OptID, 1>;
+ defm NAME#"Enabled" : DefBoolOptionOpndType<OptID, 2>;
+ }
+}
+
+multiclass BoolOptionOpndWithDefaultOpsDef<string OptStr=!tolower(NAME), bit defaultVal = 0> {
+ def "BO_"#NAME : BoolOptionIDEntry, BoolOptionTableEntry<OptStr>;
+ defvar OptID = "BO_"#NAME;
+ def NAME#"OpndPMC" : BoolOptionOpndParserMatchClass<OptID>;
+ def NAME#"Opnd" : BoolOptionOpndWithDefaultOps<OptID, !cast<BoolOptionOpndParserMatchClass>(NAME#"OpndPMC"), defaultVal>;
+}
diff --git a/llvm/lib/MC/MCInst.cpp b/llvm/lib/MC/MCInst.cpp
index f29cb48a16ece..7684f872c90fd 100644
--- a/llvm/lib/MC/MCInst.cpp
+++ b/llvm/lib/MC/MCInst.cpp
@@ -32,6 +32,8 @@ void MCOperand::print(raw_ostream &OS, const MCContext *Ctx) const {
OS << getReg().id();
} else if (isImm())
OS << "Imm:" << getImm();
+ else if (isHFPImm())
+ OS << "HFPImm:" << getHFPImm();
else if (isSFPImm())
OS << "SFPImm:" << bit_cast<float>(getSFPImm());
else if (isDFPImm())
diff --git a/llvm/lib/Target/PISA/CMakeLists.txt b/llvm/lib/Target/PISA/CMakeLists.txt
index fafef2a3c3fe8..321a75d7f88b6 100644
--- a/llvm/lib/Target/PISA/CMakeLists.txt
+++ b/llvm/lib/Target/PISA/CMakeLists.txt
@@ -4,33 +4,44 @@ set(LLVM_TARGET_DEFINITIONS PISA.td)
tablegen(LLVM PISAGenAsmWriter.inc -gen-asm-writer)
tablegen(LLVM PISAGenInstrInfo.inc -gen-instr-info)
+tablegen(LLVM PISAGenMCCodeEmitter.inc -gen-emitter)
tablegen(LLVM PISAGenRegisterInfo.inc -gen-register-info)
tablegen(LLVM PISAGenSubtargetInfo.inc -gen-subtarget)
+tablegen(LLVM PISAGenSearchableTables.inc -gen-searchable-tables)
add_public_tablegen_target(PISACommonTableGen)
add_llvm_target(PISACodeGen
PISAInstrInfo.cpp
+ PISAMCInstLower.cpp
+ PISARegManager.cpp
PISARegisterInfo.cpp
PISASubtarget.cpp
PISATargetMachine.cpp
+ PISAUtils.cpp
LINK_COMPONENTS
Analysis
+ AsmPrinter
CodeGen
CodeGenTypes
Core
+ Demangle
+ GlobalISel
MC
+ Passes
+ Scalar
SelectionDAG
Support
Target
TargetParser
+ TransformUtils
PISADesc
PISAInfo
ADD_TO_COMPONENT
PISA
- )
+)
add_subdirectory(MCTargetDesc)
add_subdirectory(TargetInfo)
diff --git a/llvm/lib/Target/PISA/MCTargetDesc/CMakeLists.txt b/llvm/lib/Target/PISA/MCTargetDesc/CMakeLists.txt
index 1e7639e93d484..45ea6b7a1d9d9 100644
--- a/llvm/lib/Target/PISA/MCTargetDesc/CMakeLists.txt
+++ b/llvm/lib/Target/PISA/MCTargetDesc/CMakeLists.txt
@@ -1,7 +1,11 @@
add_llvm_component_library(LLVMPISADesc
+ PISAEnum.cpp
PISAMCAsmInfo.cpp
PISAMCTargetDesc.cpp
+ PISATargetStreamer.cpp
PISAInstPrinter.cpp
+ PISAMCExpr.cpp
+ PISARegEncoder.cpp
LINK_COMPONENTS
CodeGenTypes
diff --git a/llvm/lib/Target/PISA/MCTargetDesc/PISABaseInfo.h b/llvm/lib/Target/PISA/MCTargetDesc/PISABaseInfo.h
new file mode 100644
index 0000000000000..a396a106f28e7
--- /dev/null
+++ b/llvm/lib/Target/PISA/MCTargetDesc/PISABaseInfo.h
@@ -0,0 +1,44 @@
+//===-- PISABaseInfo.h - Top level PISA definitions -----------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_PISA_MCTARGETDESC_PISABASEINFO_H
+#define LLVM_LIB_TARGET_PISA_MCTARGETDESC_PISABASEINFO_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace llvm {
+
+// Return a string representation of the operands from startIndex onwards.
+// Templated to allow both MachineInstr and MCInst to use the same logic.
+template <class InstType>
+std::string getPISAS...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/214107
More information about the llvm-branch-commits
mailing list