Merge pull request #4 from AMD-Lightning-Internal/amd/dev/msearles/merge-amd-develop

merge amd-develop into amd-staging

Author: searlmc1

README.md

@@ -277,3 +277,18 @@ creating a pull request or raising an issue on GitHub.
 As mentioned earlier there are branches `llvm_release_*` that get backported
 changes. Those changes if exists are released automatically by github CI on
 monthly basis in a format `<llvm_major>.<llvm_minor>.<latest patch +1>`.
+
+## Deprecation of "preview extensions"
+
+In a case if a "preview extension" has to be deprecated, as the first step one
+should disable support for forward translation of the extension in the main branch
+(this will prevent new SPIR-V modules from being generated using the extension).
+Meanwhile support reverse translation for the extension should be continued
+(this retains compatibility with existing SPIR-V modules).
+  * Addition of deprecation warning for the extension is not required.
+  * We encourage backporting the changes to other branches to speed up removal, but this is not required.
+
+After at least one release cycle one may remove support for reverse translation in the main branch as well,
+at which point support for the "preview extension" is considered removed.
+
+These are guidelines, not requirements, and we will consider exceptions on a case-by-case basis.

include/LLVMSPIRVExtensions.inc

@@ -64,7 +64,7 @@ EXT(SPV_INTEL_global_variable_fpga_decorations)
 EXT(SPV_INTEL_complex_float_mul_div)
 EXT(SPV_INTEL_split_barrier)
 EXT(SPV_INTEL_masked_gather_scatter)
-EXT(SPV_INTEL_tensor_float32_rounding)
+EXT(SPV_INTEL_tensor_float32_conversion)
 EXT(SPV_EXT_relaxed_printf_string_address_space)
 EXT(SPV_INTEL_fpga_argument_interfaces)
 EXT(SPV_INTEL_fpga_latency_control)
@@ -76,3 +76,4 @@ EXT(SPV_INTEL_maximum_registers)
 EXT(SPV_INTEL_bindless_images)
 EXT(SPV_INTEL_2d_block_io)
 EXT(SPV_INTEL_subgroup_matrix_multiply_accumulate)
+EXT(SPV_KHR_bfloat16)

lib/SPIRV/LLVMToSPIRVDbgTran.cpp

@@ -1208,14 +1208,24 @@ LLVMToSPIRVDbgTran::transDbgGlobalVariable(const DIGlobalVariable *GV) {
     Ops.push_back(transDbgEntry(StaticMember)->getId());
 
   // Check if Ops[VariableIdx] has no information
-  if (isNonSemanticDebugInfo() && Ops[VariableIdx] == getDebugInfoNoneId()) {
+  if (isNonSemanticDebugInfo()) {
     // Check if GV has an associated GVE with a non-empty DIExpression.
     // The non-empty DIExpression gives the initial value of the GV.
     for (const DIGlobalVariableExpression *GVE : DIF.global_variables()) {
       if ( // GVE matches GV
           GVE->getVariable() == GV &&
           // DIExpression is non-empty
           GVE->getExpression()->getNumElements()) {
+        if (Ops[VariableIdx] != getDebugInfoNoneId()) {
+#ifdef SPIRV_HAS_DIOP_DIEXPRESSION
+          if (GVE->getExpression()->holdsNewElements()) {
+            Ops.resize(MaxOperandCount, getDebugInfoNoneId());
+            Ops[DIOpBasedExprIdx] =
+              transDbgExpression(GVE->getExpression())->getId();
+          }
+#endif
+          break;
+        }
         // Repurpose VariableIdx operand to hold the initial value held in the
         // GVE's DIExpression
         Ops[VariableIdx] = transDbgExpression(GVE->getExpression())->getId();
@@ -1608,21 +1618,96 @@ LLVMToSPIRVDbgTran::transDbgLocalVariable(const DILocalVariable *Var) {
 
 // DWARF Operations and expressions
 
+template <>
+void LLVMToSPIRVDbgTran::transDIOpOperand(SPIRVWordVec &Vec, unsigned Idx,
+                                          llvm::Type *Ty) {
+  Vec[Idx] = SPIRVWriter->transType(Ty)->getId();
+}
+
+template <>
+void LLVMToSPIRVDbgTran::transDIOpOperand(SPIRVWordVec &Vec, unsigned Idx,
+                                          uint32_t UInt) {
+  Vec[Idx] = UInt;
+  if (isNonSemanticDebugInfo())
+    transformToConstant(Vec, {Idx});
+}
+
+template <>
+void LLVMToSPIRVDbgTran::transDIOpOperand(SPIRVWordVec &Vec, unsigned Idx,
+                                          llvm::ConstantData *Data) {
+  Vec[Idx] = SPIRVWriter->transConstant(Data)->getId();
+}
+
 SPIRVEntry *LLVMToSPIRVDbgTran::transDbgExpression(const DIExpression *Expr) {
   SPIRVWordVec Operations;
+
+#ifdef SPIRV_HAS_DIOP_DIEXPRESSION
+  if (auto NewElems = Expr->getNewElementsRef()) {
+    if (!(BM->allowExtraDIExpressions() ||
+          BM->getDebugInfoEIS() == SPIRVEIS_NonSemantic_Shader_DebugInfo_200))
+      report_fatal_error(
+          llvm::Twine("unsupported DIOp-based opcode found in DIExpression"));
+
+    for (DIOp::Variant DIOp : *NewElems) {
+      using namespace SPIRVDebug::Operand::Operation;
+
+      unsigned BitcodeID = llvm::DIOp::getBitcodeID(DIOp);
+      SPIRVDebug::ExpressionOpCode OC =
+          SPIRV::DbgExpressionDIOpBasedOpCodeMap::map(BitcodeID);
+      if (OpCountMap.find(OC) == OpCountMap.end())
+        report_fatal_error(
+            llvm::Twine("unknown DIOp-based opcode found in DIExpression"));
+
+      unsigned OpCount = OpCountMap[OC];
+      SPIRVWordVec Op(OpCount);
+      Op[OpCodeIdx] = OC;
+      if (isNonSemanticDebugInfo())
+        transformToConstant(Op, {OpCodeIdx});
+
+#define HANDLE_OP1(Name, OpType, OpName)                                       \
+  case llvm::DIOp::Name::getBitcodeID():                                       \
+    assert(OpCount == 2);                                                      \
+    transDIOpOperand<OpType>(Op, 1,                                            \
+                             std::get<llvm::DIOp::Name>(DIOp).get##OpName());  \
+    break;
+#define HANDLE_OP2(Name, OpType1, OpName1, OpType2, OpName2)                   \
+  case llvm::DIOp::Name::getBitcodeID():                                       \
+    assert(OpCount == 3);                                                      \
+    transDIOpOperand<OpType1>(                                                 \
+        Op, 1, std::get<llvm::DIOp::Name>(DIOp).get##OpName1());               \
+    transDIOpOperand<OpType2>(                                                 \
+        Op, 2, std::get<llvm::DIOp::Name>(DIOp).get##OpName2());               \
+    break;
+
+      switch (BitcodeID) {
+#include "llvm/IR/DIExprOps.def"
+      default:
+        // This is the OP0 case.
+        assert(OpCount == 1);
+        break;
+      }
+
+      auto *Operation =
+          BM->addDebugInfo(SPIRVDebug::Operation, getVoidTy(), Op);
+      Operations.push_back(Operation->getId());
+    }
+
+    return BM->addDebugInfo(SPIRVDebug::Expression, getVoidTy(), Operations);
+  }
+#endif
+
   for (unsigned I = 0, N = Expr->getNumElements(); I < N; ++I) {
     using namespace SPIRVDebug::Operand::Operation;
     auto DWARFOpCode = static_cast<dwarf::LocationAtom>(Expr->getElement(I));
 
     SPIRVDebug::ExpressionOpCode OC =
         SPIRV::DbgExpressionOpCodeMap::map(DWARFOpCode);
     if (OpCountMap.find(OC) == OpCountMap.end())
-      report_fatal_error(llvm::Twine("unknown opcode found in DIExpression"));
+      report_fatal_error("unknown opcode found in DIExpression");
     if (OC > SPIRVDebug::Fragment &&
         !(BM->allowExtraDIExpressions() ||
           BM->getDebugInfoEIS() == SPIRVEIS_NonSemantic_Shader_DebugInfo_200))
-      report_fatal_error(
-          llvm::Twine("unsupported opcode found in DIExpression"));
+      report_fatal_error("unsupported opcode found in DIExpression");
 
     unsigned OpCount = OpCountMap[OC];
     SPIRVWordVec Op(OpCount);

lib/SPIRV/LLVMToSPIRVDbgTran.h

@@ -159,6 +159,9 @@ class LLVMToSPIRVDbgTran {
   // DWARF expressions
   SPIRVEntry *transDbgExpression(const DIExpression *Expr);
 
+  template <class OperandTy>
+  void transDIOpOperand(SPIRVWordVec &Vec, unsigned Idx, OperandTy Operand);
+
   // Imported declarations and modules
   SPIRVEntry *transDbgImportedEntry(const DIImportedEntity *IE);
 

lib/SPIRV/Mangler/ManglingUtils.cpp

@@ -28,6 +28,7 @@ static const char *PrimitiveNames[PRIMITIVE_NUM] = {
     "half",
     "float",
     "double",
+    "__bf16",
     "void",
     "...",
     "image1d_ro_t",
@@ -105,6 +106,7 @@ const char *MangledTypes[PRIMITIVE_NUM] = {
     "Dh",                                // HALF
     "f",                                 // FLOAT
     "d",                                 // DOUBLE
+    "u6__bf16",                          // __BF16
     "v",                                 // VOID
     "z",                                 // VarArg
     "14ocl_image1d_ro",                  // PRIMITIVE_IMAGE1D_RO_T
@@ -197,6 +199,7 @@ static const SPIRversion PrimitiveSupportedVersions[PRIMITIVE_NUM] = {
     SPIR12, // HALF
     SPIR12, // FLOAT
     SPIR12, // DOUBLE
+    SPIR12, // __BF16
     SPIR12, // VOID
     SPIR12, // VarArg
     SPIR12, // PRIMITIVE_IMAGE1D_RO_T

lib/SPIRV/Mangler/ParameterType.h

@@ -45,6 +45,7 @@ enum TypePrimitiveEnum {
   PRIMITIVE_HALF,
   PRIMITIVE_FLOAT,
   PRIMITIVE_DOUBLE,
+  PRIMITIVE_BFLOAT,
   PRIMITIVE_VOID,
   PRIMITIVE_VAR_ARG,
   PRIMITIVE_STRUCT_FIRST,

lib/SPIRV/SPIRVReader.cpp

@@ -315,6 +315,8 @@ std::optional<uint64_t> SPIRVToLLVM::getAlignment(SPIRVValue *V) {
 Type *SPIRVToLLVM::transFPType(SPIRVType *T) {
   switch (T->getFloatBitWidth()) {
   case 16:
+    if (T->isTypeFloat(16, FPEncodingBFloat16KHR))
+      return Type::getBFloatTy(*Context);
     return Type::getHalfTy(*Context);
   case 32:
     return Type::getFloatTy(*Context);
@@ -480,15 +482,20 @@ Type *SPIRVToLLVM::transType(SPIRVType *T, bool UseTPT) {
   }
   case OpTypeBufferSurfaceINTEL: {
     auto *PST = static_cast<SPIRVTypeBufferSurfaceINTEL *>(T);
-    Type *StructTy = getOrCreateOpaqueStructType(M, transVCTypeName(PST));
-    Type *PointerTy;
-    if (UseTPT)
-      PointerTy = TypedPointerType::get(StructTy, SPIRAS_Global);
-    else
-      PointerTy = PointerType::get(StructTy, SPIRAS_Global);
-    return mapType(T, PointerTy);
+    Type *Ty = nullptr;
+    if (UseTPT) {
+      Type *StructTy = getOrCreateOpaqueStructType(M, transVCTypeName(PST));
+      Ty = TypedPointerType::get(StructTy, SPIRAS_Global);
+    } else {
+      std::vector<unsigned> Params;
+      if (PST->hasAccessQualifier()) {
+        unsigned Access = static_cast<unsigned>(PST->getAccessQualifier());
+        Params.push_back(Access);
+      }
+      Ty = TargetExtType::get(*Context, "spirv.BufferSurfaceINTEL", {}, Params);
+    }
+    return mapType(T, Ty);
   }
-
   case internal::OpTypeJointMatrixINTEL: {
     auto *MT = static_cast<SPIRVTypeJointMatrixINTEL *>(T);
     auto R = static_cast<SPIRVConstant *>(MT->getRows())->getZExtIntValue();
@@ -1501,7 +1508,9 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
       const llvm::fltSemantics *FS = nullptr;
       switch (BT->getFloatBitWidth()) {
       case 16:
-        FS = &APFloat::IEEEhalf();
+        FS =
+            (BT->isTypeFloat(16, FPEncodingBFloat16KHR) ? &APFloat::BFloat()
+                                                        : &APFloat::IEEEhalf());
         break;
       case 32:
         FS = &APFloat::IEEEsingle();
@@ -3524,7 +3533,7 @@ Function *SPIRVToLLVM::transFunction(SPIRVFunction *BF, unsigned AS) {
 
   // TODO: this is temporarily disabled as it breaks some more complex code
   //       patterns that are otherwise correctly(-ish) handled
-  if (M->getTargetTriple().getVendor() == Triple::VendorType::AMD)
+  if (M->getTargetTriple().getVendor() != Triple::VendorType::AMD)
     validatePhiPredecessors(F);
   transLLVMLoopMetadata(F);