fix lit

Author: wangdi4

llvm/include/llvm/SYCLLowerIR/CompileTimePropertiesPass.h

@@ -40,7 +40,7 @@ class CompileTimePropertiesPass
       Module &M, IntrinsicInst *IntrInst,
       SmallVectorImpl<IntrinsicInst *> &RemovableAnnotations);
 
-  void parseAlignmentAndApply(Module &M, IntrinsicInst *IntrInst);
+  bool parseAlignmentAndApply(Module &M, IntrinsicInst *IntrInst);
 
   // Map for keeping track of global variables generated for annotation strings.
   // This allows reuse for annotations with the same generated annotation

llvm/lib/SYCLLowerIR/CompileTimePropertiesPass.cpp

@@ -683,7 +683,7 @@ PreservedAnalyses CompileTimePropertiesPass::run(Module &M,
                                   : PreservedAnalyses::all();
 }
 
-void CompileTimePropertiesPass::parseAlignmentAndApply(
+bool CompileTimePropertiesPass::parseAlignmentAndApply(
     Module &M, IntrinsicInst *IntrInst) {
   // Get the global variable with the annotation string.
   const GlobalVariable *AnnotStrArgGV = nullptr;
@@ -693,11 +693,11 @@ void CompileTimePropertiesPass::parseAlignmentAndApply(
   else if (auto *GEP = dyn_cast<GEPOperator>(IntrAnnotStringArg))
     AnnotStrArgGV = dyn_cast<GlobalVariable>(GEP->getOperand(0));
   if (!AnnotStrArgGV)
-    return;
+    return false;
 
   std::optional<StringRef> AnnotStr = getGlobalVariableString(AnnotStrArgGV);
   if (!AnnotStr)
-    return;
+    return false;
 
   // parse properties string to decoration-value pairs
   auto Properties = parseSYCLPropertiesString(M, IntrInst);
@@ -708,6 +708,7 @@ void CompileTimePropertiesPass::parseAlignmentAndApply(
   getUserListIgnoringCast<StoreInst>(IntrInst, TargetedInstList);
   getUserListIgnoringCast<MemTransferInst>(IntrInst, TargetedInstList);
 
+  bool AlignApplied = false;
   for (auto &Property : Properties) {
     auto DecorStr = Property.first->str();
     auto DecorValue = Property.second;
@@ -731,18 +732,26 @@ void CompileTimePropertiesPass::parseAlignmentAndApply(
         auto Op_num = Pair.second;
         if (auto *LInst = dyn_cast<LoadInst>(Inst)) {
           LInst->setAlignment(Align_val);
+          AlignApplied = true;
         } else if (auto *SInst = dyn_cast<StoreInst>(Inst)) {
-          if (Op_num == 1)
+          if (Op_num == 1) {
             SInst->setAlignment(Align_val);
+            AlignApplied = true;
+          }
         } else if (auto *MI = dyn_cast<MemTransferInst>(Inst)) {
-          if (Op_num == 0)
+          if (Op_num == 0) {
             MI->setDestAlignment(Align_val);
-          else if (Op_num == 1)
+            AlignApplied = true;
+          } else if (Op_num == 1) {
             MI->setSourceAlignment(Align_val);
+            AlignApplied = true;
+          }
         }
       }
     }
   }
+
+  return AlignApplied;
 }
 
 // Returns true if the transformation changed IntrInst.
@@ -771,7 +780,7 @@ bool CompileTimePropertiesPass::transformSYCLPropertiesAnnotation(
     return false;
 
   // check alignment annotation and apply it to load/store
-  parseAlignmentAndApply(M, IntrInst);
+  bool AlignApplied = parseAlignmentAndApply(M, IntrInst);
 
   // Read the annotation values and create new annotation strings.
   std::string NewAnnotString = "";
@@ -780,6 +789,11 @@ bool CompileTimePropertiesPass::transformSYCLPropertiesAnnotation(
   bool CacheProp = false;
   bool FPGAProp = false;
   for (const auto &[PropName, PropVal] : Properties) {
+    // if sycl-alignment is converted to align on IR constructs
+    // during parseAlignmentAndApply(), dropping here
+    if (PropName == "sycl-alignment" && AlignApplied)
+      continue;
+
     auto DecorIt = SpirvDecorMap.find(*PropName);
     if (DecorIt == SpirvDecorMap.end())
       continue;

sycl/include/sycl/ext/intel/experimental/fpga_annotated_properties.hpp

@@ -356,9 +356,6 @@ struct is_valid_property<T, stable_key::value_t> : std::true_type {};
 // buffer_location is applied on PtrAnnotation
 template <>
 struct propagateToPtrAnnotation<buffer_location_key> : std::true_type {};
-template <int K>
-struct propagateToPtrAnnotation<buffer_location_key::value_t<K>>
-    : std::true_type {};
 
 //===----------------------------------------------------------------------===//
 //   Utility for FPGA properties

sycl/include/sycl/ext/oneapi/experimental/common_annotated_properties/properties.hpp

@@ -58,6 +58,11 @@ struct check_property_list<T, Prop, Props...>
 
 template <typename PropTy> struct propagateToPtrAnnotation : std::false_type {};
 
+// Partial specilization for property_value
+template <typename PropKeyT, typename... PropValuesTs>
+struct propagateToPtrAnnotation<property_value<PropKeyT, PropValuesTs...>>
+    : propagateToPtrAnnotation<PropKeyT> {};
+
 //===----------------------------------------------------------------------===//
 //        Common properties of annotated_arg/annotated_ptr
 //===----------------------------------------------------------------------===//
@@ -83,8 +88,6 @@ struct is_property_key_of<alignment_key, annotated_arg<T, PropertyListT>>
     : std::true_type {};
 
 template <> struct propagateToPtrAnnotation<alignment_key> : std::true_type {};
-template <int K>
-struct propagateToPtrAnnotation<alignment_key::value_t<K>> : std::true_type {};
 
 namespace detail {
 

sycl/test/extensions/properties/properties_cache_control.cpp

@@ -9,14 +9,12 @@ using namespace ext::intel::experimental;
 
 using load_hint = annotated_ptr<
     float, decltype(properties(
-               alignment<8>,
                read_hint<cache_control<cache_mode::cached, cache_level::L1>,
                          cache_control<cache_mode::uncached, cache_level::L2,
                                        cache_level::L3>>))>;
 using load_assertion = annotated_ptr<
     int,
     decltype(properties(
-        alignment<8>,
         read_assertion<cache_control<cache_mode::constant, cache_level::L1>,
                        cache_control<cache_mode::invalidate, cache_level::L2,
                                      cache_level::L3>>))>;