[llvm-context, solidity] Add CLI option '-g' to generate debug inform…

…ation.

Add command line option '-g' to generate source level debug information
in the output code. This only works with the LLVM-IR code generator.

Add flag 'emit_debug_info' to the llvm-context optimizer/code-gen
settings structure, to record the setting of the '-g' CLI option.

Generate source level debug information for the functions defined when
YUL is lowered to LLVM-IR. This includes the deploy_code and runtime
functions generated by the compiler.

Generate debug-location information for other constructs that may appear
in a contract.

crates/llvm-context/src/lib.rs

@@ -16,6 +16,7 @@ pub use self::polkavm::context::argument::Argument as PolkaVMArgument;
 pub use self::polkavm::context::attribute::Attribute as PolkaVMAttribute;
 pub use self::polkavm::context::build::Build as PolkaVMBuild;
 pub use self::polkavm::context::code_type::CodeType as PolkaVMCodeType;
+pub use self::polkavm::context::debug_info::DebugInfo;
 pub use self::polkavm::context::evmla_data::EVMLAData as PolkaVMContextEVMLAData;
 pub use self::polkavm::context::function::block::evmla_data::key::Key as PolkaVMFunctionBlockKey;
 pub use self::polkavm::context::function::block::evmla_data::EVMLAData as PolkaVMFunctionBlockEVMLAData;

crates/llvm-context/src/optimizer/settings/mod.rs

@@ -9,7 +9,7 @@ use itertools::Itertools;
 
 use self::size_level::SizeLevel;
 
-/// The LLVM optimizer settings.
+/// The LLVM optimizer and code-gen settings.
 #[derive(Debug, Serialize, Deserialize, Clone, Eq)]
 pub struct Settings {
     /// The middle-end optimization level.
@@ -28,6 +28,9 @@ pub struct Settings {
     pub is_verify_each_enabled: bool,
     /// Whether the LLVM `debug logging` option is enabled.
     pub is_debug_logging_enabled: bool,
+
+    /// Whether to generate source-level debug information.
+    pub emit_debug_info: bool,
 }
 
 impl Settings {
@@ -47,6 +50,8 @@ impl Settings {
 
             is_verify_each_enabled: false,
             is_debug_logging_enabled: false,
+
+            emit_debug_info: false,
         }
     }
 
@@ -58,6 +63,8 @@ impl Settings {
 
         is_verify_each_enabled: bool,
         is_debug_logging_enabled: bool,
+
+        emit_debug_info: bool,
     ) -> Self {
         Self {
             level_middle_end,
@@ -69,6 +76,8 @@ impl Settings {
 
             is_verify_each_enabled,
             is_debug_logging_enabled,
+
+            emit_debug_info,
         }
     }
 
@@ -220,6 +229,11 @@ impl Settings {
     pub fn is_system_request_memoization_disabled(&self) -> bool {
         self.is_system_request_memoization_disabled
     }
+
+    /// Whether source-level debug information should be emitted.
+    pub fn emit_debug_info(&self) -> bool {
+        self.emit_debug_info
+    }
 }
 
 impl PartialEq for Settings {

crates/llvm-context/src/polkavm/context/debug_info.rs

@@ -1,14 +1,54 @@
 //! The LLVM debug information.
 
+use std::cell::RefCell;
+
 use inkwell::debug_info::AsDIScope;
-use num::Zero;
+use inkwell::debug_info::DIScope;
+
+/// Debug info scope stack
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ScopeStack<'ctx> {
+    stack: Vec<DIScope<'ctx>>,
+}
+
+// Abstract the type of the DIScope stack.
+impl<'ctx> ScopeStack<'ctx> {
+    pub fn from(item: DIScope<'ctx>) -> Self {
+        Self { stack: vec![item] }
+    }
+
+    /// Return the top of the scope stack, or None if the stack is empty.
+    pub fn top(&self) -> Option<DIScope<'ctx>> {
+        self.stack.last().copied()
+    }
+
+    /// Push a scope onto the stack.
+    pub fn push(&mut self, scope: DIScope<'ctx>) {
+        self.stack.push(scope)
+    }
+
+    /// Pop the scope at the top of the stack and return it.
+    /// Return None if the stack is empty.
+    pub fn pop(&mut self) -> Option<DIScope<'ctx>> {
+        self.stack.pop()
+    }
+
+    /// Return the number of scopes on the stack.
+    pub fn len(&self) -> usize {
+        self.stack.len()
+    }
+}
 
 /// The LLVM debug information.
 pub struct DebugInfo<'ctx> {
     /// The compile unit.
     compile_unit: inkwell::debug_info::DICompileUnit<'ctx>,
     /// The debug info builder.
     builder: inkwell::debug_info::DebugInfoBuilder<'ctx>,
+    /// Enclosing debug info scopes.
+    scope_stack: RefCell<ScopeStack<'ctx>>,
+    // Names of enclosing objects, functions and other namespaces.
+    namespace_stack: RefCell<Vec<String>>,
 }
 
 impl<'ctx> DebugInfo<'ctx> {
@@ -35,19 +75,44 @@ impl<'ctx> DebugInfo<'ctx> {
         Self {
             compile_unit,
             builder,
+            scope_stack: RefCell::new(ScopeStack::from(compile_unit.as_debug_info_scope())),
+            namespace_stack: RefCell::new(vec![]),
         }
     }
 
+    /// Prepare an LLVM-IR module for debug-info generation
+    pub fn initialize_module(
+        &self,
+        llvm: &'ctx inkwell::context::Context,
+        module: &inkwell::module::Module<'ctx>,
+    ) {
+        let debug_metadata_value = llvm
+            .i32_type()
+            .const_int(inkwell::debug_info::debug_metadata_version() as u64, false);
+        module.add_basic_value_flag(
+            "Debug Info Version",
+            inkwell::module::FlagBehavior::Warning,
+            debug_metadata_value,
+        );
+        self.push_scope(self.compilation_unit().get_file().as_debug_info_scope());
+    }
+
+    /// Finalize debug-info for an LLVM-IR module.
+    pub fn finalize_module(&self) {
+        self.builder().finalize()
+    }
+
     /// Creates a function info.
     pub fn create_function(
         &self,
         name: &str,
     ) -> anyhow::Result<inkwell::debug_info::DISubprogram<'ctx>> {
+        let flags = inkwell::debug_info::DIFlagsConstants::ZERO;
         let subroutine_type = self.builder.create_subroutine_type(
             self.compile_unit.get_file(),
-            Some(self.create_type(revive_common::BIT_LENGTH_FIELD)?),
+            Some(self.create_word_type(Some(flags))?.as_type()),
             &[],
-            inkwell::debug_info::DIFlags::zero(),
+            flags,
         );
 
         let function = self.builder.create_function(
@@ -60,7 +125,7 @@ impl<'ctx> DebugInfo<'ctx> {
             true,
             false,
             1,
-            inkwell::debug_info::DIFlags::zero(),
+            flags,
             false,
         );
 
@@ -74,24 +139,91 @@ impl<'ctx> DebugInfo<'ctx> {
         Ok(function)
     }
 
-    /// Creates a primitive type info.
-    pub fn create_type(
+    /// Creates primitive integer type debug-info.
+    pub fn create_primitive_type(
         &self,
         bit_length: usize,
-    ) -> anyhow::Result<inkwell::debug_info::DIType<'ctx>> {
+        flags: Option<inkwell::debug_info::DIFlags>,
+    ) -> anyhow::Result<inkwell::debug_info::DIBasicType<'ctx>> {
+        let di_flags = flags.unwrap_or(inkwell::debug_info::DIFlagsConstants::ZERO);
+        let di_encoding: u32 = 0;
+        let type_name = String::from("U") + bit_length.to_string().as_str();
         self.builder
-            .create_basic_type(
-                "U256",
-                bit_length as u64,
-                0,
-                inkwell::debug_info::DIFlags::zero(),
-            )
-            .map(|basic_type| basic_type.as_type())
+            .create_basic_type(type_name.as_str(), bit_length as u64, di_encoding, di_flags)
             .map_err(|error| anyhow::anyhow!("Debug info error: {}", error))
     }
 
-    /// Finalizes the builder.
-    pub fn finalize(&self) {
-        self.builder.finalize();
+    /// Returns the debug-info model of word-sized integer types.
+    pub fn create_word_type(
+        &self,
+        flags: Option<inkwell::debug_info::DIFlags>,
+    ) -> anyhow::Result<inkwell::debug_info::DIBasicType<'ctx>> {
+        self.create_primitive_type(revive_common::BIT_LENGTH_WORD, flags)
+    }
+
+    /// Return the DIBuilder.
+    pub fn builder(&self) -> &inkwell::debug_info::DebugInfoBuilder<'ctx> {
+        &self.builder
+    }
+
+    /// Return the compilation unit. {
+    pub fn compilation_unit(&self) -> &inkwell::debug_info::DICompileUnit<'ctx> {
+        &self.compile_unit
+    }
+
+    /// Push a debug-info scope onto the stack.
+    pub fn push_scope(&self, scope: DIScope<'ctx>) {
+        self.scope_stack.borrow_mut().push(scope)
+    }
+
+    /// Pop the top of the debug-info scope stack and return it.
+    pub fn pop_scope(&self) -> Option<DIScope<'ctx>> {
+        self.scope_stack.borrow_mut().pop()
+    }
+
+    /// Return the top of the debug-info scope stack.
+    pub fn top_scope(&self) -> Option<DIScope<'ctx>> {
+        self.scope_stack.borrow().top()
+    }
+
+    /// Return the number of debug-info scopes on the scope stack.
+    pub fn num_scopes(&self) -> usize {
+        self.scope_stack.borrow().len()
+    }
+
+    /// Push a name onto the namespace stack.
+    pub fn push_namespace(&self, name: String) {
+        self.namespace_stack.borrow_mut().push(name);
+    }
+
+    /// Pop the top name off the namespace stack and return it.
+    pub fn pop_namespace(&self) -> Option<String> {
+        self.namespace_stack.borrow_mut().pop()
+    }
+
+    /// Return the top of the namespace stack.
+    pub fn top_namespace(&self) -> Option<String> {
+        self.namespace_stack.borrow().last().cloned()
+    }
+
+    // Get a string representation of the namespace stack. Optionally append the given name.
+    pub fn namespace_as_identifier(&self, name: Option<&str>) -> String {
+        let separator = "::";
+        let mut ret = String::new();
+        let mut sep = false;
+        for s in self.namespace_stack.borrow().iter() {
+            if sep {
+                ret.push_str(separator);
+            };
+            sep = true;
+            ret.push_str(s)
+        }
+        if let Some(n) = name {
+            if sep {
+                ret.push_str(separator);
+            };
+            ret.push_str(n);
+        }
+        ret
     }
 }

crates/llvm-context/src/polkavm/context/function/declaration.rs

@@ -17,4 +17,8 @@ impl<'ctx> Declaration<'ctx> {
     ) -> Self {
         Self { r#type, value }
     }
+
+    pub fn function_value(&self) -> inkwell::values::FunctionValue<'ctx> {
+        self.value
+    }
 }

crates/llvm-context/src/polkavm/context/function/runtime/deploy_code.rs

@@ -8,6 +8,8 @@ use crate::polkavm::context::Context;
 use crate::polkavm::Dependency;
 use crate::polkavm::WriteLLVM;
 
+use inkwell::debug_info::AsDIScope;
+
 /// The deploy code function.
 /// Is a special function that is only used by the front-end generated code.
 #[derive(Debug)]
@@ -60,7 +62,57 @@ where
         context.set_basic_block(context.current_function().borrow().entry_block());
         context.set_code_type(CodeType::Deploy);
 
+        if let Some(dinfo) = context.debug_info() {
+            context.builder().unset_current_debug_location();
+            let di_builder = dinfo.builder();
+            let func_name: &str = runtime::FUNCTION_DEPLOY_CODE;
+            let di_file = dinfo.compilation_unit().get_file();
+            let di_scope = dinfo.top_scope().expect("expected a debug-info scope");
+
+            let di_flags = inkwell::debug_info::DIFlagsConstants::PUBLIC;
+            let ret_type = dinfo.create_word_type(Some(di_flags))?.as_type();
+            let subroutine_type =
+                di_builder.create_subroutine_type(di_file, Some(ret_type), &[], di_flags);
+            let linkage = dinfo.namespace_as_identifier(Some(func_name));
+            let di_func_scope = di_builder.create_function(
+                di_scope,
+                func_name,
+                Some(linkage.as_str()),
+                di_file,
+                0,
+                subroutine_type,
+                false,
+                true,
+                1,
+                di_flags,
+                false,
+            );
+            let func_value = context
+                .current_function()
+                .borrow()
+                .declaration()
+                .function_value();
+            func_value.set_subprogram(di_func_scope);
+            dinfo.push_scope(di_func_scope.as_debug_info_scope());
+            let di_loc = di_builder.create_debug_location(
+                context.llvm(),
+                0,
+                0,
+                di_func_scope.as_debug_info_scope(),
+                None,
+            );
+            context.builder().set_current_debug_location(di_loc)
+        }
+
         self.inner.into_llvm(context)?;
+        if let Some(dinfo) = context.debug_info() {
+            let di_loc_scope = dinfo.top_scope().expect("expected a debug-info scope");
+            let di_loc =
+                dinfo
+                    .builder()
+                    .create_debug_location(context.llvm(), 0, 0, di_loc_scope, None);
+            context.builder().set_current_debug_location(di_loc)
+        }
         match context
             .basic_block()
             .get_last_instruction()
@@ -73,8 +125,22 @@ where
         }
 
         context.set_basic_block(context.current_function().borrow().return_block());
+        if let Some(dinfo) = context.debug_info() {
+            context.builder().unset_current_debug_location();
+            let di_builder = dinfo.builder();
+            let di_parent_scope = dinfo
+                .top_scope()
+                .expect("expected an existing debug-info scope");
+            let di_loc =
+                di_builder.create_debug_location(context.llvm(), 0, 0, di_parent_scope, None);
+            context.builder().set_current_debug_location(di_loc)
+        }
         context.build_return(None);
 
+        if let Some(dinfo) = context.debug_info() {
+            let _ = dinfo.pop_scope();
+        }
+
         Ok(())
     }
 }