#include "AMDKernelCodeTUtils.h"
#include "AMDKernelCodeT.h"
#include "SIDefines.h"
#include "Utils/AMDGPUBaseInfo.h"
#include "Utils/SIDefinesUtils.h"
#include "llvm/ADT/IndexedMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCParser/MCAsmLexer.h"
#include "llvm/MC/MCParser/MCAsmParser.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "Utils/AMDKernelCodeTInfo.h"

Classes
class	PrintField

Macros
#define	GEN_HAS_MEMBER(member)

#define	RECORD(name, altName, print, parse) #name

#define	RECORD(name, altName, print, parse) #altName

#define	RECORD(name, altName, print, parse) (IsMCExpr##name::RESULT)

#define	RECORD(name, altName, print, parse) GetMember##name::Get

#define	COMPPGM1(name, aname, AccMacro) COMPPGM(name, aname, C_00B848_##AccMacro, S_00B848_##AccMacro, 0)

#define	COMPPGM2(name, aname, AccMacro) COMPPGM(name, aname, C_00B84C_##AccMacro, S_00B84C_##AccMacro, 32)

#define	PRINTFIELD(sname, aname, name) PrintField::printField<FLD_T(name)>

#define	PRINTCOMP(Complement, PGMType)

#define	RECORD(name, altName, print, parse) print

#define	COMPPGM1(name, aname, AccMacro) COMPPGM(name, aname, G_00B848_##AccMacro, C_00B848_##AccMacro, 0)

#define	COMPPGM2(name, aname, AccMacro) COMPPGM(name, aname, G_00B84C_##AccMacro, C_00B84C_##AccMacro, 32)

#define	PARSECOMP(Complement, PGMType)

#define	RECORD(name, altName, print, parse) parse

Typedefs
using	RetrieveFx = const MCExpr &()(AMDGPUMCKernelCodeT &)

using	PrintFx = void(*)(StringRef, const AMDGPUMCKernelCodeT &, raw_ostream &, MCContext &)

using	ParseFx = bool(*)(AMDGPUMCKernelCodeT &, MCAsmParser &, raw_ostream &)

Functions
static ArrayRef< StringLiteral >	get_amd_kernel_code_t_FldNames ()

static ArrayRef< StringLiteral >	get_amd_kernel_code_t_FldAltNames ()

static ArrayRef< bool >	hasMCExprVersionTable ()

static ArrayRef< RetrieveFx >	getMCExprIndexTable ()

static StringMap< int >	createIndexMap (ArrayRef< StringLiteral > names, ArrayRef< StringLiteral > altNames)

static int	get_amd_kernel_code_t_FieldIndex (StringRef name)

template<typename T , T AMDGPUMCKernelCodeT::* ptr, int shift, int width = 1>
static void	printBitField (StringRef Name, const AMDGPUMCKernelCodeT &C, raw_ostream &OS, MCContext &)

static ArrayRef< PrintFx >	getPrinterTable ()

static bool	expectAbsExpression (MCAsmParser &MCParser, int64_t &Value, raw_ostream &Err)

template<typename T , T AMDGPUMCKernelCodeT::* ptr>
static bool	parseField (AMDGPUMCKernelCodeT &C, MCAsmParser &MCParser, raw_ostream &Err)

template<typename T , T AMDGPUMCKernelCodeT::* ptr, int shift, int width = 1>
static bool	parseBitField (AMDGPUMCKernelCodeT &C, MCAsmParser &MCParser, raw_ostream &Err)

static bool	parseExpr (MCAsmParser &MCParser, const MCExpr *&Value, raw_ostream &Err)

static ArrayRef< ParseFx >	getParserTable ()

static void	printAmdKernelCodeField (const AMDGPUMCKernelCodeT &C, int FldIndex, raw_ostream &OS, MCContext &Ctx)

Macro Definition Documentation

◆ COMPPGM1 [1/2]

#define COMPPGM1	(	name,
		aname,
		AccMacro
	)	COMPPGM(name, aname, C_00B848_##AccMacro, S_00B848_##AccMacro, 0)

◆ COMPPGM1 [2/2]

#define COMPPGM1	(	name,
		aname,
		AccMacro
	)	COMPPGM(name, aname, G_00B848_##AccMacro, C_00B848_##AccMacro, 0)

◆ COMPPGM2 [1/2]

#define COMPPGM2	(	name,
		aname,
		AccMacro
	)	COMPPGM(name, aname, C_00B84C_##AccMacro, S_00B84C_##AccMacro, 32)

◆ COMPPGM2 [2/2]

#define COMPPGM2	(	name,
		aname,
		AccMacro
	)	COMPPGM(name, aname, G_00B84C_##AccMacro, C_00B84C_##AccMacro, 32)

◆ GEN_HAS_MEMBER

#define GEN_HAS_MEMBER ( member )

Definition at line 42 of file AMDKernelCodeTUtils.cpp.

◆ PARSECOMP

#define PARSECOMP	(	Complement,
		PGMType
	)

Value:

  [](AMDGPUMCKernelCodeT &C, MCAsmParser &MCParser,                            \
     raw_ostream &Err) -> bool {                                               \
    MCContext &Ctx = MCParser.getContext();                                    \
    const MCExpr *Value;                                                       \
    if (!parseExpr(MCParser, Value, Err))                                      \
      return false;                                                            \
    auto [Shift, Mask] = getShiftMask(Complement);                             \
    Value = maskShiftSet(Value, Mask, Shift, Ctx);                             \
    const MCExpr *Compl = MCConstantExpr::create(Complement, Ctx);             \
    if (PGMType == 0) {                                                        \
      C.compute_pgm_resource1_registers = MCBinaryExpr::createAnd(             \
          C.compute_pgm_resource1_registers, Compl, Ctx);                      \
      C.compute_pgm_resource1_registers = MCBinaryExpr::createOr(              \
          C.compute_pgm_resource1_registers, Value, Ctx);                      \
    } else {                                                                   \
      C.compute_pgm_resource2_registers = MCBinaryExpr::createAnd(             \
          C.compute_pgm_resource2_registers, Compl, Ctx);                      \
      C.compute_pgm_resource2_registers = MCBinaryExpr::createOr(              \
          C.compute_pgm_resource2_registers, Value, Ctx);                      \
    }                                                                          \
    return true;                                                               \
  }

◆ PRINTCOMP

#define PRINTCOMP	(	Complement,
		PGMType
	)

Value:

  [](StringRef Name, const AMDGPUMCKernelCodeT &C, raw_ostream &OS,            \
     MCContext &Ctx) {                                                         \
    OS << Name << " = ";                                                       \
    auto [Shift, Mask] = getShiftMask(Complement);                             \
    const MCExpr *Value;                                                       \
    if (PGMType == 0) {                                                        \
      Value =                                                                  \
          maskShiftGet(C.compute_pgm_resource1_registers, Mask, Shift, Ctx);   \
    } else {                                                                   \
      Value =                                                                  \
          maskShiftGet(C.compute_pgm_resource2_registers, Mask, Shift, Ctx);   \
    }                                                                          \
    int64_t Val;                                                               \
    if (Value->evaluateAsAbsolute(Val))                                        \
      OS << Val;                                                               \
    else                                                                       \
      Value->print(OS, Ctx.getAsmInfo());                                      \
  }