Add more attributes to highlevel dialect

include/vast/CodeGen/DefaultAttrVisitor.hpp

@@ -25,6 +25,7 @@ namespace vast::cg {
         mlir_attr VisitSectionAttr(const clang::SectionAttr *attr);
         mlir_attr VisitFormatAttr(const clang::FormatAttr *attr);
         mlir_attr VisitAnnotateAttr(const clang::AnnotateAttr *attr);
+        mlir_attr VisitAlignedAttr(const clang::AlignedAttr *attr);
         mlir_attr VisitAlwaysInlineAttr(const clang::AlwaysInlineAttr *attr);
         mlir_attr VisitLoaderUninitializedAttr(const clang::LoaderUninitializedAttr *attr);
         mlir_attr VisitNoInstrumentFunctionAttr(const clang::NoInstrumentFunctionAttr *attr);
@@ -39,6 +40,11 @@ namespace vast::cg {
         mlir_attr VisitAsmLabelAttr(const clang::AsmLabelAttr *attr);
         mlir_attr VisitAllocAlignAttr(const clang::AllocAlignAttr *attr);
         mlir_attr VisitAllocSizeAttr(const clang::AllocSizeAttr *attr);
+        mlir_attr VisitLeafAttr(const clang::LeafAttr *attr);
+        mlir_attr VisitColdAttr(const clang::ColdAttr *attr);
+        mlir_attr VisitDeprecatedAttr(const clang::DeprecatedAttr *attr);
+        mlir_attr VisitTransparentUnionAttr(const clang::TransparentUnionAttr *attr);
+        mlir_attr VisitReturnsTwiceAttr(const clang::ReturnsTwiceAttr *attr);
 
       private:
         template< typename attr_t, typename... args_t >
@@ -47,4 +53,4 @@ namespace vast::cg {
         }
     };
 
-} // namespace vast::cg
+} // namespace vast::cg

include/vast/CodeGen/DefaultStmtVisitor.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #pragma once
 
@@ -251,6 +251,13 @@
         //
         // Literals
         //
+
+        // Helper for use with literal expressions that might return lvalue.
+        // It takes an expression, checks if it's lvalue expression
+        // and depending on the result calls either the lvalue type visitor or
+        // the standard type visitor.
+        mlir_type visit_maybe_lvalue_literal_type (const clang::Expr *expr);
+
         operation VisitCharacterLiteral(const clang::CharacterLiteral *lit);
         operation VisitIntegerLiteral(const clang::IntegerLiteral *lit);
         operation VisitFloatingLiteral(const clang::FloatingLiteral *lit);
@@ -261,6 +268,7 @@
         operation VisitImaginaryLiteral(const clang::ImaginaryLiteral *lit);
 
         operation VisitInitListExpr(const clang::InitListExpr *expr);
+        operation VisitImplicitValueInitExpr(const clang::ImplicitValueInitExpr *expr);
     };
 
     template< typename Op >

include/vast/Dialect/HighLevel/HighLevelAttributes.td

@@ -18,6 +18,7 @@ class NameAttr<string name, string attr_mnemonic>
   : HighLevel_Attr< name, attr_mnemonic >
 {
   let parameters = (ins "::mlir::StringAttr":$name);
+
   let builders = [
     AttrBuilderWithInferredContext<(ins "::mlir::StringAttr":$name), [{
       return get(name.getContext(), name);
@@ -33,6 +34,8 @@ class NameAttr<string name, string attr_mnemonic>
 def AnnotationAttr    : NameAttr< "Annotation", "annotation" >;
 def FormatAttr        : NameAttr< "Format", "format" >;
 def SectionAttr       : NameAttr< "Section", "section" >;
+// TODO(#595): Make aligned attribute keep the alignment value/expr
+def AlignedAttr       : HighLevel_Attr< "Aligned", "aligned" >;
 def AlwaysInlineAttr  : HighLevel_Attr< "AlwaysInline", "always_inline" >;
 def ConstAttr         : HighLevel_Attr< "Const", "const" >;
 def LoaderUninitAttr  : HighLevel_Attr< "LoaderUninitialized", "loader_uninitialized" >;
@@ -43,9 +46,14 @@ def WarnUnusedResAttr : HighLevel_Attr< "WarnUnusedResult", "warn_unused_result"
 def RestrictAttr : HighLevel_Attr< "Restrict", "restrict" >;
 def NoThrowAttr  : HighLevel_Attr< "NoThrow", "nothrow" >;
 def NonNullAttr  : HighLevel_Attr< "NonNull", "nonnull" >;
+def LeafAttr     : HighLevel_Attr< "Leaf", "leaf" >;
+def ColdAttr     : HighLevel_Attr< "Cold", "cold" >;
+def TransparentUnionAttr : HighLevel_Attr< "TransparentUnion", "transparent_union" >;
+def ReturnsTwiceAttr      : HighLevel_Attr< "ReturnsTwice", "returns_twice" >;
 
 def AsmLabelAttr : HighLevel_Attr< "AsmLabel", "asm" > {
   let parameters = (ins "::mlir::StringAttr":$label, "bool":$isLiteral);
+
   let builders = [
     AttrBuilderWithInferredContext<(ins "::mlir::StringAttr":$label, "bool":$literal), [{
       return get(label.getContext(), label, literal);
@@ -60,6 +68,7 @@ def AsmLabelAttr : HighLevel_Attr< "AsmLabel", "asm" > {
 
 def ModeAttr : HighLevel_Attr< "Mode", "mode" > {
   let parameters = (ins "::mlir::StringAttr":$mode);
+
   let builders = [
     AttrBuilderWithInferredContext<(ins "::mlir::StringAttr":$mode), [{
       return get(mode.getContext(), mode);
@@ -74,19 +83,35 @@ def ModeAttr : HighLevel_Attr< "Mode", "mode" > {
 
 def BuiltinAttr : HighLevel_Attr< "Builtin", "builtin" > {
   let parameters = (ins "unsigned":$ID);
+
   let assemblyFormat = "`<` $ID `>`";
 }
 
-def AllocAlignAttr : HighLevel_Attr< "AllocAlign", "alloc_align" >{
+def AllocAlignAttr : HighLevel_Attr< "AllocAlign", "alloc_align" > {
   let parameters = (ins "int":$alignment);
 
   let assemblyFormat = "`<` $alignment `>`";
 }
 
-def AllocSizeAttr : HighLevel_Attr< "AllocSize", "alloc_size" >{
+def AllocSizeAttr : HighLevel_Attr< "AllocSize", "alloc_size" > {
   let parameters = (ins "int":$size_arg_pos, OptionalParameter< "int" >:$num_arg_pos);
 
   let assemblyFormat = "`<` `size_pos` `:` $size_arg_pos (`,` `num_pos` `:` $num_arg_pos^)? `>`";
 }
 
+def DeprecatedAttr : HighLevel_Attr< "Deprecated", "deprecated" > {
+  let parameters = (ins
+    "::mlir::StringAttr":$message,
+    "::mlir::StringAttr":$fixit
+  );
+
+  let builders = [
+    AttrBuilder<(ins "::mlir::StringRef":$msg, "::mlir::StringRef":$fix), [{
+      return get($_ctxt, mlir::StringAttr::get($_ctxt, msg), mlir::StringAttr::get($_ctxt, fix));
+    }]>,
+  ];
+
+  let assemblyFormat = "`<` `msg` `:` $message `,` `fix` `:` $fixit `>`";
+}
+
 #endif // VAST_DIALECT_HIGHLEVEL_IR_HIGHLEVELATTRIBUTES

include/vast/Dialect/HighLevel/HighLevelOps.td

@@ -468,16 +468,23 @@ def ConstantOp
 def InitializedConstantOp : HighLevel_Op< "const.init", [ConstantLike, Pure] >
   , Results< (outs AnyType:$result) >
 {
-  let summary = "VAST value constant";
-  let description = [{ VAST value constant witch requires region initialization }];
+  let summary = "VAST constant with non-trivial initialization";
+  let description = [{
+    InitializedConstantOp is used to represent a constant with non-trivial
+    initialization. The initialization is represented by a region that
+    represents initialization expression.
+  }];
+
   let regions = (region ValueRegion:$init);
+
   let skipDefaultBuilders = 1;
   let builders = [
       OpBuilder<(ins
           "Type":$type,
           "builder_callback":$initbuilder
       )>
   ];
+
   let assemblyFormat = [{ attr-dict `:` type($result) `=` $init }];
 }
 
@@ -487,6 +494,30 @@ def UnreachableOp : HighLevel_Op<"unreachable", [Terminator]> {
   let assemblyFormat = "attr-dict";
 }
 
+def CompoundLiteralOp : HighLevel_Op< "compound_literal" >
+  , Results< (outs AnyType:$result) >
+{
+  let summary = "VAST compound literals operation";
+  let description = [{
+    Creates a compound literal that represents an unnamed object and is
+    initialzied by initializer-list.
+
+    Is used to represetnt `clang::CompoundLiteralExpr`.
+  }];
+
+  let regions = (region ValueRegion:$init);
+
+  let skipDefaultBuilders = 1;
+  let builders = [
+      OpBuilder<(ins
+          "Type":$type,
+          "builder_callback":$initbuilder
+      )>
+  ];
+
+  let assemblyFormat = [{ attr-dict `:` type($result) `=` $init }];
+}
+
 class CastKindAttr< string name, int val > : I64EnumAttrCase< name, val > {}
 
 class CastKindList< string name, string summary, list< CastKindAttr > cases >
@@ -745,12 +776,12 @@ class StandardArithBinOp< string mnemonic, list< Trait > traits = [] >
 class FloatArithBinOp< string mnemonic, list< Trait > traits = [] >
     : ArithBinOp< mnemonic, traits >
 {
-      let hasVerifier = 1;
-      let extraClassDefinition = [{
+    let hasVerifier = 1;
+    let extraClassDefinition = [{
         logical_result $cppClass::verify() {
-          return verify_float_arith_op(this->getOperation());
+            return verify_float_arith_op(this->getOperation());
         }
-      }];
+    }];
 }
 
 def AddIOp : ArithBinOp< "add", [Commutative, IsAdditive< "lhs", "rhs", "result" >] >;
@@ -1030,6 +1061,7 @@ def FCmpOp
 {
   let summary = "VAST flaoting point comparison operation";
   let description = [{ VAST floating point comparison operation }];
+
   let hasVerifier = 1;
 
   let assemblyFormat = "$predicate $lhs `,` $rhs  attr-dict `:` type(operands) `->` type($result)";
@@ -1270,8 +1302,8 @@ def IdentKind : IdentKindList< "IdentKind", "ident kind", [
 
 def PredefinedExpr
   : HighLevel_Op< "predefined.expr" >
-    , Arguments<(ins AnyType:$value, IdentKind:$kind)>
-    , Results<(outs AnyType:$result)>
+  , Arguments<(ins AnyType:$value, IdentKind:$kind)>
+  , Results<(outs AnyType:$result)>
 {
     let summary = "VAT predefined expr ( such as __func__ )";
     let description = [{ VAT predefined expr ( such as __func__ ) }];
@@ -1281,8 +1313,8 @@ def PredefinedExpr
 
 def ExtensionOp
   : HighLevel_Op< "gnu.extension" >
-    , Arguments<(ins AnyType:$value)>
-    , Results<(outs AnyType:$result)>
+  , Arguments<(ins AnyType:$value)>
+  , Results<(outs AnyType:$result)>
 {
     let summary = "VAST extension (__extension__) keyword";
     let description = [{ VAST op corresponding to GNU __extension__ keyword. }];
@@ -1314,11 +1346,12 @@ def AsmOp
     )>
 {
   let summary = "VAST operation for inline assembly";
-  let description = [{ VAST operation mirroring the GCCAsmStmt in clang AST. It prints
-                       a name for every operand (either its id or user-supplied string).}];
+  let description = [{
+    VAST operation mirroring the GCCAsmStmt in clang AST. It prints a name for
+    every operand (either its id or user-supplied string).
+  }];
 
   let skipDefaultBuilders = 1;
-
   let builders = [
   OpBuilder< (ins
       "mlir::StringAttr":$asm_template,
@@ -1335,7 +1368,9 @@ def AsmOp
     ) >
   ];
 
-  let assemblyFormat = [{attr-dict $asm_template `(`($output_names $asm_outputs^ `:` $output_constraints)? `)` `(` (`ins` `:`$input_names $asm_inputs^ `:` $input_constraints)? `)` `(`( $clobbers^)?`)` `(`( $labels^)?`)` `:` functional-type(operands, results)}];
+  let assemblyFormat = [{
+    attr-dict $asm_template `(`($output_names $asm_outputs^ `:` $output_constraints)? `)` `(` (`ins` `:`$input_names $asm_inputs^ `:` $input_constraints)? `)` `(`( $clobbers^)?`)` `(`( $labels^)?`)` `:` functional-type(operands, results)
+  }];
 }
 
 def VAArgExpr

lib/vast/CodeGen/DefaultAttrVisitor.cpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2024, Trail of Bits, Inc.
 
 #include "vast/CodeGen/DefaultAttrVisitor.hpp"
 
@@ -22,6 +22,11 @@
         return make< hl::AnnotationAttr >(attr->getAnnotation());
     }
 
+    mlir_attr default_attr_visitor::VisitAlignedAttr(const clang::AlignedAttr *attr) {
+        // TODO(#595): Keep the alignment in the attribute
+        return make< hl::AlignedAttr >();
+    }
+
     mlir_attr default_attr_visitor::VisitAlwaysInlineAttr(const clang::AlwaysInlineAttr *) {
         return make< hl::AlwaysInlineAttr >();
     }
@@ -78,4 +83,24 @@
         auto num = attr->getNumElemsParam().isValid() ? attr->getNumElemsParam().getSourceIndex() : int();
         return make< hl::AllocSizeAttr >(attr->getElemSizeParam().getSourceIndex(), num);
     }
+
+    mlir_attr default_attr_visitor::VisitLeafAttr(const clang::LeafAttr *attr) {
+        return make< hl::LeafAttr >();
+    }
+
+    mlir_attr default_attr_visitor::VisitColdAttr(const clang::ColdAttr *attr) {
+        return make< hl::ColdAttr >();
+    }
+
+    mlir_attr default_attr_visitor::VisitDeprecatedAttr(const clang::DeprecatedAttr *attr) {
+        return make< hl::DeprecatedAttr >(attr->getMessage(), attr->getReplacement());
+    }
+
+    mlir_attr default_attr_visitor::VisitTransparentUnionAttr(const clang::TransparentUnionAttr *attr) {
+        return make< hl::TransparentUnionAttr >();
+    }
+
+    mlir_attr default_attr_visitor::VisitReturnsTwiceAttr(const clang::ReturnsTwiceAttr *attr) {
+        return make< hl::ReturnsTwiceAttr >();
+    }
 } // namespace vast::hcg

lib/vast/CodeGen/DefaultStmtVisitor.cpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #include "vast/CodeGen/DefaultStmtVisitor.hpp"
 
@@ -562,6 +562,12 @@
     //
     // Literals
     //
+    mlir_type default_stmt_visitor::visit_maybe_lvalue_literal_type (const clang::Expr *lit){
+        if (lit->isLValue())
+            return self.visit_as_lvalue_type(lit->getType());
+        return self.visit(lit->getType());
+    }
+
     operation default_stmt_visitor::VisitCharacterLiteral(const clang::CharacterLiteral *lit) {
         return bld.constant(self.location(lit), self.visit(lit->getType()), apsint(lit->getValue())).getDefiningOp();
     }
@@ -575,23 +581,21 @@
     }
 
     operation default_stmt_visitor::VisitStringLiteral(const clang::StringLiteral *lit) {
-        auto type = [&] {
-            if (lit->isLValue()) {
-                return self.visit_as_lvalue_type(lit->getType());
-            } else {
-                return self.visit(lit->getType());
-            }
-        }();
-
-        return bld.constant(self.location(lit), type, lit->getString()).getDefiningOp();
+        return bld.constant(self.location(lit),
+                            visit_maybe_lvalue_literal_type(lit),
+                            lit->getString()).getDefiningOp();
     }
 
     operation default_stmt_visitor::VisitUserDefinedLiteral(const clang::UserDefinedLiteral */* lit */) {
         return {};
     }
 
-    operation default_stmt_visitor::VisitCompoundLiteralExpr(const clang::CompoundLiteralExpr */* lit */) {
-        return {};
+    operation default_stmt_visitor::VisitCompoundLiteralExpr(const clang::CompoundLiteralExpr *lit) {
+        return bld.compose< hl::CompoundLiteralOp >()
+            .bind(self.location(lit))
+            .bind(visit_maybe_lvalue_literal_type(lit))
+            .bind(mk_value_builder(lit->getInitializer()))
+            .freeze();
     }
 
     operation default_stmt_visitor::VisitFixedPointLiteral(const clang::FixedPointLiteral */* lit */) {
@@ -1009,4 +1013,12 @@
             .freeze();
     }
 
+    operation default_stmt_visitor::VisitImplicitValueInitExpr(const clang::ImplicitValueInitExpr *expr) {
+        return bld.compose< hl::InitListExpr >()
+            .bind(self.location(expr))
+            .bind(self.visit(expr->getType()))
+            .bind(visit_values_range(expr->children()))
+            .freeze();
+    }
+
 } // namespace vast::cg

lib/vast/Dialect/HighLevel/HighLevelOps.cpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2021-present, Trail of Bits, Inc.
 
 #include "vast/Util/Warnings.hpp"
 
@@ -667,6 +667,16 @@
         st.addTypes(type);
     }
 
+    void CompoundLiteralOp::build(Builder &bld, State &st, Type type, builder_callback init)
+    {
+        VAST_ASSERT(init && "the builder callback for 'init' region must be present");
+
+        InsertionGuard guard(bld);
+
+        build_region(bld, st, builder_callback_ref(init));
+        st.addTypes(type);
+    }
+
     GRAPH_REGION_OP(FuncOp);
     GRAPH_REGION_OP(StmtExprOp);
 

test/vast/Dialect/HighLevel/attr-e.c

@@ -0,0 +1,12 @@
+// RUN: %vast-front -vast-emit-mlir=hl -o - %s | %file-check %s
+// RUN: %vast-front -vast-emit-mlir=hl -o - %s > %t && %vast-opt %t | diff -B %t -
+
+// CHECK: hl.func @fun external () -> !hl.void attributes {deprecated = #hl.deprecated<msg : "msg", fix : "fix">} {
+__attribute__((deprecated("msg","fix")))
+void fun (void) {};
+// CHECK: hl.func @fun1 external () -> !hl.void attributes {deprecated = #hl.deprecated<msg : "msg", fix : "">} {
+__attribute__((deprecated("msg")))
+void fun1 (void) {};
+// CHECK: hl.func @fun2 external () -> !hl.void attributes {deprecated = #hl.deprecated<msg : "", fix : "">} {
+__attribute__((deprecated()))
+void fun2 (void) {};