Add support for cells with non-local storage

include/vast/Conversion/Passes.hpp

@@ -62,6 +62,8 @@ namespace vast
     // ToMem
     std::unique_ptr< mlir::Pass > createRefsToSSAPass();
 
+    std::unique_ptr< mlir::Pass > createEvictStaticLocalsPass();
+
     std::unique_ptr< mlir::Pass > createStripParamLValuesPass();
 
     std::unique_ptr< mlir::Pass > createVarsToCellsPass();

include/vast/Conversion/Passes.td

@@ -84,6 +84,16 @@ def StripParamLValues : Pass<"vast-strip-param-lvalues", "core::ModuleOp"> {
   ];
 }
 
+def EvictStaticLocals : Pass<"vast-evict-static-locals", "core::ModuleOp"> {
+  let summary = "Evict hl.var declarations with static storage to global scope.";
+
+  let constructor = "vast::createEvictStaticLocalsPass()";
+  let dependentDialects = [
+    "vast::hl::HighLevelDialect",
+    "vast::core::CoreDialect"
+  ];
+}
+
 def VarsToCells : Pass<"vast-vars-to-cells", "core::ModuleOp"> {
   let summary = "Lower `hl.var` into ssa-based `ll.cell`.";
 

include/vast/Dialect/Core/CoreAttributes.hpp

@@ -1,4 +1,4 @@
 // Copyright (c) 2022-present, Trail of Bits, Inc.
 
 #pragma once
 
@@ -28,4 +28,12 @@
 
     mlir::CallInterfaceCallable get_callable_for_callee(operation op);
 
+    ParseResult parseStorageClasses(
+        Parser &parser, Attribute &storage_class, Attribute &thread_storage_class
+    );
+
+    void printStorageClasses(
+        Printer &printer, mlir::Operation *op, core::StorageClassAttr storage_class, core::TSClassAttr thread_storage_class
+    );
+
 } // namespace vast::core

include/vast/Dialect/Core/CoreAttributes.td

@@ -143,4 +143,110 @@ def Core_SourceLanguageAttr : EnumAttr< Core_Dialect, Core_SourceLanguage, "lang
 
 include "vast/Dialect/Core/Linkage.td"
 
+//
+// Storage and context attributes
+//
+
+class Core_StorageClassAttr< string name, int val >
+  : I64EnumAttrCase< name, val >
+{}
+
+class Core_StorageClassList< string name, string summary, list<Core_StorageClassAttr> cases >
+  : I64EnumAttr< name, summary, cases >
+{}
+
+def Core_SC_None          : Core_StorageClassAttr< "sc_none", 0 >;
+def Core_SC_Auto          : Core_StorageClassAttr< "sc_auto", 1 >;
+def Core_SC_Static        : Core_StorageClassAttr< "sc_static", 2 >;
+def Core_SC_Extern        : Core_StorageClassAttr< "sc_extern", 3 >;
+def Core_SC_PrivateExtern : Core_StorageClassAttr< "sc_private_extern", 4 >;
+def Core_SC_Register      : Core_StorageClassAttr< "sc_register", 5 >;
+
+let cppNamespace = "::vast::core" in
+def Core_StorageClass : Core_StorageClassList< "StorageClass", "storage class", [
+  Core_SC_None,
+  Core_SC_Auto,
+  Core_SC_Static,
+  Core_SC_Extern,
+  Core_SC_PrivateExtern,
+  Core_SC_Register
+] >;
+
+// thread storage class
+
+class Core_TSCAttr< string name, int val > : I64EnumAttrCase< name, val > {}
+
+class Core_TSCList< string name, string summary, list<Core_TSCAttr> cases >
+  : I64EnumAttr< name, summary, cases >
+{}
+
+def Core_TSC_None       : Core_TSCAttr< "tsc_none", 0 >;
+def Core_TSC_GNU_Thread : Core_TSCAttr< "tsc_gnu_thread", 1 >;
+def Core_TSC_CXX_Thread : Core_TSCAttr< "tsc_cxx_thread", 2 >;
+def Core_TSC_C_Thread   : Core_TSCAttr< "tsc_c_thread", 3 >;
+
+let cppNamespace = "::vast::core" in
+def Core_ThreadStorage : Core_TSCList< "TSClass", "thread storage class",
+[
+  Core_TSC_None,
+  Core_TSC_GNU_Thread,
+  Core_TSC_CXX_Thread,
+  Core_TSC_C_Thread
+] >;
+
+// Storage Duration
+
+class Core_StorageDurationAttr< string name, int val > : I64EnumAttrCase< name, val > {}
+
+class Core_StorageDurationList< string name, string summary, list<Core_StorageDurationAttr> cases >
+  : I64EnumAttr< name, summary, cases >
+{}
+
+def Core_SD_FullExpression : Core_StorageDurationAttr< "sd_none", 0 >;
+def Core_SD_Automatic      : Core_StorageDurationAttr< "sd_automatic", 1 >;
+def Core_SD_Thread 	       : Core_StorageDurationAttr< "sd_thread", 2 >;
+def Core_SD_Static         : Core_StorageDurationAttr< "sd_static", 3 >;
+def Core_SD_Dynamic        : Core_StorageDurationAttr< "sd_dynamic", 4 >;
+
+let cppNamespace = "::vast::core" in
+def Core_StorageDuration
+  : Core_StorageDurationList< "StorageDuration", "storage duration",
+[
+  Core_SD_FullExpression,
+  Core_SD_Automatic,
+  Core_SD_Thread,
+  Core_SD_Static,
+  Core_SD_Dynamic
+] >;
+
+// declaration context kinds
+class Core_DeclContextAttr< string name, int val > : I64EnumAttrCase< name, val > {}
+
+class Core_DeclContextList< string name, string summary, list<Core_DeclContextAttr> cases >
+  : I64EnumAttr< name, summary, cases >
+{}
+
+def Core_DC_Function        : Core_DeclContextAttr< "dc_function", 0 >;
+def Core_DC_Method          : Core_DeclContextAttr< "dc_method", 1 >;
+def Core_DC_Block           : Core_DeclContextAttr< "dc_block", 2 >;
+def Core_DC_Capture         : Core_DeclContextAttr< "dc_capture", 3 >;
+def Core_DC_TranslationUnit : Core_DeclContextAttr< "dc_translation_unit", 4 >;
+def Core_DC_Record          : Core_DeclContextAttr< "dc_record", 5 >;
+def Core_DC_Enum            : Core_DeclContextAttr< "dc_enum", 6 >;
+def Core_DC_Namespace       : Core_DeclContextAttr< "dc_namespace", 7 >;
+
+let cppNamespace = "::vast::core" in
+def Core_DeclContextKind
+  : Core_DeclContextList< "DeclContextKind", "declaration context kind",
+[
+  Core_DC_Function,
+  Core_DC_Method,
+  Core_DC_Block,
+  Core_DC_Capture,
+  Core_DC_TranslationUnit,
+  Core_DC_Record,
+  Core_DC_Enum,
+  Core_DC_Namespace
+] >;
+
 #endif // VAST_DIALECT_CORE_COREATTRIBUTES

include/vast/Dialect/Core/Func.td

@@ -10,18 +10,7 @@ include "mlir/Interfaces/FunctionInterfaces.td"
 include "vast/Dialect/Core/Interfaces/SymbolInterface.td"
 
 include "vast/Dialect/Core/CoreTraits.td"
-
-def Core_GlobalLinkageKind : Attr<
-    CPred<"::llvm::isa<::vast::core::GlobalLinkageKindAttr>($_self)">,
-    "global linkage kind"
-> {
-    let storageType = "::vast::core::GlobalLinkageKindAttr";
-    let returnType  = "::vast::core::GlobalLinkageKind";
-    let convertFromStorage = "$_self.getValue()";
-    let constBuilderCall = [{
-        ::vast::core::GlobalLinkageKindAttr::get($_builder.getContext(), $0)
-    }];
-}
+include "vast/Dialect/Core/LinkageHelper.td"
 
 def Core_FunctionType : Type<
     CPred<"::llvm::isa<::vast::core::FunctionType>($_self)">,

include/vast/Dialect/Core/Interfaces/CMakeLists.txt

@@ -1,3 +1,4 @@
+add_vast_op_interface(DeclStorageInterface)
 add_vast_op_interface(TypeDefinitionInterface)
 
 add_vast_op_interface(SymbolInterface)

include/vast/Dialect/Core/Interfaces/DeclStorageInterface.hpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2024, Trail of Bits, Inc.
+
+#pragma once
+
+#include "vast/Util/Warnings.hpp"
+
+VAST_RELAX_WARNINGS
+#include <mlir/Interfaces/FunctionInterfaces.h>
+#include <mlir/IR/BuiltinOps.h>
+#include <mlir/IR/BuiltinTypes.h>
+#include <mlir/IR/Dialect.h>
+#include <mlir/IR/OperationSupport.h>
+VAST_RELAX_WARNINGS
+
+#include "vast/Dialect/Core/CoreOps.hpp"
+
+#define GET_OP_FWD_DEFINES
+#include "vast/Dialect/HighLevel/HighLevel.h.inc"
+/// Include the generated interface declarations.
+#include "vast/Dialect/Core/Interfaces/DeclStorageInterface.h.inc"

include/vast/Dialect/Core/Interfaces/DeclStorageInterface.td

@@ -0,0 +1,124 @@
+// Copyright (c) 2024, Trail of Bits, Inc.
+
+#ifndef VAST_INTERFACES_DECL_STORAGE_INTERFACE
+#define VAST_INTERFACES_DECL_STORAGE_INTERFACE
+
+include "mlir/IR/OpBase.td"
+include "vast/Dialect/Core/StorageInfo.td"
+include "vast/Dialect/Core/Interfaces/Common.td"
+
+def Core_DeclStorageInterface : Core_OpInterface< "DeclStorageInterface" > {
+    let description = [{ Interface for querying info about declaration storage. }];
+
+    let methods = [
+        InterfaceMethod<"",
+            "bool", "hasLocalStorage", (ins), [{}],
+            /*defaultImplementation=*/[{
+                switch ($_op.getStorageClass()) {
+                    case ::vast::core::StorageClass::sc_none:
+                        return !isFileVarDecl() && $_op.getThreadStorageClass() == TSClass::tsc_none;
+                    case ::vast::core::StorageClass::sc_register: return isLocalVarDecl();
+                    case ::vast::core::StorageClass::sc_auto: return true;
+                    case ::vast::core::StorageClass::sc_extern:
+                    case ::vast::core::StorageClass::sc_static:
+                    case ::vast::core::StorageClass::sc_private_extern: return false;
+                }
+
+                VAST_UNIMPLEMENTED_MSG("unknown starage class");
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isLocalVarDecl", (ins), [{}],
+            /*defaultImplementation=*/[{ return this->isInFunctionOrMethodContext(); }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isStaticLocal", (ins), [{}],
+            /*defaultImplementation=*/[{
+                if (isFileVarDecl())
+                    return false;
+                auto sc = $_op.getStorageClass();
+                if (sc == ::vast::core::StorageClass::sc_static)
+                    return true;
+                auto tsc = $_op.getThreadStorageClass();
+                return sc == ::vast::core::StorageClass::sc_none && tsc == TSClass::tsc_cxx_thread;
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "hasExternalStorage", (ins), [{}],
+            /*defaultImplementation=*/[{
+                auto sc = $_op.getStorageClass();
+                return sc == ::vast::core::StorageClass::sc_extern
+                    || sc == ::vast::core::StorageClass::sc_private_extern;
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "hasGlobalStorage", (ins), [{}],
+            /*defaultImplementation=*/[{ return !hasLocalStorage(); }]
+        >,
+        InterfaceMethod<"",
+            "::vast::core::StorageDuration", "getStorageDuration", (ins), [{}],
+            /*defaultImplementation=*/[{
+                if (hasLocalStorage())
+                    return StorageDuration::sd_automatic;
+                if ($_op.getThreadStorageClass() != TSClass::tsc_none)
+                    return StorageDuration::sd_thread;
+                return StorageDuration::sd_static;
+            }]
+        >,
+        InterfaceMethod<"",
+            "::vast::core::DeclContextKind", "getDeclContextKind", (ins), [{}],
+            /*defaultImplementation=*/[{
+                if (auto kind_attr = $_op->template getAttrOfType< core::DeclContextKindAttr >("context")) {
+                    return kind_attr.getValue();
+                }
+                auto st = core::get_effective_symbol_table_for< core::var_symbol >($_op)->get_defining_operation();
+                if (mlir::isa< mlir::FunctionOpInterface >(st))
+                    return DeclContextKind::dc_function;
+                if (st->template hasTrait< core::ScopeLikeTrait >())
+                    return DeclContextKind::dc_function;
+                if (mlir::isa< core::ModuleOp >(st))
+                    return DeclContextKind::dc_translation_unit;
+                if (mlir::isa< hl::StructDeclOp >(st))
+                    return DeclContextKind::dc_record;
+                if (mlir::isa< hl::EnumDeclOp >(st))
+                    return DeclContextKind::dc_enum;
+                VAST_UNIMPLEMENTED_MSG("unknown declaration context");
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isStaticDataMember", (ins), [{}],
+            /*defaultImplementation=*/[{ return isInRecordContext(); }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isInFileContext", (ins), [{}],
+            /*defaultImplementation=*/[{
+                auto kind = getDeclContextKind();
+                return kind == DeclContextKind::dc_translation_unit
+                    || kind == DeclContextKind::dc_namespace;
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isInFunctionOrMethodContext", (ins), [{}],
+            /*defaultImplementation=*/[{
+                auto kind = getDeclContextKind();
+                return kind == DeclContextKind::dc_function
+                    || kind == DeclContextKind::dc_method
+                    || kind == DeclContextKind::dc_capture;
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isInRecordContext", (ins), [{}],
+            /*defaultImplementation=*/[{
+                return getDeclContextKind() == DeclContextKind::dc_record;
+            }]
+        >,
+        InterfaceMethod<"",
+            "bool", "isFileVarDecl", (ins), [{}],
+            /*defaultImplementation=*/[{
+              return isInFileContext() || isStaticDataMember();
+            }]
+        >
+    ];
+}
+
+#endif // VAST_INTERFACES_DECL_STORAGE_INTERFACE

include/vast/Dialect/Core/Linkage.hpp

@@ -6,6 +6,7 @@
 
 VAST_RELAX_WARNINGS
 #include <clang/AST/GlobalDecl.h>
+#include <mlir/Dialect/LLVMIR/LLVMAttrs.h>
 VAST_UNRELAX_WARNINGS
 
 #include "vast/Dialect/HighLevel/HighLevelAttributes.hpp"
@@ -21,4 +22,6 @@ namespace vast::core {
 
     std::optional< core::GlobalLinkageKind > get_function_linkage(clang::GlobalDecl glob);
 
+    mlir::LLVM::Linkage convert_linkage_to_llvm(core::GlobalLinkageKind linkage);
+
 } // namespace vast::core

include/vast/Dialect/Core/LinkageHelper.td

@@ -0,0 +1,19 @@
+// Copyright (c) 2023, Trail of Bits, Inc.
+
+#ifndef VAST_DIALECT_CORE_LINKAGE_HELPER
+#define VAST_DIALECT_CORE_LINKAGE_HELPER
+include "mlir/IR/OpBase.td"
+
+def Core_GlobalLinkageKind : Attr<
+    CPred<"::llvm::isa<::vast::core::GlobalLinkageKindAttr>($_self)">,
+    "global linkage kind"
+> {
+    let storageType = "::vast::core::GlobalLinkageKindAttr";
+    let returnType  = "::vast::core::GlobalLinkageKind";
+    let convertFromStorage = "$_self.getValue()";
+    let constBuilderCall = [{
+        ::vast::core::GlobalLinkageKindAttr::get($_builder.getContext(), $0)
+    }];
+}
+
+#endif // VAST_DIALECT_CORE_LINKAGE_HELPER

include/vast/Dialect/Core/StorageInfo.td

@@ -0,0 +1,31 @@
+#ifndef VAST_DIALECT_CORE_STORAGEINFO
+#define VAST_DIALECT_CORE_STORAGEINFO
+
+include "mlir/IR/AttrTypeBase.td"
+include "mlir/IR/BuiltinAttributeInterfaces.td"
+
+def Core_StorageClass : Attr<
+    CPred<"::mlir::isa<::vast::core::StorageClassAttr>($_self)">,
+    "declaration storage class"
+> {
+    let storageType = "::vast::core::StorageClassAttr";
+    let returnType  = "::vast::core::StorageClass";
+    let convertFromStorage = "$_self.getValue()";
+    let constBuilderCall = [{
+        ::vast::core::StorageClassAttr::get($_builder.getContext(), $0)
+    }];
+}
+
+def Core_ThreadStorage : Attr<
+    CPred<"::mlir::isa<::vast::core::TSClassAttr>($_self)">,
+    "declaration storage class"
+> {
+    let storageType = "::vast::core::TSClassAttr";
+    let returnType  = "::vast::core::TSClass";
+    let convertFromStorage = "$_self.getValue()";
+    let constBuilderCall = [{
+        ::vast::core::TSClassAttr::get($_builder.getContext(), $0)
+    }];
+}
+
+#endif //VAST_DIALECT_CORE_STORAGEINFO