[SYCL-MLIR]: FunctionType and Attributes Infrastructure (#7126)

In order to abide by the ABI calling conventions clang uses an
exhaustive infrastructure. In cgeist we take a number of shortcuts. This
is problematic because:
- the cgeist implementation to add attributes to function types,
parameters, call arguments is incomplete
- the current way cgeist computes function attributes does not take into
account the ABI constraints
  
This PR enhances the way cgeist attaches function attributes to a
function definition.

Signed-off-by: Tiotto, Ettore <[email protected]>

Author: etiotto

polygeist/tools/cgeist/Lib/Attributes.cc

@@ -40,13 +40,29 @@ static void addToPassThroughAttr(NamedAttribute &PassThroughAttr,
   std::vector<mlir::Attribute> Vec =
       PassThroughAttr.getValue().cast<ArrayAttr>().getValue().vec();
 
-  // TODO: find a way to add the attributes only if one does not exist already,
-  // and keep the list in sorted order.
+  // TODO: find a way to add the attributes only if one does not exist already.
   if (Attr.getValue().isa<UnitAttr>())
     Vec.push_back(Attr.getName());
   else
     Vec.push_back(ArrayAttr::get(&Ctx, {Attr.getName(), Attr.getValue()}));
 
+  auto Comp = [&](const mlir::Attribute &A1, const mlir::Attribute &A2) {
+    assert(A1.isa<StringAttr>() || A1.isa<ArrayAttr>());
+    assert(A2.isa<StringAttr>() || A2.isa<ArrayAttr>());
+
+    if (auto StrA1 = A1.dyn_cast<StringAttr>()) {
+      if (auto StrA2 = A2.dyn_cast<StringAttr>())
+        return StrA1 < StrA2;
+      return true;
+    }
+
+    auto ArrA1 = A1.cast<ArrayAttr>();
+    if (auto ArrA2 = A2.dyn_cast<ArrayAttr>())
+      return ArrA1[0].cast<StringAttr>() < ArrA2[0].cast<StringAttr>();
+    return false;
+  };
+
+  llvm::sort(Vec.begin(), Vec.end(), Comp);
   PassThroughAttr.setValue(ArrayAttr::get(&Ctx, Vec));
 
   LLVM_DEBUG({
@@ -81,26 +97,36 @@ static void addToPassThroughAttr(mlir::NamedAttribute &PassThroughAttr,
 // AttributeList Method Implementations
 //===----------------------------------------------------------------------===//
 
+AttributeList::AttributeList(const mlir::NamedAttrList &FnAttrs,
+                             const mlir::NamedAttrList &RetAttrs,
+                             llvm::ArrayRef<mlir::NamedAttrList> ParamAttrs)
+    : FnAttrs(FnAttrs), RetAttrs(RetAttrs), ParamAttrs(ParamAttrs) {}
+
 AttributeList &
 AttributeList::addAttrs(const AttrBuilder &FnAttrB, const AttrBuilder &RetAttrB,
                         llvm::ArrayRef<mlir::NamedAttrList> Attrs) {
   return addFnAttrs(FnAttrB).addRetAttrs(RetAttrB).addParamAttrs(Attrs);
 }
 
 AttributeList &AttributeList::addFnAttrs(const AttrBuilder &B) {
-  for (const NamedAttribute &NewNamedAttr : B.getAttrs()) {
-    Optional<NamedAttribute> ExistingAttr =
-        FnAttrs.getNamed(NewNamedAttr.getName());
-    if (!ExistingAttr) {
-      FnAttrs.append(NewNamedAttr);
+  return addFnAttrs(B.getAttrs(), B.getContext());
+}
+
+AttributeList &AttributeList::addFnAttrs(const NamedAttrList &Attrs,
+                                         MLIRContext &Ctx) {
+  for (const NamedAttribute &NewFnAttr : Attrs) {
+    Optional<NamedAttribute> ExistingFnAttr =
+        FnAttrs.getNamed(NewFnAttr.getName());
+    if (!ExistingFnAttr) {
+      FnAttrs.append(NewFnAttr);
       continue;
     }
 
     // Merge the 'passthrough' attribute lists.
-    if (ExistingAttr->getName() == PassThroughAttrName) {
-      auto Attrs = NewNamedAttr.getValue().cast<ArrayAttr>();
-      addToPassThroughAttr(*ExistingAttr, Attrs, B.getContext());
-      FnAttrs.set(ExistingAttr->getName(), ExistingAttr->getValue());
+    if (ExistingFnAttr->getName() == PassThroughAttrName) {
+      auto Attrs = NewFnAttr.getValue().cast<ArrayAttr>();
+      addToPassThroughAttr(*ExistingFnAttr, Attrs, Ctx);
+      FnAttrs.set(ExistingFnAttr->getName(), ExistingFnAttr->getValue());
       continue;
     }
 
@@ -111,7 +137,12 @@ AttributeList &AttributeList::addFnAttrs(const AttrBuilder &B) {
 }
 
 AttributeList &AttributeList::addRetAttrs(const AttrBuilder &B) {
-  for (const NamedAttribute &NewNamedAttr : B.getAttrs()) {
+  return addRetAttrs(B.getAttrs(), B.getContext());
+}
+
+AttributeList &AttributeList::addRetAttrs(const mlir::NamedAttrList &Attrs,
+                                          mlir::MLIRContext &Ctx) {
+  for (const NamedAttribute &NewNamedAttr : Attrs) {
     Optional<NamedAttribute> ExistingAttr =
         RetAttrs.getNamed(NewNamedAttr.getName());
     if (!ExistingAttr) {

polygeist/tools/cgeist/Lib/Attributes.h

@@ -24,6 +24,9 @@ class AttrBuilder;
 class AttributeList {
 public:
   AttributeList() = default;
+  AttributeList(const mlir::NamedAttrList &FnAttrs,
+                const mlir::NamedAttrList &RetAttrs,
+                llvm::ArrayRef<mlir::NamedAttrList> ParamAttrs);
 
   //===--------------------------------------------------------------------===//
   // AttributeList Mutation
@@ -36,9 +39,13 @@ class AttributeList {
 
   /// Add function attributes to the list.
   AttributeList &addFnAttrs(const AttrBuilder &B);
+  AttributeList &addFnAttrs(const mlir::NamedAttrList &Attrs,
+                            mlir::MLIRContext &Ctx);
 
   /// Add return value attributes to the list.
   AttributeList &addRetAttrs(const AttrBuilder &B);
+  AttributeList &addRetAttrs(const mlir::NamedAttrList &Attrs,
+                             mlir::MLIRContext &Ctx);
 
   /// Add parameters attributes to the list.
   AttributeList &addParamAttrs(llvm::ArrayRef<mlir::NamedAttrList> Attrs);