diff --git a/Cargo.lock b/Cargo.lock index 8b866e98c0..569021b40e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -305,6 +305,17 @@ dependencies = [ "serde", ] +[[package]] +name = "chacha20" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.0", + "rand_core 0.10.1", +] + [[package]] name = "chrono" version = "0.4.44" @@ -465,6 +476,15 @@ dependencies = [ "libc", ] +[[package]] +name = "cpufeatures" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +dependencies = [ + "libc", +] + [[package]] name = "criterion" version = "0.8.2" @@ -933,6 +953,7 @@ dependencies = [ "cfg-if", "libc", "r-efi", + "rand_core 0.10.1", "wasip2", "wasip3", ] @@ -1128,7 +1149,9 @@ dependencies = [ "itertools 0.14.0", "petgraph", "portgraph", + "rand 0.10.1", "rstest", + "serde_json", "strum", ] @@ -2143,6 +2166,17 @@ dependencies = [ "rand_core 0.9.5", ] +[[package]] +name = "rand" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207" +dependencies = [ + "chacha20", + "getrandom 0.4.1", + "rand_core 0.10.1", +] + [[package]] name = "rand_chacha" version = "0.9.0" @@ -2171,6 +2205,12 @@ dependencies = [ "getrandom 0.3.4", ] +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + [[package]] name = "rand_xorshift" version = "0.4.0" @@ -2549,7 +2589,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" dependencies = [ "cfg-if", - "cpufeatures", + "cpufeatures 0.2.17", "digest", ] diff --git a/hugr-cli/src/mermaid.rs b/hugr-cli/src/mermaid.rs index d476c4ac36..6418cd2ac0 100644 --- a/hugr-cli/src/mermaid.rs +++ b/hugr-cli/src/mermaid.rs @@ -7,6 +7,8 @@ use anyhow::Result; use clap::Parser; use clio::Output; use hugr::HugrView; +use hugr::hugr::views::render::NodeLabel; +use hugr::metadata::DEBUGINFO_META_KEY; use hugr::package::PackageValidationError; /// Dump the standard extensions. @@ -26,6 +28,16 @@ pub struct MermaidArgs { help = "Validate before rendering, includes extension inference." )] pub validate: bool, + + /// Print debug metadata. + #[arg( + short = 'D', + long, + help = "Print debug info attached to nodes if it exists. For rendering purposes, \ + we replace double quotes with single quotes and newlines with spaces." + )] + pub debug_info: bool, + /// Output file '-' for stdout #[clap(long, short, value_parser, default_value = "-")] output: Output, @@ -64,10 +76,19 @@ impl MermaidArgs { } for hugr in package.modules { + let mmd_fmt = if self.debug_info { + hugr.mermaid_format() + .with_node_labels(NodeLabel::MetadataValues { + print_keys: [DEBUGINFO_META_KEY.to_string()].into(), + }) + } else { + hugr.mermaid_format() + }; + if let Some(ref mut writer) = output_override { - writeln!(writer, "{}", hugr.mermaid_string())?; + writeln!(writer, "{}", mmd_fmt.finish())?; } else { - writeln!(self.output, "{}", hugr.mermaid_string())?; + writeln!(self.output, "{}", mmd_fmt.finish())?; } } Ok(()) diff --git a/hugr-core/src/hugr/views.rs b/hugr-core/src/hugr/views.rs index 4e0211b6e6..4dd4f95024 100644 --- a/hugr-core/src/hugr/views.rs +++ b/hugr-core/src/hugr/views.rs @@ -12,6 +12,7 @@ pub mod sibling_subgraph; mod tests; use serde::de::Deserialize; +use std::any::type_name; use std::borrow::Cow; use std::collections::HashMap; @@ -33,7 +34,7 @@ use super::validate::ValidationContext; use super::{Hugr, HugrMut, Node, ValidationError}; use crate::core::HugrNode; use crate::extension::ExtensionRegistry; -use crate::metadata::{Metadata, RawMetadataValue}; +use crate::metadata::{Metadata, MetadataError, RawMetadataValue}; use crate::ops::handle::NodeHandle; use crate::ops::{OpParent, OpTag, OpTrait, OpType}; @@ -111,6 +112,28 @@ pub trait HugrView: HugrInternals { .and_then(|value| <::Type<'_> as Deserialize>::deserialize(value).ok()) } + /// Returns the metadata associated with a node, differentiating between a missing and + /// invalid payload. + /// + /// If there is no metadata found with key M::KEY, returns Ok(None) + /// If there is metadata at that key which does not deserialize into M, return Err + /// Otherwise, return Ok(Some(metadata)). + #[inline] + fn try_get_metadata( + &self, + node: Self::Node, + ) -> Result::Type<'_>>, MetadataError> { + if let Some(raw_value) = self.get_metadata_any(node, ::KEY) { + <::Type<'_> as Deserialize>::deserialize(raw_value) + .map_err(|json_err| { + MetadataError::MetadataDeserializationError(type_name::(), json_err) + }) + .map(Some) + } else { + Ok(None) + } + } + /// Returns a metadata entry associated with a node and a string key. /// /// When possible, prefer using the type-safe accessor [`HugrView::get_metadata`] instead. diff --git a/hugr-core/src/hugr/views/render.rs b/hugr-core/src/hugr/views/render.rs index ae0f230c2c..1241a84073 100644 --- a/hugr-core/src/hugr/views/render.rs +++ b/hugr-core/src/hugr/views/render.rs @@ -1,6 +1,7 @@ //! Helper methods to compute the node/edge/port style when rendering a HUGR //! into dot or mermaid format. +use itertools::Itertools; use std::collections::HashMap; use portgraph::render::{EdgeStyle, NodeStyle, PortStyle, PresentationStyle}; @@ -179,6 +180,12 @@ pub enum NodeLabel { /// Display the node index as a number. #[default] Numeric, + /// Display the numeric node index and a list of metadata keys and their JSON values. + /// Prints "null" if a key is not present on a node. + MetadataValues { + /// List of metadata keys to display + print_keys: Vec, + }, /// Display the labels corresponding to the node indices. Custom(HashMap), } @@ -196,6 +203,14 @@ pub(in crate::hugr) fn node_style<'a>( } } + fn numeric_label(h: &Hugr, n: NodeIndex, is_entry: bool) -> String { + if is_entry { + format!("({}) [**{}**]", n.index(), node_name(h, n)) + } else { + format!("({}) {}", n.index(), node_name(h, n)) + } + } + let mut entrypoint_style = PresentationStyle::default(); entrypoint_style.stroke = Some("#832561".to_string()); entrypoint_style.stroke_width = Some("3px".to_string()); @@ -204,18 +219,9 @@ pub(in crate::hugr) fn node_style<'a>( match formatter.node_labels { NodeLabel::Numeric => Box::new(move |n| { if Some(n) == entrypoint { - NodeStyle::boxed(format!( - "({ni}) [**{name}**]", - ni = n.index(), - name = node_name(h, n) - )) - .with_attrs(entrypoint_style.clone()) + NodeStyle::boxed(numeric_label(h, n, true)).with_attrs(entrypoint_style.clone()) } else { - NodeStyle::boxed(format!( - "({ni}) {name}", - ni = n.index(), - name = node_name(h, n) - )) + NodeStyle::boxed(numeric_label(h, n, false)) } }), NodeLabel::None => Box::new(move |n| { @@ -226,6 +232,32 @@ pub(in crate::hugr) fn node_style<'a>( NodeStyle::boxed(node_name(h, n)) } }), + NodeLabel::MetadataValues { print_keys } => Box::new(move |n| { + let kv_str = print_keys + .iter() + .filter_map(|key| { + h.get_metadata_any(n.into(), key).map(|json_value| { + format!( + "{key}={}", + serde_json::to_string(json_value) + .expect("JSON metadata should be serializable") + // the mermaid renderer in portgraph generates verbose escapes + // for double quotes and newlines, so we replace them with + // single quotes and spaces + .replace('\n', " ") + .replace('"', "\'") + ) + }) + }) + .join("; "); + + if Some(n) == entrypoint { + NodeStyle::boxed(format!("{}; {kv_str}", numeric_label(h, n, true))) + .with_attrs(entrypoint_style.clone()) + } else { + NodeStyle::boxed(format!("{}; {kv_str}", numeric_label(h, n, false))) + } + }), NodeLabel::Custom(labels) => Box::new(move |n| { if Some(n) == entrypoint { NodeStyle::boxed(format!( diff --git a/hugr-core/src/metadata.rs b/hugr-core/src/metadata.rs index b71064d9c8..7785d384b6 100644 --- a/hugr-core/src/metadata.rs +++ b/hugr-core/src/metadata.rs @@ -22,6 +22,14 @@ //! let payload = hugr.get_metadata::(hugr.module_root()); //! assert_eq!(payload, Some("payload")); //! ``` +mod debug_info; + +use thiserror::Error; + +#[doc(inline)] +pub use self::debug_info::{ + CompileUnitRecord, DEBUGINFO_META_KEY, DebugRecordKind, LocationRecord, SubprogramRecord, +}; // // When adding new metadata keys, they should be re-exported by the python bindings. // See hugr-py/rust/metadata.rs @@ -65,3 +73,12 @@ impl Metadata for HugrUsedExtensions { type Type<'hugr> = Vec; const KEY: &'static str = "core.used_extensions"; } + +/// Errors related to metadata +#[derive(Error, Debug)] +pub enum MetadataError { + /// Returned by `try_get_metadata` if the metadata present at the requested key + /// cannot be deserialized into the expected type. + #[error("Metadata value does not deserialize to {0}: {1}")] + MetadataDeserializationError(&'static str, serde_json::Error), +} diff --git a/hugr-core/src/metadata/debug_info.rs b/hugr-core/src/metadata/debug_info.rs new file mode 100644 index 0000000000..5322fcecda --- /dev/null +++ b/hugr-core/src/metadata/debug_info.rs @@ -0,0 +1,98 @@ +use crate::metadata::Metadata; +use serde::{Deserialize, Serialize}; +use thiserror::Error; + +/// The HUGR metadata key for debug records +pub const DEBUGINFO_META_KEY: &str = "core.debug_info"; + +/// Errors related to debug info metadata +#[derive(Debug, Error)] +pub enum DebugInfoError { + /// This error indicates that the 'kind' field in the metadata record is incorrect. + #[error("Debug metadata has wrong kind: got '{0}' expected '{1}'")] + DRKindMismatchError(String, &'static str), +} + +// We could remove this trait & macro if serde provided something like +// https://github.com/serde-rs/serde/pull/2908. +/// Trait which checks the "kind" string in a JSON debug record is correct +pub trait DebugRecordKind { + /// Returns Err if the record's 'kind' tag is incorrect, + /// or Ok(()) otherwise. + fn check_kind(&self) -> Result<(), DebugInfoError>; +} + +macro_rules! impl_dr_kind_check { + ( $drtype:ty, $expected_kind:expr ) => { + impl DebugRecordKind for $drtype { + fn check_kind(&self) -> Result<(), DebugInfoError> { + if &self.kind == $expected_kind { + Ok(()) + } else { + // Copy the 'kind' string because the error will outlive the (malformed) object + Err(DebugInfoError::DRKindMismatchError( + self.kind.clone(), + $expected_kind, + )) + } + } + } + }; +} + +/// JSON-format HUGR debug record for a compilation unit (module) +#[derive(Serialize, Deserialize)] +pub struct CompileUnitRecord { + /// Type of the debug record (should be "compile_unit") + pub kind: String, + /// Working directory of the compiler + pub directory: String, + /// Index of the root file of the compilation unit in the file table + pub filename: usize, + /// Table of filenames used referenced in the debug info module + pub file_table: Vec, +} + +impl Metadata for CompileUnitRecord { + type Type<'hugr> = CompileUnitRecord; + const KEY: &'static str = DEBUGINFO_META_KEY; +} +impl_dr_kind_check!(CompileUnitRecord, "compile_unit"); + +/// JSON-format HUGR debug record for a subprogram (function) +#[derive(Serialize, Deserialize)] +pub struct SubprogramRecord { + /// Type of the debug record (should be "subprogram") + pub kind: String, + /// file_tab index of the file where this function is defined + pub file: usize, + /// Line number where this function's declaration begins + pub line_no: usize, + // TODO: waiting on scopes in milestone 2 + //scope: Option, + /// Line number where this function's body begins + pub scope_line: usize, +} + +impl Metadata for SubprogramRecord { + type Type<'hugr> = SubprogramRecord; + const KEY: &'static str = DEBUGINFO_META_KEY; +} +impl_dr_kind_check!(SubprogramRecord, "subprogram"); + +/// JSON-format HUGR debug record for a source code location +#[derive(Serialize, Deserialize)] +pub struct LocationRecord { + /// Type of the debug record (should be "location") + pub kind: String, + /// Column number of the location + pub column: usize, + /// Line number of the location + pub line_no: usize, +} + +impl Metadata for LocationRecord { + type Type<'hugr> = LocationRecord; + const KEY: &'static str = DEBUGINFO_META_KEY; +} +impl_dr_kind_check!(LocationRecord, "location"); diff --git a/hugr-llvm/Cargo.toml b/hugr-llvm/Cargo.toml index 3f83253f74..c1ea71f324 100644 --- a/hugr-llvm/Cargo.toml +++ b/hugr-llvm/Cargo.toml @@ -16,7 +16,7 @@ keywords = ["Quantum", "Quantinuum"] categories = ["compilers"] [features] -test-utils = ["insta", "rstest", "portgraph"] +test-utils = ["insta", "rstest", "portgraph", "rand"] default = ["llvm21-1"] llvm21-1 = ["inkwell/llvm21-1"] @@ -37,9 +37,11 @@ insta = { workspace = true, optional = true } rstest = { workspace = true, optional = true } portgraph = { workspace = true, optional = true } derive_more = { workspace = true, features = ["debug"] } +rand = { version = "0.10.1", optional = true } [dev-dependencies] hugr-llvm = { "path" = ".", features = ["test-utils"] } +serde_json.workspace = true [build-dependencies] cc = "1.2.57" diff --git a/hugr-llvm/src/emit.rs b/hugr-llvm/src/emit.rs index 6297321d61..2828aa29fa 100644 --- a/hugr-llvm/src/emit.rs +++ b/hugr-llvm/src/emit.rs @@ -15,11 +15,12 @@ use inkwell::{ }; use std::{collections::HashSet, rc::Rc}; +use crate::emit::debug_info::DebugInfoContext; use crate::types::{HugrFuncType, HugrSumType, HugrType, TypingSession}; - use crate::{custom::CodegenExtsMap, types::LLVMSumType, utils::fat::FatNode}; pub mod args; +pub mod debug_info; pub mod func; pub mod libc; pub mod namer; @@ -44,6 +45,7 @@ where module: Module<'c>, extensions: Rc>, namer: Rc, + di_context: Option>, } impl<'c, 'a, H> EmitModuleContext<'c, 'a, H> { @@ -69,6 +71,29 @@ impl<'c, 'a, H> EmitModuleContext<'c, 'a, H> { self.iw_context } + pub fn di_context(&self) -> Option<&DebugInfoContext<'c>> { + self.di_context.as_ref() + } + + pub fn di_context_mut(&mut self) -> Option<&mut DebugInfoContext<'c>> { + self.di_context.as_mut() + } + + /// If the Module has attached debug info, create a matching `di_context`. + /// Fails if `di_context` is not None. + pub fn try_di_init>( + &mut self, + node: FatNode<'_, hugr_core::ops::Module, HV>, + ptr_bits: u32, + ) -> Result<()> { + if self.di_context.is_some() { + Err(anyhow!("Debug context already present")) + } else { + self.di_context = DebugInfoContext::try_from_hugr_module(node, &self.module, ptr_bits)?; + Ok(()) + } + } + /// Creates a new `EmitModuleContext`. We take ownership of the [Module], /// and return it in [`EmitModuleContext::finish`]. pub fn new( @@ -82,6 +107,7 @@ impl<'c, 'a, H> EmitModuleContext<'c, 'a, H> { module, extensions, namer, + di_context: None, // we decide whether to emit debug info by inspecting the HUGR Module } } @@ -235,9 +261,10 @@ impl<'c, 'a, H> EmitModuleContext<'c, 'a, H> { } } - /// Consumes the `EmitModuleContext` and returns the internal [Module]. - pub fn finish(self) -> Module<'c> { - self.module + /// Consumes the `EmitModuleContext` and returns the internal [Module] and + /// [DebugInfoContext] (if present). + pub fn finish(mut self) -> (Module<'c>, Option>) { + (self.module, self.di_context.take()) } } @@ -257,6 +284,10 @@ impl<'c, 'a, H: HugrView> EmitHugr<'c, 'a, H> { to self.module_context { /// Returns a reference to the inner [Context]. pub fn iw_context(&self) -> &'c Context; + /// Returns an optional reference to the [DebugInfoContext]. + pub fn di_context(&self) -> Option<&DebugInfoContext<'c>>; + /// Returns an optional, mutable reference to the [DebugInfoContext]. + pub fn di_context_mut(&mut self) -> Option<&mut DebugInfoContext<'c>>; /// Returns a reference to the inner [Module]. Note that this type has /// "interior mutability", and this reference can be used to add functions /// and globals to the [Module]. @@ -321,7 +352,20 @@ impl<'c, 'a, H: HugrView> EmitHugr<'c, 'a, H> { /// and [`hugr_core::ops::FuncDecl`] nodes are not emitted directly, but instead by /// emission of ops with static edges from them. So [`FuncDefn`] are the only /// interesting children. - pub fn emit_module(mut self, node: FatNode<'_, hugr_core::ops::Module, H>) -> Result { + /// + /// If `emit_debug` is true, debug info will be included in the generated IR to the + /// extent it is present in the HUGR. If `emit_debug` is false, any debug info on + /// the HUGR will be ignored. `ptr_bits` gives the number of bits in a pointer on + /// target architecture - it is used only for generating debug info types. + pub fn emit_module( + mut self, + node: FatNode<'_, hugr_core::ops::Module, H>, + emit_debug: bool, + ptr_bits: u32, + ) -> Result { + if emit_debug { + self.module_context.try_di_init(node, ptr_bits)?; + } for c in node.children() { match c.as_ref() { OpType::FuncDefn(fd) => { @@ -343,6 +387,10 @@ impl<'c, 'a, H: HugrView> EmitHugr<'c, 'a, H> { return Ok((self, EmissionSet::default())); } let func = self.module_context.get_func_defn(node)?; + self.module_context + .di_context_mut() + .map_or(Ok(()), |di_ctx| di_ctx.try_add_di_func(node, func))?; + let mut func_ctx = EmitFuncContext::new(self.module_context, func)?; let ret_rmb = func_ctx.new_row_mail_box(node.signature().body().output.iter(), "ret")?; ops::emit_dataflow_parent( @@ -365,7 +413,7 @@ impl<'c, 'a, H: HugrView> EmitHugr<'c, 'a, H> { } /// Consumes the `EmitHugr` and returns the internal [Module]. - pub fn finish(self) -> Module<'c> { + pub fn finish(self) -> (Module<'c>, Option>) { self.module_context.finish() } } diff --git a/hugr-llvm/src/emit/debug_info.rs b/hugr-llvm/src/emit/debug_info.rs new file mode 100644 index 0000000000..3d3159738e --- /dev/null +++ b/hugr-llvm/src/emit/debug_info.rs @@ -0,0 +1,884 @@ +use anyhow::{Result, anyhow}; +use std::collections::BTreeMap; +use std::ffi::CString; +use std::ops::Deref; + +use hugr_core::{ + HugrView, Node, + metadata::{ + CompileUnitRecord, DebugRecordKind, HugrGenerator, LocationRecord, Metadata, + SubprogramRecord, + }, +}; + +use inkwell::{ + builder::Builder, + context::Context, + debug_info::{ + AsDIScope, DICompileUnit, DIFile, DILocation, DISubprogram, DISubroutineType, DIType, + DWARFEmissionKind, DWARFSourceLanguage, DebugInfoBuilder, + }, + module::{FlagBehavior, Linkage, Module}, + types::{ + ArrayType, BasicMetadataTypeEnum, BasicTypeEnum, FloatType, FunctionType, IntType, + StructType, + }, + values::FunctionValue, +}; + +use crate::utils::fat::FatNode; + +// alignment for all types +const DEBUG_TYPE_ALIGNMENT: u32 = 8; + +#[expect(dead_code, reason = "Currently unused types")] +enum DWARFTypeCode { + // Sourced frpm section 7.8 of the standard (look for the DW_ATE prefix), + // or alternately llvm-project/llvm/include/llvm/BinaryFormat/Dwarf.def. + // No idea why these aren't defined on the Rust side, rather annoying. + Address = 1, + Boolean = 2, + Float = 4, + Signed = 5, + Unsigned = 7, +} + +/// Try to produce a human-readable name from an internal HUGR function name. +/// +/// We expect a "mangled" name in the following form: +/// `__hugr__...`, where the Guppy +/// identifier can be a Python identifier path with multiple dot components. +/// +/// The pretty name is obtained by removing the first two dot components (`__hugr__` and +/// the Python module) and the final dot component (the node ID). If there are not +/// enough dot components to do this (fewer than three dots total), the original name is +/// returned unchanged. +fn unmangle_hugr_func_name(name: &str) -> &str { + // Index of the dot that starts the third component (after __hugr__ and module). + let Some(lpar) = name.match_indices('.').nth(1).map(|(i, _)| i) else { + return name; + }; + // Index of the last dot (separates the guppy identifier from the node ID). + // `unwrap` is safe: we already know there are at least two dots. + let rpar = name.rfind('.').unwrap(); + if lpar < rpar { + &name[(lpar + 1)..rpar] + } else { + name + } +} + +/// This type wraps the Inkwell DebugInfoBuilder and is responsible for converting HUGR +/// debug info into the format expected by Inkwell/LLVM. +pub struct DebugInfoContext<'c> { + /// Debug info builder + builder: DebugInfoBuilder<'c>, + /// DWARF record for the root compilation unit (HUGR module) + compile_unit: DICompileUnit<'c>, + /// Mapping from file indices to DWARF file records + file_table: Vec>, + /// Mapping from basic type names to DWARF type records + type_map: BTreeMap>, + /// Mapping from function type names to DWARF type records + fn_type_map: BTreeMap>, + // TODO: replace this with HUGR debug types after second milestone + /// Fixed opaque pointer type + ptr_type: DIType<'c>, + /// Placeholder DIFile for compiler-generated code + compgen_file: DIFile<'c>, + /// Counts the number of compiler-generated functions so far, + /// used to give each one a unique location record + num_compgen: u32, + // NOTE: have_di_loc may not match the Builder's view of things, + // see: https://github.com/TheDan64/inkwell/issues/674 + /// Tracks whether the builder currently has a location set + have_di_loc: bool, +} + +/// Check for a debug record of a given type on a node. +/// +/// This calls try_get_metadata, and then calls +/// metadata.check_kind() if that call returns Some(metadata). +fn try_get_debug_meta< + 'h, + H: HugrView, + M: Metadata = M> + DebugRecordKind + 'h, +>( + hugr: &'h H, + node: Node, +) -> Result> { + let maybe_record = hugr.try_get_metadata::(node)?; + if let Some(debug_record) = maybe_record { + debug_record.check_kind()?; + Ok(Some(debug_record)) + } else { + Ok(None) + } +} + +impl<'c> DebugInfoContext<'c> { + /// If there is a compilation unit record attached to the HUGR Module, + /// create and return Some(DebugInfoContext). If there is + /// a different debug record attached, return Err. + /// Otherwise, return Ok(None). + pub fn try_from_hugr_module>( + node: FatNode<'_, hugr_core::ops::Module, H>, + iw_module: &Module<'c>, + ptr_bits: u32, + ) -> Result> { + let maybe_record = try_get_debug_meta::<_, CompileUnitRecord>(node.hugr(), node.node())?; + let Some(root_meta) = maybe_record else { + return Ok(None); + }; + + // LLVM debug info version + let di_version = iw_module.get_context().i32_type().const_int(3, false); + iw_module.add_basic_value_flag("Debug Info Version", FlagBehavior::Warning, di_version); + + let prod_str = node + .hugr() + .get_metadata::(node.node()) + .map(|genmeta| genmeta.to_string()) + .unwrap_or("unknown_hugr_generator".to_string()); + + let (builder, compile_unit) = iw_module.create_debug_info_builder( + true, // allow_unresolved + DWARFSourceLanguage::Python, + &(root_meta.file_table[root_meta.filename]), + &root_meta.directory, + &prod_str, + false, // is_optimized + "", // flags + 0, // runtime_ver + "", // split_name + DWARFEmissionKind::Full, + 0, // dwo_id + true, // split_debug_inlining + false, // debug_info_for_profiling + "", // sysroot + "", // sdk + ); + + let file_table: Vec> = root_meta + .file_table + .iter() + .map( + // TODO: parse directory? relative paths? + |path| builder.create_file(path, ""), + ) + .collect(); + + // NOTE: LLVM has purpose-built constructs to represent this + // (DebugLoc::getCompilerGenerated etc), but they are not exposed + // through the C API. Internally they appear to just be records with null + // metadata ptrs, but Inkwell doesn't seem to let us construct those either. + let compgen_file = builder.create_file("COMPILER_GENERATED_CODE", ""); + + // note that this is not a DIPointerType, because + // it should be void* but Inkwell may not support creating a void DIType + let ptr_type = builder + .create_basic_type("ptr", ptr_bits as u64, DWARFTypeCode::Address as u32, 0)? + .as_type(); + + Ok(Some(Self { + builder, + compile_unit, + file_table, + type_map: BTreeMap::new(), + fn_type_map: BTreeMap::new(), + ptr_type, + compgen_file, + num_compgen: 0, + have_di_loc: false, + })) + } + + /// Get the size of a BasicTypeEnum + fn get_basic_type_size(&self, ty: BasicTypeEnum<'c>) -> u64 { + match ty { + BasicTypeEnum::ArrayType(array_ty) => { + array_ty.len() as u64 * self.get_basic_type_size(array_ty.get_element_type()) + } + BasicTypeEnum::FloatType(float_ty) => (float_ty.get_bit_width() / 8).into(), + BasicTypeEnum::IntType(int_ty) => (int_ty.get_bit_width() / 8).into(), + BasicTypeEnum::PointerType(_) => self.ptr_type.get_size_in_bits() / 8, + // TODO: this does not respect inter-member alignment. not that important + // until we have support for values in debug info. + BasicTypeEnum::StructType(struct_ty) => struct_ty + .get_field_types_iter() + .fold(0, |len, elem_ty| len + self.get_basic_type_size(elem_ty)), + _ => panic!("Unexpected type in `get_basic_type_size`: {ty}"), + } + } + + fn get_di_file(&self, idx: usize) -> Result> { + if idx >= self.file_table.len() { + Err(anyhow!("No debug file at index {idx}")) + } else { + Ok(self.file_table[idx]) + } + } + + fn create_di_int_type(&mut self, int_ty: IntType<'c>) -> Result> { + let width = int_ty.get_bit_width() as u64; + let name = format!("i{width}"); + // TODO: need HUGR type to get information about signedness + Ok(self + .builder + .create_basic_type(&name, width, DWARFTypeCode::Unsigned as u32, 0) + .map_err(|e| anyhow!("Could not create int DIType: {e}"))? + .as_type()) + } + + fn create_di_float_type(&mut self, flt_ty: FloatType<'c>) -> Result> { + let width: u64 = flt_ty.get_bit_width().into(); + let name = format!("f{width}"); + Ok(self + .builder + .create_basic_type(name.as_str(), width, DWARFTypeCode::Float as u32, 0) + .map_err(|e| anyhow!("Could not create float DIType: {e}"))? + .as_type()) + } + + fn create_di_arr_type(&mut self, arr_ty: ArrayType<'c>) -> Result> { + let elem_di_ty = self.get_basic_di_type(arr_ty.get_element_type().into())?; + let arr_len = arr_ty.len() as u64; + let arr_bits: u64 = arr_len * elem_di_ty.get_size_in_bits(); + let arr_len_i64: i64 = arr_len + .try_into() + .expect("Arrays should have length < 2^63"); + let arr_subscripts = 0..arr_len_i64; + Ok(self + .builder + .create_array_type( + elem_di_ty, + arr_bits, + elem_di_ty.get_align_in_bits(), + &[arr_subscripts], + ) + .as_type()) + } + + fn create_di_struct_type(&mut self, struct_ty: StructType<'c>) -> Result> { + let mut struct_len: u64 = 0; + let mut elem_tys = Vec::default(); + for llvm_ty in struct_ty.get_field_types_iter() { + elem_tys.push(self.get_basic_di_type(llvm_ty.into())?); + struct_len += self.get_basic_type_size(llvm_ty); + } + + Ok(self + .builder + .create_struct_type( + self.compile_unit.as_debug_info_scope(), // all structs have global scope + struct_ty + .print_to_string() + .to_str() + .expect("type name is utf-8"), + self.compile_unit.get_file(), // TODO: this is probably supposed to be the decl + 0, // line_no + struct_len, + DEBUG_TYPE_ALIGNMENT, + 0, // flags + None, // derived_from + &elem_tys, + 0, // runtime_language // TODO: find this enum + None, // vtable_holder + "", // unique_id + ) + .as_type()) + } + + /// Get a DWARF type record for a LLVM data type, + /// creating it if it does not yet exist. + fn get_basic_di_type(&mut self, llvm_ty: BasicMetadataTypeEnum<'c>) -> Result> { + let name = llvm_ty.print_to_string(); + if let Some(di_ty) = self.type_map.get(name.deref()) { + return Ok(*di_ty); + } + + let new_di_ty = match llvm_ty { + BasicMetadataTypeEnum::ArrayType(arr_ty) => self.create_di_arr_type(arr_ty), + BasicMetadataTypeEnum::FloatType(flt_ty) => self.create_di_float_type(flt_ty), + BasicMetadataTypeEnum::IntType(int_ty) => self.create_di_int_type(int_ty), + BasicMetadataTypeEnum::StructType(struct_ty) => self.create_di_struct_type(struct_ty), + BasicMetadataTypeEnum::PointerType(_) => Ok(self.ptr_type), + _ => Err(anyhow!( + "Type not supported by get_basic_di_type: {llvm_ty:#}" + )), + }?; + + if self + .type_map + .insert(name.deref().into(), new_di_ty) + .is_some() + { + Err(anyhow!("Duplicate DI type")) + } else { + Ok(new_di_ty) + } + } + + fn create_di_function_type( + &mut self, + fty: FunctionType<'c>, + fn_file: DIFile<'c>, + ) -> Result> { + let name = fty.print_to_string(); + if let Some(di_fty) = self.fn_type_map.get(name.deref()) { + return Ok(*di_fty); + } + + let ret_ty = fty.get_return_type().map_or(Ok(None), |llvm_ty| { + Some(self.get_basic_di_type(llvm_ty.into())).transpose() + }); + let arg_tys: Result> = fty + .get_param_types() + .iter() + .map(|llvm_ty| self.get_basic_di_type(*llvm_ty)) + .collect(); + let new_di_fty = + self.builder + .create_subroutine_type(fn_file, ret_ty?, arg_tys?.as_slice(), 0); + + if self + .fn_type_map + .insert(name.deref().into(), new_di_fty) + .is_some() + { + Err(anyhow!("Duplicate DI function type")) + } else { + Ok(new_di_fty) + } + } + + /// Common logic for creating function debug info + fn add_di_func( + &mut self, + func: FunctionValue<'c>, + file: DIFile<'c>, + lno: u32, + scope_lno: u32, + ) -> Result<()> { + if func.get_subprogram().is_some() { + return Err(anyhow!("Function already has debug record!")); + } + + let name = func + .get_name() + .to_str() + .expect("function names should be valid UTF-8"); + let di_fty = self.create_di_function_type(func.get_type(), file)?; + let is_local = func.get_linkage() != Linkage::External; + + let pretty_name = unmangle_hugr_func_name(name); + + let di_func = self.builder.create_function( + self.compile_unit.as_debug_info_scope(), + pretty_name, // name + Some(name), // linkage_name + file, + lno, + di_fty, + is_local, + // currently, hugr-llvm erases FuncDecls during lowering, + // so we will never emit a debug record for a declaration. + true, + scope_lno, + 0, + false, + ); + + func.set_subprogram(di_func); + Ok(()) + } + + /// If the FuncDefn/FuncDecl node has a HUGR debug record attached, + /// construct a corresponding DISubprogram and attach it to `llvm_func`. + /// It can be retrieved by calling `llvm_func.get_subprogram()`. + /// If no debug record is attached, do nothing. + pub fn try_add_di_func, OT>( + &mut self, + node: FatNode<'_, OT, H>, + func: FunctionValue<'c>, + ) -> Result<()> { + let maybe_record = try_get_debug_meta::<_, SubprogramRecord>(node.hugr(), node.node()) + .map_err(|e| anyhow!("Could not get subprogram record: {e}"))?; + let Some(record) = maybe_record else { + return Ok(()); + }; + + let di_file = self.get_di_file(record.file)?; + let lno_u32: u32 = record + .line_no + .try_into() + .map_err(|e| anyhow!("Invalid line_no: {} : {e}", record.line_no))?; + let scope_lno_u32: u32 = record + .scope_line + .try_into() + .map_err(|e| anyhow!("Invalid scope_line: {} : {e}", record.scope_line))?; + self.add_di_func(func, di_file, lno_u32, scope_lno_u32) + } + + /// Construct and attach a debug info record for a compiler-generated function and + /// set the location to a special placeholder value. This is needed if `func` calls + /// inlined functions with attached debug info, otherwise the + /// callees' debug information will be lost. + pub fn set_compiler_generated( + &mut self, + func: FunctionValue<'c>, + iw_ctx: &'c Context, + ir_builder: &Builder, + ) -> Result<()> { + self.add_di_func(func, self.compgen_file, 0, 0)?; + let loc = self.builder.create_debug_location( + iw_ctx, + self.num_compgen, + 0, + func.get_subprogram().unwrap().as_debug_info_scope(), + None, + ); + self.set_debug_loc(ir_builder, loc)?; + self.num_compgen += 1; + Ok(()) + } + + /// If a node has an attached DILocation record, return Ok(Some(record)). + /// If the node has other debug info, return Err. + /// If there is no debug metadata attached, return Ok(None). + pub fn try_get_di_location>( + &self, + iw_context: &'c Context, + node: &FatNode<'_, OT, H>, + di_func: DISubprogram<'c>, + ) -> Result>> { + let maybe_record = try_get_debug_meta::<_, LocationRecord>(node.hugr(), node.node()) + .map_err(|e| anyhow!("Could not get location record: {e}"))?; + match maybe_record { + Some(record) => { + let lno_u32: u32 = record + .line_no + .try_into() + .map_err(|e| anyhow!("Invalid line_no: {} : {e}", record.line_no))?; + let col_u32: u32 = record + .column + .try_into() + .map_err(|e| anyhow!("Invalid column: {} : {e}", record.column))?; + Ok(Some(self.builder.create_debug_location( + iw_context, + lno_u32, + col_u32, + di_func.as_debug_info_scope(), + None, + ))) + } + None => Ok(None), + } + } + + /// Set the input location record as the IR builder's debug location. + /// Returns an error if the IR builder already has a debug location. + pub fn set_debug_loc(&mut self, ir_builder: &Builder, loc: DILocation<'c>) -> Result<()> { + if self.have_di_loc { + Err(anyhow!("Debug location is already set")) + } else { + ir_builder.set_current_debug_location(loc); + self.have_di_loc = true; + Ok(()) + } + } + + /// Clear the IR builder's current debug location. + /// Returns an error if the IR builder's debug location is not set. + pub fn unset_debug_loc(&mut self, ir_builder: &Builder) -> Result<()> { + if !self.have_di_loc { + Err(anyhow!("Debug location is already unset!")) + } else { + ir_builder.unset_current_debug_location(); + self.have_di_loc = false; + Ok(()) + } + } + + /// Finalize and drop the underlying DebugInfoBuilder + pub fn finish(self) { + self.builder.finalize(); + } +} + +/// We test debug info generation by adding random info to all HUGRs generated and compiled for other +/// hugr-llvm tests (see `exec_hugr` and `check_emission`). +#[cfg(any(test, feature = "test-utils"))] +pub mod test { + use super::*; + use hugr_core::{ + Hugr, envelope::description::GeneratorDesc, hugr::hugrmut::HugrMut, ops::OpType, + }; + use rand::{ + RngExt, SeedableRng, + distr::{Alphabetic, SampleString}, + rngs::SmallRng, + }; + + /// Fixed seed for random debug info + const RAND_DEBUGINFO_SEED: u64 = 0xfeabfaec; + /// Maximum length of a randomly-generated path component + const MAX_RAND_COMPONENT_LEN: usize = 32; + /// Maximum number of components in a randomly-generated path + const MAX_RAND_PATH_LEN: usize = 8; + /// Probability of creating a new random file path for a debug info entry + const NEW_RAND_FILE_PROB: f64 = 0.1; + /// Maximum random line number + const MAX_RAND_LNO: usize = 32768; + /// Maximum random column number + const MAX_RAND_COLNO: usize = 512; + + fn rand_path(rng: &mut SmallRng, suffix: &str) -> String { + let mut s = String::new(); + let ncomp = rng.random_range(1..MAX_RAND_PATH_LEN); + for _ in 1..ncomp { + s.push('/'); + let comp_len = rng.random_range(1..MAX_RAND_COMPONENT_LEN); + s.push_str(&Alphabetic.sample_string(rng, comp_len)) + } + s.push_str(suffix); + s + } + + /// Probabilistically get or create a random file and return its index in file_tab + fn rand_indexed_file(rng: &mut SmallRng, file_tab: &mut Vec) -> usize { + if file_tab.is_empty() || rng.random_bool(NEW_RAND_FILE_PROB) { + let i = file_tab.len(); + file_tab.push(rand_path(rng, ".gpy.py")); + i + } else { + rng.random_range(0..file_tab.len()) + } + } + + /// Add random, format-appropriate debug info to a node + fn node_random_debug_info( + hugr: &mut Hugr, + node: &Node, + rng: &mut SmallRng, + file_tab: &mut Vec, + ) { + // the root CompileUnit record is generated last, in the calling function + match hugr.get_optype(*node) { + OpType::FuncDefn(_) => { + let lno = rng.random_range(1..MAX_RAND_LNO); + hugr.set_metadata::( + *node, + SubprogramRecord { + kind: "subprogram".into(), + file: rand_indexed_file(rng, file_tab), + line_no: lno, + scope_line: lno + 1, + }, + ); + } + OpType::ExtensionOp(_) + | OpType::OpaqueOp(_) + | OpType::Call(_) + | OpType::CallIndirect(_) => { + hugr.set_metadata::( + *node, + LocationRecord { + kind: "location".into(), + column: rng.random_range(1..MAX_RAND_COLNO), + line_no: rng.random_range(1..MAX_RAND_LNO), + }, + ); + } + _ => (), + } + } + + /// Add random, format-appropriate debug info to a Hugr + /// This needs to be `pub` for non-crate callers of `emit::test::check_emission` + pub fn add_random_debug_info(hugr: &mut Hugr) { + let mut rng = SmallRng::seed_from_u64(RAND_DEBUGINFO_SEED); + let mut file_tab = Vec::new(); + let root = hugr.module_root(); + + let node_vec: Vec = hugr.nodes().collect(); + for node in node_vec.iter() { + node_random_debug_info(hugr, node, &mut rng, &mut file_tab); + } + + // need to populate the root metadata last, since it contains the file table. + hugr.set_metadata::( + root, + CompileUnitRecord { + kind: "compile_unit".into(), + directory: rand_path(&mut rng, ""), + filename: rand_indexed_file(&mut rng, &mut file_tab), + file_table: file_tab, + }, + ); + // debug info emission requires that a generator string is present + hugr.set_metadata::(root, GeneratorDesc::new_unversioned("hugr_llvm_test")); + } + + #[cfg(test)] + mod tests { + use super::*; + use crate::custom::CodegenExtsBuilder; + use crate::emit::test::{DFGW, Emission, SimpleHugrConfig}; + use crate::test::{TestContext, llvm_ctx}; + use crate::utils::fat::FatExt; + use hugr_core::HugrView; + use hugr_core::builder::{Dataflow, DataflowHugr}; + use hugr_core::hugr::hugrmut::HugrMut; + use hugr_core::metadata::DEBUGINFO_META_KEY; + use hugr_core::std_extensions::STD_REG; + use hugr_core::std_extensions::arithmetic::int_ops::IntOpDef; + use hugr_core::std_extensions::arithmetic::int_types::int_type; + use rstest::rstest; + + /// Build a HUGR with a simple integer add function, with all three supported + /// debug info record types attached: `CompileUnitRecord` on the module root, + /// `SubprogramRecord` on the `FuncDefn`, and `LocationRecord` on the `ExtensionOp`. + fn build_hugr_with_all_debug_info() -> Hugr { + let int64 = int_type(6); + let mut hugr = SimpleHugrConfig::new() + .with_ins([int64.clone(), int64.clone()]) + .with_outs([int64]) + .with_extensions(STD_REG.to_owned()) + .finish(|mut builder: DFGW| { + let [a, b] = builder.input_wires_arr(); + let add = builder + .add_dataflow_op(IntOpDef::iadd.with_log_width(6), [a, b]) + .unwrap(); + builder.finish_hugr_with_outputs(add.outputs()).unwrap() + }); + + let file_table = vec!["test_source.gpy.py".to_string()]; + let root = hugr.module_root(); + + let func_node = hugr + .children(root) + .find(|&n| matches!(hugr.get_optype(n), OpType::FuncDefn(_))) + .unwrap(); + hugr.set_metadata::( + func_node, + SubprogramRecord { + kind: "subprogram".into(), + file: 0, + line_no: 10, + scope_line: 10, + }, + ); + + let ext_op_node = hugr + .nodes() + .find(|&n| matches!(hugr.get_optype(n), OpType::ExtensionOp(_))) + .unwrap(); + hugr.set_metadata::( + ext_op_node, + LocationRecord { + kind: "location".into(), + line_no: 11, + column: 4, + }, + ); + + hugr.set_metadata::( + root, + CompileUnitRecord { + kind: "compile_unit".into(), + directory: "/test/src".to_string(), + filename: 0, + file_table, + }, + ); + hugr.set_metadata::( + root, + GeneratorDesc::new_unversioned("hugr_llvm_debug_test"), + ); + + hugr + } + + /// Test that a HUGR with all debug info record types compiles successfully + /// when debug info emission is enabled. + #[rstest] + fn test_debug_info_enabled(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let hugr = build_hugr_with_all_debug_info(); + let root = hugr.fat_root().unwrap(); + let emission = Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).unwrap(); + emission.verify().unwrap(); + } + + /// Test that a HUGR with all debug info record types compiles successfully + /// when debug info emission is disabled. + #[rstest] + fn test_debug_info_disabled(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let hugr = build_hugr_with_all_debug_info(); + let root = hugr.fat_root().unwrap(); + let emission = Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), false).unwrap(); + emission.verify().unwrap(); + } + + /// Test that compilation fails when a wrong debug info record type is attached + /// to the Module root node (SubprogramRecord instead of CompileUnitRecord). + #[rstest] + fn test_wrong_debug_info_on_module(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + // Replace the correct CompileUnitRecord with a SubprogramRecord + let root = hugr.module_root(); + hugr.set_metadata::( + root, + SubprogramRecord { + kind: "subprogram".into(), + file: 0, + line_no: 1, + scope_line: 1, + }, + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + + /// Test that compilation fails when a wrong debug info record type is attached + /// to a FuncDefn node (LocationRecord instead of SubprogramRecord). + #[rstest] + fn test_wrong_debug_info_on_funcdefn(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + // Replace the correct SubprogramRecord with a LocationRecord + let root = hugr.module_root(); + let func_node = hugr + .children(root) + .find(|&n| matches!(hugr.get_optype(n), OpType::FuncDefn(_))) + .unwrap(); + hugr.set_metadata::( + func_node, + LocationRecord { + kind: "location".into(), + line_no: 1, + column: 1, + }, + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + + /// Test that compilation fails when a wrong debug info record type is attached + /// to an ExtensionOp node (SubprogramRecord instead of LocationRecord). + #[rstest] + fn test_wrong_debug_info_on_extension_op(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + // Replace the correct LocationRecord with a SubprogramRecord + let ext_op_node = hugr + .nodes() + .find(|&n| matches!(hugr.get_optype(n), OpType::ExtensionOp(_))) + .unwrap(); + hugr.set_metadata::( + ext_op_node, + SubprogramRecord { + kind: "subprogram".into(), + file: 0, + line_no: 1, + scope_line: 1, + }, + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + + /// Test that compilation fails when invalid JSON (not matching CompileUnitRecord's + /// schema) is attached to the Module root node. + #[rstest] + fn test_invalid_json_on_module(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + let root = hugr.module_root(); + hugr.set_metadata_any( + root, + DEBUGINFO_META_KEY, + serde_json::json!({"not_a_valid_field": true}), + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + + /// Test that compilation fails when invalid JSON (not matching SubprogramRecord's + /// schema) is attached to a FuncDefn node. + #[rstest] + fn test_invalid_json_on_funcdefn(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + let root = hugr.module_root(); + let func_node = hugr + .children(root) + .find(|&n| matches!(hugr.get_optype(n), OpType::FuncDefn(_))) + .unwrap(); + hugr.set_metadata_any( + func_node, + DEBUGINFO_META_KEY, + serde_json::json!({"not_a_valid_field": true}), + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + + /// Test that `unmangle_hugr_func_name` correctly strips the prefix and suffix + /// components from a well-formed mangled name. + #[test] + fn test_unmangle_hugr_func_name_valid() { + // Basic form: __hugr__... + assert_eq!( + unmangle_hugr_func_name("__hugr__.my_module.my_func.0"), + "my_func" + ); + // Guppy identifier is a dotted path (multiple components between module and node ID) + assert_eq!( + unmangle_hugr_func_name("__hugr__.my_module.pkg.subpkg.my_func.0"), + "pkg.subpkg.my_func" + ); + // Module name with underscores and digits + assert_eq!( + unmangle_hugr_func_name("__hugr__.mod_1.foo.bar.42"), + "foo.bar" + ); + } + + /// Test that `unmangle_hugr_func_name` returns the original name unchanged when + /// the name is not in the expected form, even if it contains dots. + #[test] + fn test_unmangle_hugr_func_name_preserves_non_mangled() { + // No dots at all + assert_eq!(unmangle_hugr_func_name("plain_name"), "plain_name"); + // Only one dot — not enough components + assert_eq!(unmangle_hugr_func_name("a.b"), "a.b"); + // Two dots, but the middle section is empty so lpar+1 == rpar + assert_eq!(unmangle_hugr_func_name("a..b"), "a..b"); + // Exactly two dots — middle slice would be empty (lpar+1 == rpar) + assert_eq!(unmangle_hugr_func_name("a.b.c"), "a.b.c"); + } + + /// Test that compilation fails when invalid JSON (not matching LocationRecord's + /// schema) is attached to an ExtensionOp node. + #[rstest] + fn test_invalid_json_on_extension_op(mut llvm_ctx: TestContext) { + llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); + let mut hugr = build_hugr_with_all_debug_info(); + let ext_op_node = hugr + .nodes() + .find(|&n| matches!(hugr.get_optype(n), OpType::ExtensionOp(_))) + .unwrap(); + hugr.set_metadata_any( + ext_op_node, + DEBUGINFO_META_KEY, + serde_json::json!({"not_a_valid_field": true}), + ); + let root = hugr.fat_root().unwrap(); + assert!(Emission::emit_hugr(root, llvm_ctx.get_emit_hugr(), true).is_err()); + } + } +} diff --git a/hugr-llvm/src/emit/func.rs b/hugr-llvm/src/emit/func.rs index 5db6ac4aa4..ac24dc837f 100644 --- a/hugr-llvm/src/emit/func.rs +++ b/hugr-llvm/src/emit/func.rs @@ -17,6 +17,7 @@ use inkwell::{ }; use itertools::{Itertools, zip_eq}; +use crate::emit::debug_info::DebugInfoContext; use crate::types::{HugrFuncType, HugrSumType, HugrType, TypingSession}; use crate::{custom::CodegenExtsMap, types::LLVMSumType, utils::fat::FatNode}; use delegate::delegate; @@ -55,6 +56,7 @@ where builder: Builder<'c>, prologue_bb: BasicBlock<'c>, launch_bb: BasicBlock<'c>, + have_di_loc: bool, } impl<'c, 'a, H: HugrView> EmitFuncContext<'c, 'a, H> { @@ -102,6 +104,9 @@ impl<'c, 'a, H: HugrView> EmitFuncContext<'c, 'a, H> { /// If a global with the given name exists but the type or constant-ness /// does not match then an error will be returned. pub fn get_global(&self, symbol: impl AsRef, typ: impl BasicType<'c>, constant: bool) -> Result>; + /// Returns the [DebugInfoContext] for the module if it exists. + pub fn di_context(&self) -> Option<&DebugInfoContext<'c>>; + pub fn di_context_mut(&mut self) -> Option<&mut DebugInfoContext<'c>>; } } @@ -167,6 +172,7 @@ impl<'c, 'a, H: HugrView> EmitFuncContext<'c, 'a, H> { let launch_bb = emit_context .iw_context() .append_basic_block(func, "entry_block"); + let builder = emit_context.iw_context().create_builder(); builder.position_at_end(launch_bb); Ok(Self { @@ -177,6 +183,7 @@ impl<'c, 'a, H: HugrView> EmitFuncContext<'c, 'a, H> { builder, prologue_bb, launch_bb, + have_di_loc: false, }) } @@ -308,19 +315,61 @@ impl<'c, 'a, H: HugrView> EmitFuncContext<'c, 'a, H> { .emit_load_constant(self, v) } + /// If debug emission is enabled for the current function, + /// and the node contains location metadata, + /// set the builder's current debug location. + pub(crate) fn try_set_debug_loc<'hugr, OT>( + &mut self, + node: &FatNode<'hugr, OT, H>, + ) -> Result<()> { + let iw_ctx = self.emit_context.iw_context(); + let builder = &self.builder; + if let Some(di_func) = self.func.get_subprogram() { + let di_ctx = self.emit_context.di_context_mut().unwrap(); + let maybe_loc = di_ctx.try_get_di_location(iw_ctx, node, di_func)?; + + if let Some(loc) = maybe_loc { + di_ctx.set_debug_loc(builder, loc)?; + self.have_di_loc = true; + } + } + Ok(()) + } + + /// If `self.have_di_loc` is true, unset the current debug location. + /// Otherwise do nothing. + pub(crate) fn try_unset_debug_loc(&mut self) -> Result<()> { + if self.have_di_loc { + self.emit_context + .di_context_mut() + .unwrap() + .unset_debug_loc(&self.builder)?; + self.have_di_loc = false; + } + Ok(()) + } + pub(crate) fn emit_extension_op( &mut self, args: EmitOpArgs<'c, '_, ExtensionOp, H>, ) -> Result<()> { + self.try_set_debug_loc(&args.node)?; let exts = self.extensions(); exts.as_ref() .extension_op_handlers - .emit_extension_op(self, args) + .emit_extension_op(self, args)?; + self.try_unset_debug_loc() } /// Consumes the `EmitFuncContext` and returns both the inner /// [`EmitModuleContext`] and the scoped [`FuncDefn`]s that were encountered. pub fn finish(self) -> Result<(EmitModuleContext<'c, 'a, H>, EmissionSet)> { + if self.have_di_loc { + return Err(anyhow!( + "Should not have a debug location set at the end of a function!" + )); + } + self.builder.position_at_end(self.prologue_bb); self.builder.build_unconditional_branch(self.launch_bb)?; Ok((self.emit_context, self.todo)) diff --git a/hugr-llvm/src/emit/ops.rs b/hugr-llvm/src/emit/ops.rs index 435ab6ff92..d970379b50 100644 --- a/hugr-llvm/src/emit/ops.rs +++ b/hugr-llvm/src/emit/ops.rs @@ -236,6 +236,7 @@ fn emit_call<'c, H: HugrView>( if !args.node.called_function_type().params().is_empty() { return Err(anyhow!("Call of generic function")); } + context.try_set_debug_loc(&args.node)?; let (func_node, _) = args .node .single_linked_output(args.node.called_function_port()) @@ -249,7 +250,8 @@ fn emit_call<'c, H: HugrView>( let builder = context.builder(); let call = builder.build_call(func?, inputs.as_slice(), "")?; let call_results = deaggregate_call_result(builder, call, args.outputs.len())?; - args.outputs.finish(builder, call_results) + args.outputs.finish(context.builder(), call_results)?; + context.try_unset_debug_loc() } fn emit_call_indirect<'c, H: HugrView>( @@ -260,12 +262,14 @@ fn emit_call_indirect<'c, H: HugrView>( BasicValueEnum::PointerValue(v) => Ok(v), _ => Err(anyhow!("emit_call_indirect: Not a pointer")), }?; + context.try_set_debug_loc(&args.node)?; let func_ty = context.llvm_func_type(&args.node().signature)?; let inputs = args.inputs.into_iter().skip(1).map_into().collect_vec(); let builder = context.builder(); let call = builder.build_indirect_call(func_ty, func_ptr, inputs.as_slice(), "")?; let call_results = deaggregate_call_result(builder, call, args.outputs.len())?; - args.outputs.finish(builder, call_results) + args.outputs.finish(builder, call_results)?; + context.try_unset_debug_loc() } fn emit_load_function<'c, H: HugrView>( diff --git a/hugr-llvm/src/emit/ops/cfg.rs b/hugr-llvm/src/emit/ops/cfg.rs index 13888809a4..5f5797b4d3 100644 --- a/hugr-llvm/src/emit/ops/cfg.rs +++ b/hugr-llvm/src/emit/ops/cfg.rs @@ -239,7 +239,7 @@ mod test { llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); let t1 = INT_TYPES[0].clone(); let t2 = INT_TYPES[1].clone(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins([t1.clone(), t2.clone()]) .with_outs([t2.clone()]) .with_extensions(ExtensionRegistry::new([ @@ -288,7 +288,7 @@ mod test { #[rstest] fn nested(llvm_ctx: TestContext) { let t1 = HugrType::new_unit_sum(3); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![t1.clone(), bool_t()]) .with_outs([bool_t()]) .finish(|mut builder| { diff --git a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@llvm21.snap b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@llvm21.snap index 770b3bd6d5..4005c184ed 100644 --- a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@llvm21.snap +++ b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block @@ -15,8 +15,8 @@ entry_block: ; preds = %alloca_block 2: ; preds = %11, %entry_block %"7_0.0" = phi i8 [ %0, %entry_block ], [ %12, %11 ] %"7_1.0" = phi i8 [ %1, %entry_block ], [ %7, %11 ] - %3 = insertvalue { i8, i8 } poison, i8 %"7_0.0", 0 - %4 = insertvalue { i8, i8 } %3, i8 %"7_1.0", 1 + %3 = insertvalue { i8, i8 } poison, i8 %"7_0.0", 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %"7_1.0", 1, !dbg !8 switch i1 false, label %5 [ ] @@ -42,3 +42,16 @@ entry_block: ; preds = %alloca_block 14: ; preds = %13 ret i8 %7 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@pre-mem2reg@llvm21.snap index 75af16a73b..c17186b44b 100644 --- a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__diverse_outputs@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -36,9 +36,9 @@ entry_block: ; preds = %alloca_block store i8 %"7_15", ptr %"7_1", align 1 %"7_06" = load i8, ptr %"7_0", align 1 %"7_17" = load i8, ptr %"7_1", align 1 - %3 = insertvalue { i8, i8 } poison, i8 %"7_06", 0 - %4 = insertvalue { i8, i8 } %3, i8 %"7_17", 1 - store { i8, i8 } %4, ptr %"9_0", align 1 + %3 = insertvalue { i8, i8 } poison, i8 %"7_06", 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %"7_17", 1, !dbg !8 + store { i8, i8 } %4, ptr %"9_0", align 1, !dbg !8 %"9_08" = load { i8, i8 }, ptr %"9_0", align 1 store { i8, i8 } %"9_08", ptr %"9_0", align 1 %"9_09" = load { i8, i8 }, ptr %"9_0", align 1 @@ -89,3 +89,16 @@ entry_block: ; preds = %alloca_block %"019" = load i8, ptr %"0", align 1 ret i8 %"019" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@llvm21.snap b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@llvm21.snap index 8bcb038df5..b534be77cb 100644 --- a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@llvm21.snap +++ b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i2 %0, i1 %1) { +define internal i1 @_hl.main.1(i2 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block @@ -81,3 +81,16 @@ entry_block: ; preds = %alloca_block 20: ; preds = %18 br label %5 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@pre-mem2reg@llvm21.snap index ac3622fb8e..30f8bd6bb7 100644 --- a/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/ops/snapshots/hugr_llvm__emit__ops__cfg__test__nested@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i2 %0, i1 %1) { +define internal i1 @_hl.main.1(i2 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"5_0" = alloca {}, align 8 @@ -156,3 +156,16 @@ entry_block: ; preds = %alloca_block 20: ; preds = %18 br label %5 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@llvm21.snap index 21c5362e27..f8ce05158f 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1() { +define internal i1 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -22,3 +22,15 @@ entry_block: ; preds = %alloca_block 2: ; preds = %1 ret i1 false } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@pre-mem2reg@llvm21.snap index f28e7526d0..84b2855806 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_cfg_children@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1() { +define internal i1 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"4_0" = alloca i1, align 1 @@ -41,3 +41,15 @@ entry_block: ; preds = %alloca_block %"08" = load i1, ptr %"0", align 1 ret i1 %"08" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@llvm21.snap index b4d1d527f8..8bcf8c2824 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.f1.1() { +define internal void @_hl.f1.1() !dbg !3 { alloca_block: br label %entry_block @@ -13,10 +13,22 @@ entry_block: ; preds = %alloca_block ret void } -define internal void @_hl.f2.4() { +define internal void @_hl.f2.4() !dbg !7 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret void } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/PNzlVLClAphFGIyrhvZsHeD") +!3 = distinct !DISubprogram(name: "_hl.f1.1", linkageName: "_hl.f1.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = distinct !DISubprogram(name: "_hl.f2.4", linkageName: "_hl.f2.4", scope: null, file: !4, line: 25761, type: !5, scopeLine: 25762, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@pre-mem2reg@llvm21.snap index b4d1d527f8..8bcf8c2824 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__diverse_module_children@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.f1.1() { +define internal void @_hl.f1.1() !dbg !3 { alloca_block: br label %entry_block @@ -13,10 +13,22 @@ entry_block: ; preds = %alloca_block ret void } -define internal void @_hl.f2.4() { +define internal void @_hl.f2.4() !dbg !7 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret void } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/PNzlVLClAphFGIyrhvZsHeD") +!3 = distinct !DISubprogram(name: "_hl.f1.1", linkageName: "_hl.f1.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = distinct !DISubprogram(name: "_hl.f2.4", linkageName: "_hl.f2.4", scope: null, file: !4, line: 25761, type: !5, scopeLine: 25762, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@llvm21.snap index c63d58848c..57e3480127 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@llvm21.snap @@ -5,33 +5,55 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define void @_hl.main_void.1() { +define void @_hl.main_void.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - call void @_hl.main_void.1() + call void @_hl.main_void.1(), !dbg !7 ret void } -define i1 @_hl.main_unary.5(i1 %0) { +define i1 @_hl.main_unary.5(i1 %0) !dbg !8 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = call i1 @_hl.main_unary.5(i1 %0) + %1 = call i1 @_hl.main_unary.5(i1 %0), !dbg !12 ret i1 %1 } -define { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1) { +define { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1) !dbg !13 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = call { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1) - %3 = extractvalue { i1, i1 } %2, 0 - %4 = extractvalue { i1, i1 } %2, 1 + %2 = call { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1), !dbg !17 + %3 = extractvalue { i1, i1 } %2, 0, !dbg !17 + %4 = extractvalue { i1, i1 } %2, 1, !dbg !17 %mrv = insertvalue { i1, i1 } poison, i1 %3, 0 %mrv7 = insertvalue { i1, i1 } %mrv, i1 %4, 1 ret { i1, i1 } %mrv7 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/p/FGIyrhvZsHeDgUnyeIVw/u/KJHaZEPSZwPXPeycUvnujGxZKPRC/cNfsTEGLoPGC") +!3 = distinct !DISubprogram(name: "_hl.main_void.1", linkageName: "_hl.main_void.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = distinct !DISubprogram(name: "_hl.main_unary.5", linkageName: "_hl.main_unary.5", scope: null, file: !4, line: 25884, type: !9, scopeLine: 25885, spFlags: DISPFlagDefinition, unit: !1) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 8376, column: 157, scope: !8) +!13 = distinct !DISubprogram(name: "_hl.main_binary.9", linkageName: "_hl.main_binary.9", scope: null, file: !4, line: 32551, type: !14, scopeLine: 32552, spFlags: DISPFlagDefinition, unit: !1) +!14 = !DISubroutineType(types: !15) +!15 = !{!16, !11, !11} +!16 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !10) +!17 = !DILocation(line: 1712, column: 109, scope: !13) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@pre-mem2reg@llvm21.snap index 3fd254daae..b185b5c762 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call@pre-mem2reg@llvm21.snap @@ -5,16 +5,16 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define void @_hl.main_void.1() { +define void @_hl.main_void.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - call void @_hl.main_void.1() + call void @_hl.main_void.1(), !dbg !7 ret void } -define i1 @_hl.main_unary.5(i1 %0) { +define i1 @_hl.main_unary.5(i1 %0) !dbg !8 { alloca_block: %"0" = alloca i1, align 1 %"6_0" = alloca i1, align 1 @@ -24,15 +24,15 @@ alloca_block: entry_block: ; preds = %alloca_block store i1 %0, ptr %"6_0", align 1 %"6_01" = load i1, ptr %"6_0", align 1 - %1 = call i1 @_hl.main_unary.5(i1 %"6_01") - store i1 %1, ptr %"8_0", align 1 + %1 = call i1 @_hl.main_unary.5(i1 %"6_01"), !dbg !12 + store i1 %1, ptr %"8_0", align 1, !dbg !12 %"8_02" = load i1, ptr %"8_0", align 1 store i1 %"8_02", ptr %"0", align 1 %"03" = load i1, ptr %"0", align 1 ret i1 %"03" } -define { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1) { +define { i1, i1 } @_hl.main_binary.9(i1 %0, i1 %1) !dbg !13 { alloca_block: %"0" = alloca i1, align 1 %"1" = alloca i1, align 1 @@ -47,11 +47,11 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"10_1", align 1 %"10_01" = load i1, ptr %"10_0", align 1 %"10_12" = load i1, ptr %"10_1", align 1 - %2 = call { i1, i1 } @_hl.main_binary.9(i1 %"10_01", i1 %"10_12") - %3 = extractvalue { i1, i1 } %2, 0 - %4 = extractvalue { i1, i1 } %2, 1 - store i1 %3, ptr %"12_0", align 1 - store i1 %4, ptr %"12_1", align 1 + %2 = call { i1, i1 } @_hl.main_binary.9(i1 %"10_01", i1 %"10_12"), !dbg !17 + %3 = extractvalue { i1, i1 } %2, 0, !dbg !17 + %4 = extractvalue { i1, i1 } %2, 1, !dbg !17 + store i1 %3, ptr %"12_0", align 1, !dbg !17 + store i1 %4, ptr %"12_1", align 1, !dbg !17 %"12_03" = load i1, ptr %"12_0", align 1 %"12_14" = load i1, ptr %"12_1", align 1 store i1 %"12_03", ptr %"0", align 1 @@ -62,3 +62,25 @@ entry_block: ; preds = %alloca_block %mrv7 = insertvalue { i1, i1 } %mrv, i1 %"16", 1 ret { i1, i1 } %mrv7 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/p/FGIyrhvZsHeDgUnyeIVw/u/KJHaZEPSZwPXPeycUvnujGxZKPRC/cNfsTEGLoPGC") +!3 = distinct !DISubprogram(name: "_hl.main_void.1", linkageName: "_hl.main_void.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = distinct !DISubprogram(name: "_hl.main_unary.5", linkageName: "_hl.main_unary.5", scope: null, file: !4, line: 25884, type: !9, scopeLine: 25885, spFlags: DISPFlagDefinition, unit: !1) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 8376, column: 157, scope: !8) +!13 = distinct !DISubprogram(name: "_hl.main_binary.9", linkageName: "_hl.main_binary.9", scope: null, file: !4, line: 32551, type: !14, scopeLine: 32552, spFlags: DISPFlagDefinition, unit: !1) +!14 = !DISubroutineType(types: !15) +!15 = !{!16, !11, !11} +!16 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !10) +!17 = !DILocation(line: 1712, column: 109, scope: !13) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@llvm21.snap index 38df029ca8..d846ca93a0 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@llvm21.snap @@ -5,33 +5,55 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define void @_hl.main_void.1() { +define void @_hl.main_void.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - call void @_hl.main_void.1() + call void @_hl.main_void.1(), !dbg !7 ret void } -define i1 @_hl.main_unary.6(i1 %0) { +define i1 @_hl.main_unary.6(i1 %0) !dbg !8 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = call i1 @_hl.main_unary.6(i1 %0) + %1 = call i1 @_hl.main_unary.6(i1 %0), !dbg !12 ret i1 %1 } -define { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1) { +define { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1) !dbg !13 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = call { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1) - %3 = extractvalue { i1, i1 } %2, 0 - %4 = extractvalue { i1, i1 } %2, 1 + %2 = call { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1), !dbg !17 + %3 = extractvalue { i1, i1 } %2, 0, !dbg !17 + %4 = extractvalue { i1, i1 } %2, 1, !dbg !17 %mrv = insertvalue { i1, i1 } poison, i1 %3, 0 %mrv8 = insertvalue { i1, i1 } %mrv, i1 %4, 1 ret { i1, i1 } %mrv8 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/p/FGIyrhvZsHeDgUnyeIVw/u/KJHaZEPSZwPXPeycUvnujGxZKPRC/cNfsTEGLoPGC") +!3 = distinct !DISubprogram(name: "_hl.main_void.1", linkageName: "_hl.main_void.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = distinct !DISubprogram(name: "_hl.main_unary.6", linkageName: "_hl.main_unary.6", scope: null, file: !4, line: 25884, type: !9, scopeLine: 25885, spFlags: DISPFlagDefinition, unit: !1) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 8376, column: 157, scope: !8) +!13 = distinct !DISubprogram(name: "_hl.main_binary.11", linkageName: "_hl.main_binary.11", scope: null, file: !4, line: 32551, type: !14, scopeLine: 32552, spFlags: DISPFlagDefinition, unit: !1) +!14 = !DISubroutineType(types: !15) +!15 = !{!16, !11, !11} +!16 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !10) +!17 = !DILocation(line: 1712, column: 109, scope: !13) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@pre-mem2reg@llvm21.snap index 92c164c1c6..50a7879b97 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_call_indirect@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define void @_hl.main_void.1() { +define void @_hl.main_void.1() !dbg !3 { alloca_block: %"4_0" = alloca ptr, align 8 br label %entry_block @@ -13,11 +13,11 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr @_hl.main_void.1, ptr %"4_0", align 8 %"4_01" = load ptr, ptr %"4_0", align 8 - call void %"4_01"() + call void %"4_01"(), !dbg !7 ret void } -define i1 @_hl.main_unary.6(i1 %0) { +define i1 @_hl.main_unary.6(i1 %0) !dbg !8 { alloca_block: %"0" = alloca i1, align 1 %"9_0" = alloca ptr, align 8 @@ -30,15 +30,15 @@ entry_block: ; preds = %alloca_block store i1 %0, ptr %"7_0", align 1 %"9_01" = load ptr, ptr %"9_0", align 8 %"7_02" = load i1, ptr %"7_0", align 1 - %1 = call i1 %"9_01"(i1 %"7_02") - store i1 %1, ptr %"10_0", align 1 + %1 = call i1 %"9_01"(i1 %"7_02"), !dbg !12 + store i1 %1, ptr %"10_0", align 1, !dbg !12 %"10_03" = load i1, ptr %"10_0", align 1 store i1 %"10_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } -define { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1) { +define { i1, i1 } @_hl.main_binary.11(i1 %0, i1 %1) !dbg !13 { alloca_block: %"0" = alloca i1, align 1 %"1" = alloca i1, align 1 @@ -56,11 +56,11 @@ entry_block: ; preds = %alloca_block %"14_01" = load ptr, ptr %"14_0", align 8 %"12_02" = load i1, ptr %"12_0", align 1 %"12_13" = load i1, ptr %"12_1", align 1 - %2 = call { i1, i1 } %"14_01"(i1 %"12_02", i1 %"12_13") - %3 = extractvalue { i1, i1 } %2, 0 - %4 = extractvalue { i1, i1 } %2, 1 - store i1 %3, ptr %"15_0", align 1 - store i1 %4, ptr %"15_1", align 1 + %2 = call { i1, i1 } %"14_01"(i1 %"12_02", i1 %"12_13"), !dbg !17 + %3 = extractvalue { i1, i1 } %2, 0, !dbg !17 + %4 = extractvalue { i1, i1 } %2, 1, !dbg !17 + store i1 %3, ptr %"15_0", align 1, !dbg !17 + store i1 %4, ptr %"15_1", align 1, !dbg !17 %"15_04" = load i1, ptr %"15_0", align 1 %"15_15" = load i1, ptr %"15_1", align 1 store i1 %"15_04", ptr %"0", align 1 @@ -71,3 +71,25 @@ entry_block: ; preds = %alloca_block %mrv8 = insertvalue { i1, i1 } %mrv, i1 %"17", 1 ret { i1, i1 } %mrv8 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/p/FGIyrhvZsHeDgUnyeIVw/u/KJHaZEPSZwPXPeycUvnujGxZKPRC/cNfsTEGLoPGC") +!3 = distinct !DISubprogram(name: "_hl.main_void.1", linkageName: "_hl.main_void.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = distinct !DISubprogram(name: "_hl.main_unary.6", linkageName: "_hl.main_unary.6", scope: null, file: !4, line: 25884, type: !9, scopeLine: 25885, spFlags: DISPFlagDefinition, unit: !1) +!9 = !DISubroutineType(types: !10) +!10 = !{!11, !11} +!11 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 8376, column: 157, scope: !8) +!13 = distinct !DISubprogram(name: "_hl.main_binary.11", linkageName: "_hl.main_binary.11", scope: null, file: !4, line: 32551, type: !14, scopeLine: 32552, spFlags: DISPFlagDefinition, unit: !1) +!14 = !DISubroutineType(types: !15) +!15 = !{!16, !11, !11} +!16 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !10) +!17 = !DILocation(line: 1712, column: 109, scope: !13) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@llvm21.snap index 8ee0b21899..b42bbded42 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { { i2, i2, i1 }, {} } @_hl.main.1({ i2, i2, i1 } %0, {} %1) { +define internal { { i2, i2, i1 }, {} } @_hl.main.1({ i2, i2, i1 } %0, {} %1) !dbg !3 { alloca_block: br label %entry_block @@ -44,3 +44,22 @@ cond_exit_4: ; preds = %cond_4_case_2, %con %mrv32 = insertvalue { { i2, i2, i1 }, {} } %mrv, {} %1, 1 ret { { i2, i2, i1 }, {} } %mrv32 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ { i2, i2, i1 }, {} }", file: !2, align: 8, elements: !8) +!8 = !{!9, !13} +!9 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i2, i2, i1 }", file: !2, align: 8, elements: !10) +!10 = !{!11, !11, !12} +!11 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !14) +!14 = !{} diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@pre-mem2reg@llvm21.snap index 2baed530ea..2d0b4b4f44 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_conditional@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { { i2, i2, i1 }, {} } @_hl.main.1({ i2, i2, i1 } %0, {} %1) { +define internal { { i2, i2, i1 }, {} } @_hl.main.1({ i2, i2, i1 } %0, {} %1) !dbg !3 { alloca_block: %"0" = alloca { i2, i2, i1 }, align 8 %"1" = alloca {}, align 8 @@ -116,3 +116,22 @@ cond_exit_4: ; preds = %cond_4_case_2, %con %mrv32 = insertvalue { { i2, i2, i1 }, {} } %mrv, {} %"131", 1 ret { { i2, i2, i1 }, {} } %mrv32 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ { i2, i2, i1 }, {} }", file: !2, align: 8, elements: !8) +!8 = !{!9, !13} +!9 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i2, i2, i1 }", file: !2, align: 8, elements: !10) +!10 = !{!11, !11, !12} +!11 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !14) +!14 = !{} diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@llvm21.snap index 32799b0dfd..185e9457f0 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i16 @_hl.main.1() { +define internal i16 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = add i16 -24, 24 + %0 = add i16 -24, 24, !dbg !8 ret i16 %0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@pre-mem2reg@llvm21.snap index a45f82a3dc..2061679159 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_custom_op@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i16 @_hl.main.1() { +define internal i16 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i16, align 2 %"7_0" = alloca i16, align 2 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store i16 -24, ptr %"5_0", align 2 %"5_01" = load i16, ptr %"5_0", align 2 %"7_02" = load i16, ptr %"7_0", align 2 - %0 = add i16 %"5_01", %"7_02" - store i16 %0, ptr %"8_0", align 2 + %0 = add i16 %"5_01", %"7_02", !dbg !8 + store i16 %0, ptr %"8_0", align 2, !dbg !8 %"8_03" = load i16, ptr %"8_0", align 2 store i16 %"8_03", ptr %"0", align 2 %"04" = load i16, ptr %"0", align 2 ret i16 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@llvm21.snap index 6faf298195..83e48ab116 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@llvm21.snap @@ -5,10 +5,23 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal {} @_hl.main.1({} %0) { +define internal {} @_hl.main.1({} %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret {} %0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !8) +!8 = !{} diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@pre-mem2reg@llvm21.snap index 34154dd947..209b109871 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_dfg@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal {} @_hl.main.1({} %0) { +define internal {} @_hl.main.1({} %0) !dbg !3 { alloca_block: %"0" = alloca {}, align 8 %"2_0" = alloca {}, align 8 @@ -24,3 +24,16 @@ entry_block: ; preds = %alloca_block %"04" = load {}, ptr %"0", align 1 ret {} %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !8) +!8 = !{} diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@llvm21.snap index 9cd8523690..d4d86350fa 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@llvm21.snap @@ -5,10 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i2, i16 } @_hl.main.1() { +define internal { i2, i16 } @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret { i2, i16 } { i2 -2, i16 -24 } } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i2, i16 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@pre-mem2reg@llvm21.snap index 8c9534b217..02c0b5be90 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_load_constant@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i2, i16 } @_hl.main.1() { +define internal { i2, i16 } @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca { i2, i16 }, align 8 %"5_0" = alloca { i2, i16 }, align 8 @@ -18,3 +18,18 @@ entry_block: ; preds = %alloca_block %"02" = load { i2, i16 }, ptr %"0", align 2 ret { i2, i16 } %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i2, i16 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@llvm21.snap index 704673a1d0..ea9840ff52 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i2 @_hl.main.1() { +define internal i2 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i2 1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@pre-mem2reg@llvm21.snap index 795d0bd4c9..5c44fc7185 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__emit_hugr_tag@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i2 @_hl.main.1() { +define internal i2 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i2, align 1 %"4_0" = alloca i2, align 1 @@ -18,3 +18,15 @@ entry_block: ; preds = %alloca_block %"02" = load i2, ptr %"0", align 1 ret i2 %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@llvm21.snap index 3674865e98..f5c62bdb0d 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.2() { +define internal ptr @_hl.main.2() !dbg !3 { alloca_block: br label %entry_block @@ -14,3 +14,15 @@ entry_block: ; preds = %alloca_block } declare void @_hl.target_func.1() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.2", linkageName: "_hl.main.2", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@pre-mem2reg@llvm21.snap index 0042ebf0d8..e0799f060c 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__load_function@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.2() { +define internal ptr @_hl.main.2() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -20,3 +20,15 @@ entry_block: ; preds = %alloca_block } declare void @_hl.target_func.1() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.2", linkageName: "_hl.main.2", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@llvm21.snap index fd487897e2..090601abf4 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -15,9 +15,9 @@ entry_block: ; preds = %alloca_block loop_body: ; preds = %8, %entry_block %"9_0.0" = phi i64 [ 3, %entry_block ], [ %9, %8 ] %"9_1.0" = phi i64 [ 7, %entry_block ], [ %0, %8 ] - %0 = mul i64 %"9_1.0", 2 - %1 = icmp eq i64 %"9_0.0", 0 - %2 = select i1 %1, i1 true, i1 false + %0 = mul i64 %"9_1.0", 2, !dbg !8 + %1 = icmp eq i64 %"9_0.0", 0, !dbg !9 + %2 = select i1 %1, i1 true, i1 false, !dbg !9 switch i1 %2, label %3 [ i1 true, label %4 ] @@ -32,7 +32,7 @@ loop_out: ; preds = %10 ret i64 %0 cond_17_case_0: ; preds = %3 - %5 = sub i64 %"9_0.0", 1 + %5 = sub i64 %"9_0.0", 1, !dbg !10 %6 = insertvalue { i1, i64 } { i1 false, i64 poison }, i64 %5, 1 br label %cond_exit_17 @@ -53,3 +53,18 @@ cond_exit_17: ; preds = %cond_17_case_1, %co 10: ; preds = %cond_exit_17 br label %loop_out } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 27062, column: 402, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@pre-mem2reg@llvm21.snap index 6c501582b4..fa9d180cdd 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"7_0" = alloca i64, align 8 @@ -47,13 +47,13 @@ loop_body: ; preds = %8, %entry_block store i64 %"9_14", ptr %"9_1", align 4 %"9_15" = load i64, ptr %"9_1", align 4 %"15_06" = load i64, ptr %"15_0", align 4 - %0 = mul i64 %"9_15", %"15_06" - store i64 %0, ptr %"16_0", align 4 + %0 = mul i64 %"9_15", %"15_06", !dbg !8 + store i64 %0, ptr %"16_0", align 4, !dbg !8 %"9_07" = load i64, ptr %"9_0", align 4 %"12_08" = load i64, ptr %"12_0", align 4 - %1 = icmp eq i64 %"9_07", %"12_08" - %2 = select i1 %1, i1 true, i1 false - store i1 %2, ptr %"13_0", align 1 + %1 = icmp eq i64 %"9_07", %"12_08", !dbg !9 + %2 = select i1 %1, i1 true, i1 false, !dbg !9 + store i1 %2, ptr %"13_0", align 1, !dbg !9 %"13_09" = load i1, ptr %"13_0", align 1 %"9_010" = load i64, ptr %"9_0", align 4 switch i1 %"13_09", label %3 [ @@ -80,8 +80,8 @@ cond_17_case_0: ; preds = %3 store i64 %"014", ptr %"20_0", align 4 %"20_015" = load i64, ptr %"20_0", align 4 %"23_016" = load i64, ptr %"23_0", align 4 - %5 = sub i64 %"20_015", %"23_016" - store i64 %5, ptr %"24_0", align 4 + %5 = sub i64 %"20_015", %"23_016", !dbg !10 + store i64 %5, ptr %"24_0", align 4, !dbg !10 %"24_017" = load i64, ptr %"24_0", align 4 %6 = insertvalue { i1, i64 } { i1 false, i64 poison }, i64 %"24_017", 1 store { i1, i64 } %6, ptr %"25_0", align 4 @@ -121,3 +121,18 @@ cond_exit_17: ; preds = %cond_17_case_1, %co store i64 %"16_025", ptr %"8_0", align 4 br label %loop_out } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 27062, column: 402, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@llvm21.snap index 1de16db276..7fdb41cf3b 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal {} @_hl.main.1(i64 %0) { +define internal {} @_hl.main.1(i64 %0) !dbg !3 { alloca_block: br label %entry_block @@ -30,3 +30,17 @@ loop_body: ; preds = %3, %entry_block loop_out: ; preds = %5 ret {} undef } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !8) +!8 = !{} +!9 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@pre-mem2reg@llvm21.snap b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@pre-mem2reg@llvm21.snap index 1f61e2c6ab..bb49f9a4bf 100644 --- a/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/emit/snapshots/hugr_llvm__emit__test__test_fns__tail_loop_simple@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal {} @_hl.main.1(i64 %0) { +define internal {} @_hl.main.1(i64 %0) !dbg !3 { alloca_block: %"0" = alloca {}, align 8 %"2_0" = alloca i64, align 8 @@ -49,3 +49,17 @@ loop_out: ; preds = %5 %"07" = load {}, ptr %"0", align 1 ret {} %"07" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{}", file: !2, align: 8, elements: !8) +!8 = !{} +!9 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/emit/test.rs b/hugr-llvm/src/emit/test.rs index 83c529655b..cf537471b4 100644 --- a/hugr-llvm/src/emit/test.rs +++ b/hugr-llvm/src/emit/test.rs @@ -19,6 +19,10 @@ use super::EmitHugr; mod panic_runtime; +// currently all our targets have the same pointer size. +// used for debug info. +const TEST_PTR_SIZE: u32 = 64; + #[allow(clippy::upper_case_acronyms)] pub type DFGW = DFGWrapper>>; @@ -38,8 +42,12 @@ impl<'c> Emission<'c> { pub fn emit_hugr<'a: 'c, H: HugrView>( hugr: FatNode<'c, hugr_core::ops::Module, H>, eh: EmitHugr<'c, 'a, H>, + emit_debug: bool, ) -> Result where { - let module = eh.emit_module(hugr)?.finish(); + let (module, maybe_di_ctx) = eh.emit_module(hugr, emit_debug, TEST_PTR_SIZE)?.finish(); + if let Some(di_ctx) = maybe_di_ctx { + di_ctx.finish(); + } Ok(Self { module }) } @@ -311,9 +319,11 @@ pub use insta; macro_rules! check_emission { // Call the macro with a snapshot name. ($snapshot_name:expr, $hugr: ident, $test_ctx:ident) => {{ + // We add random debug info to all test HUGRs for coverage. + $crate::emit::debug_info::test::add_random_debug_info(&mut $hugr); let root = $crate::utils::fat::FatExt::fat_root(&$hugr).unwrap(); let emission = - $crate::emit::test::Emission::emit_hugr(root, $test_ctx.get_emit_hugr()).unwrap(); + $crate::emit::test::Emission::emit_hugr(root, $test_ctx.get_emit_hugr(), true).unwrap(); let mut settings = $crate::emit::test::insta::Settings::clone_current(); let new_suffix = settings @@ -400,7 +410,7 @@ mod test_fns { use crate::test::*; #[rstest] fn emit_hugr_tag(llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([Type::new_unit_sum(3)]) .finish(|mut builder: DFGW| { let tag = builder @@ -416,7 +426,7 @@ mod test_fns { #[rstest] fn emit_hugr_dfg(llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins([Type::UNIT]) .with_outs([Type::UNIT]) .finish(|mut builder: DFGW| { @@ -434,7 +444,7 @@ mod test_fns { #[rstest] fn emit_hugr_conditional(llvm_ctx: TestContext) { - let hugr = { + let mut hugr = { let input_v_rows: Vec = (1..4).map(|n| [Type::new_unit_sum(n)].into()).collect_vec(); let output_v_rows = { @@ -487,7 +497,7 @@ mod test_fns { ConstInt::new_s(4, -24).unwrap().into(), ]); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([v.get_type()]) .with_extensions(STD_REG.to_owned()) .finish(|mut builder: DFGW| { @@ -512,7 +522,7 @@ mod test_fns { build_recursive(&mut mod_b, "main_void", type_row![]); build_recursive(&mut mod_b, "main_unary", vec![bool_t()].into()); build_recursive(&mut mod_b, "main_binary", vec![bool_t(), bool_t()].into()); - let hugr = mod_b.finish_hugr().unwrap(); + let mut hugr = mod_b.finish_hugr().unwrap(); check_emission!(hugr, llvm_ctx); } @@ -534,7 +544,7 @@ mod test_fns { build_recursive(&mut mod_b, "main_void", type_row![]); build_recursive(&mut mod_b, "main_unary", vec![bool_t()].into()); build_recursive(&mut mod_b, "main_binary", vec![bool_t(), bool_t()].into()); - let hugr = mod_b.finish_hugr().unwrap(); + let mut hugr = mod_b.finish_hugr().unwrap(); check_emission!(hugr, llvm_ctx); } @@ -544,7 +554,7 @@ mod test_fns { let v1 = ConstInt::new_s(4, -24).unwrap(); let v2 = ConstInt::new_s(4, 24).unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([v1.get_type()]) .with_extensions(STD_REG.to_owned()) .finish(|mut builder: DFGW| { @@ -573,7 +583,7 @@ mod test_fns { #[rstest] fn diverse_module_children(llvm_ctx: TestContext) { - let hugr = { + let mut hugr = { let mut builder = ModuleBuilder::new(); let _ = { let fbuilder = builder @@ -598,7 +608,7 @@ mod test_fns { #[rstest] fn diverse_cfg_children(llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([bool_t()]) .finish(|mut builder: DFGW| { let [r] = { @@ -623,7 +633,7 @@ mod test_fns { #[rstest] fn load_function(llvm_ctx: TestContext) { - let hugr = { + let mut hugr = { let mut builder = ModuleBuilder::new(); let target_sig = Signature::new_endo(type_row![]); let target_func = builder @@ -647,7 +657,7 @@ mod test_fns { #[rstest] fn tail_loop_simple(mut llvm_ctx: TestContext) { - let hugr = { + let mut hugr = { let just_input = usize_t(); let just_output = Type::UNIT; let input_v = TypeRow::from(vec![just_input.clone()]); @@ -807,7 +817,7 @@ mod test_fns { } #[rstest] - fn tail_loop(mut llvm_ctx: TestContext, #[with(3, 7)] terminal_loop: Hugr) { + fn tail_loop(mut llvm_ctx: TestContext, #[with(3, 7)] mut terminal_loop: Hugr) { llvm_ctx.add_extensions(CodegenExtsBuilder::add_default_int_extensions); check_emission!(terminal_loop, llvm_ctx); } diff --git a/hugr-llvm/src/extension/collections/array.rs b/hugr-llvm/src/extension/collections/array.rs index 7ca58b6e74..74b4d56bc9 100644 --- a/hugr-llvm/src/extension/collections/array.rs +++ b/hugr-llvm/src/extension/collections/array.rs @@ -966,7 +966,7 @@ mod test { #[rstest] fn emit_all_ops(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { build_all_array_ops(builder.dfg_builder_endo([]).unwrap()) @@ -983,7 +983,7 @@ mod test { #[rstest] fn emit_get(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -1002,7 +1002,7 @@ mod test { #[rstest] fn emit_clone(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -1022,7 +1022,7 @@ mod test { #[rstest] fn emit_array_value(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .with_outs(vec![array_type(2, usize_t())]) .finish(|mut builder| { diff --git a/hugr-llvm/src/extension/collections/borrow_array.rs b/hugr-llvm/src/extension/collections/borrow_array.rs index 6a1ec224e6..23d9887736 100644 --- a/hugr-llvm/src/extension/collections/borrow_array.rs +++ b/hugr-llvm/src/extension/collections/borrow_array.rs @@ -1737,7 +1737,7 @@ mod test { #[rstest] fn emit_all_ops(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { build_all_borrow_array_ops(builder.dfg_builder_endo([]).unwrap()) @@ -1754,7 +1754,7 @@ mod test { #[rstest] fn emit_get(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -1775,7 +1775,7 @@ mod test { #[rstest] fn emit_clone(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -1799,7 +1799,7 @@ mod test { #[rstest] fn emit_array_value(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .with_outs(vec![borrow_array_type(2, usize_t())]) .finish(|mut builder| { diff --git a/hugr-llvm/src/extension/collections/list.rs b/hugr-llvm/src/extension/collections/list.rs index 37e173ecac..7d8fb62de9 100644 --- a/hugr-llvm/src/extension/collections/list.rs +++ b/hugr-llvm/src/extension/collections/list.rs @@ -391,7 +391,7 @@ mod test { .unwrap(); let es = ExtensionRegistry::new([list::EXTENSION.to_owned(), prelude::PRELUDE.to_owned()]); es.validate().unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(ext_op.signature().input().clone()) .with_outs(ext_op.signature().output().clone()) .with_extensions(es) @@ -414,7 +414,7 @@ mod test { let es = ExtensionRegistry::new([list::EXTENSION.to_owned(), prelude::PRELUDE.to_owned()]); es.validate().unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![]) .with_outs(vec![list_type(elem_ty.clone())]) .with_extensions(es) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@llvm21.snap index 95021df4cd..2e2c22def6 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@llvm21.snap @@ -16,60 +16,60 @@ source_filename = "test_context" @4 = private unnamed_addr constant [37 x i8] c"Expected variant 1 but got variant 0\00", align 1 @prelude.panic_template.4 = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 1, ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 2, ptr %5, align 4 - %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %6) - %8 = insertvalue { ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, i64 } %8, i64 0, 1 - %10 = getelementptr inbounds i64, ptr %7, i64 0 - store i64 1, ptr %10, align 4 - %11 = getelementptr inbounds i64, ptr %7, i64 1 - store i64 2, ptr %11, align 4 - %array_ptr = extractvalue { ptr, i64 } %9, 0 - %array_offset = extractvalue { ptr, i64 } %9, 1 - %12 = add i64 %array_offset, 0 - %13 = getelementptr inbounds i64, ptr %array_ptr, i64 %12 - %14 = load i64, ptr %13, align 4 - %15 = add i64 %array_offset, 1 - %16 = getelementptr inbounds i64, ptr %array_ptr, i64 %15 - %17 = load i64, ptr %16, align 4 - %array_ptr9 = extractvalue { ptr, i64 } %3, 0 - %array_offset10 = extractvalue { ptr, i64 } %3, 1 - %18 = icmp ult i64 0, 2 - %19 = icmp ult i64 1, 2 - %20 = and i1 %18, %19 - br i1 %20, label %23, label %21 + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %1 = call ptr @malloc(i64 %0), !dbg !7 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !7 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !7 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !7 + store i64 1, ptr %4, align 4, !dbg !7 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !7 + store i64 2, ptr %5, align 4, !dbg !7 + %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %6), !dbg !8 + %8 = insertvalue { ptr, i64 } poison, ptr %7, 0, !dbg !8 + %9 = insertvalue { ptr, i64 } %8, i64 0, 1, !dbg !8 + %10 = getelementptr inbounds i64, ptr %7, i64 0, !dbg !8 + store i64 1, ptr %10, align 4, !dbg !8 + %11 = getelementptr inbounds i64, ptr %7, i64 1, !dbg !8 + store i64 2, ptr %11, align 4, !dbg !8 + %array_ptr = extractvalue { ptr, i64 } %9, 0, !dbg !9 + %array_offset = extractvalue { ptr, i64 } %9, 1, !dbg !9 + %12 = add i64 %array_offset, 0, !dbg !9 + %13 = getelementptr inbounds i64, ptr %array_ptr, i64 %12, !dbg !9 + %14 = load i64, ptr %13, align 4, !dbg !9 + %15 = add i64 %array_offset, 1, !dbg !9 + %16 = getelementptr inbounds i64, ptr %array_ptr, i64 %15, !dbg !9 + %17 = load i64, ptr %16, align 4, !dbg !9 + %array_ptr9 = extractvalue { ptr, i64 } %3, 0, !dbg !10 + %array_offset10 = extractvalue { ptr, i64 } %3, 1, !dbg !10 + %18 = icmp ult i64 0, 2, !dbg !10 + %19 = icmp ult i64 1, 2, !dbg !10 + %20 = and i1 %18, %19, !dbg !10 + br i1 %20, label %23, label %21, !dbg !10 21: ; preds = %entry_block - %22 = insertvalue { i1, { ptr, i64 } } { i1 false, { ptr, i64 } poison }, { ptr, i64 } %3, 1 - br label %31 + %22 = insertvalue { i1, { ptr, i64 } } { i1 false, { ptr, i64 } poison }, { ptr, i64 } %3, 1, !dbg !10 + br label %31, !dbg !10 23: ; preds = %entry_block - %24 = add i64 0, %array_offset10 - %25 = add i64 1, %array_offset10 - %26 = getelementptr inbounds i64, ptr %array_ptr9, i64 %24 - %27 = load i64, ptr %26, align 4 - %28 = getelementptr inbounds i64, ptr %array_ptr9, i64 %25 - %29 = load i64, ptr %28, align 4 - store i64 %29, ptr %26, align 4 - store i64 %27, ptr %28, align 4 - %30 = insertvalue { i1, { ptr, i64 } } { i1 true, { ptr, i64 } poison }, { ptr, i64 } %3, 1 - br label %31 + %24 = add i64 0, %array_offset10, !dbg !10 + %25 = add i64 1, %array_offset10, !dbg !10 + %26 = getelementptr inbounds i64, ptr %array_ptr9, i64 %24, !dbg !10 + %27 = load i64, ptr %26, align 4, !dbg !10 + %28 = getelementptr inbounds i64, ptr %array_ptr9, i64 %25, !dbg !10 + %29 = load i64, ptr %28, align 4, !dbg !10 + store i64 %29, ptr %26, align 4, !dbg !10 + store i64 %27, ptr %28, align 4, !dbg !10 + %30 = insertvalue { i1, { ptr, i64 } } { i1 true, { ptr, i64 } poison }, { ptr, i64 } %3, 1, !dbg !10 + br label %31, !dbg !10 31: ; preds = %21, %23 - %"0.0" = phi { i1, { ptr, i64 } } [ %30, %23 ], [ %22, %21 ] + %"0.0" = phi { i1, { ptr, i64 } } [ %30, %23 ], [ %22, %21 ], !dbg !10 %32 = extractvalue { i1, { ptr, i64 } } %"0.0", 0 switch i1 %32, label %33 [ i1 true, label %35 @@ -84,10 +84,10 @@ entry_block: ; preds = %alloca_block br label %cond_19_case_1 cond_19_case_0: ; preds = %33 - %37 = extractvalue { i32, ptr } { i32 1, ptr @0 }, 0 - %38 = extractvalue { i32, ptr } { i32 1, ptr @0 }, 1 - %39 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %37, ptr %38) - call void @abort() + %37 = extractvalue { i32, ptr } { i32 1, ptr @0 }, 0, !dbg !11 + %38 = extractvalue { i32, ptr } { i32 1, ptr @0 }, 1, !dbg !11 + %39 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %37, ptr %38), !dbg !11 + call void @abort(), !dbg !11 br label %cond_exit_19 cond_19_case_1: ; preds = %35 @@ -95,23 +95,23 @@ cond_19_case_1: ; preds = %35 cond_exit_19: ; preds = %cond_19_case_1, %cond_19_case_0 %"013.0" = phi { ptr, i64 } [ zeroinitializer, %cond_19_case_0 ], [ %36, %cond_19_case_1 ] - %array_ptr25 = extractvalue { ptr, i64 } %"013.0", 0 - %array_offset26 = extractvalue { ptr, i64 } %"013.0", 1 - %40 = icmp ult i64 0, 2 - br i1 %40, label %42, label %41 + %array_ptr25 = extractvalue { ptr, i64 } %"013.0", 0, !dbg !12 + %array_offset26 = extractvalue { ptr, i64 } %"013.0", 1, !dbg !12 + %40 = icmp ult i64 0, 2, !dbg !12 + br i1 %40, label %42, label %41, !dbg !12 41: ; preds = %cond_exit_19 - br label %47 + br label %47, !dbg !12 42: ; preds = %cond_exit_19 - %43 = add i64 0, %array_offset26 - %44 = getelementptr inbounds i64, ptr %array_ptr25, i64 %43 - %45 = load i64, ptr %44, align 4 - %46 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %45, 1 - br label %47 + %43 = add i64 0, %array_offset26, !dbg !12 + %44 = getelementptr inbounds i64, ptr %array_ptr25, i64 %43, !dbg !12 + %45 = load i64, ptr %44, align 4, !dbg !12 + %46 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %45, 1, !dbg !12 + br label %47, !dbg !12 47: ; preds = %41, %42 - %"027.0" = phi { i1, i64 } [ %46, %42 ], [ { i1 false, i64 poison }, %41 ] + %"027.0" = phi { i1, i64 } [ %46, %42 ], [ { i1 false, i64 poison }, %41 ], !dbg !12 %48 = extractvalue { i1, i64 } %"027.0", 0 switch i1 %48, label %49 [ i1 true, label %50 @@ -125,10 +125,10 @@ cond_exit_19: ; preds = %cond_19_case_1, %co br label %cond_31_case_1 cond_31_case_0: ; preds = %49 - %52 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 0 - %53 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 1 - %54 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %52, ptr %53) - call void @abort() + %52 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 0, !dbg !13 + %53 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 1, !dbg !13 + %54 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %52, ptr %53), !dbg !13 + call void @abort(), !dbg !13 br label %cond_exit_31 cond_31_case_1: ; preds = %50 @@ -136,27 +136,27 @@ cond_31_case_1: ; preds = %50 cond_exit_31: ; preds = %cond_31_case_1, %cond_31_case_0 %"031.0" = phi i64 [ 0, %cond_31_case_0 ], [ %51, %cond_31_case_1 ] - %array_ptr41 = extractvalue { ptr, i64 } %"013.0", 0 - %array_offset42 = extractvalue { ptr, i64 } %"013.0", 1 - %55 = icmp ult i64 1, 2 - br i1 %55, label %59, label %56 + %array_ptr41 = extractvalue { ptr, i64 } %"013.0", 0, !dbg !14 + %array_offset42 = extractvalue { ptr, i64 } %"013.0", 1, !dbg !14 + %55 = icmp ult i64 1, 2, !dbg !14 + br i1 %55, label %59, label %56, !dbg !14 56: ; preds = %cond_exit_31 - %57 = insertvalue { i1, { ptr, i64 }, i64 } { i1 false, { ptr, i64 } poison, i64 poison }, i64 %"031.0", 2 - %58 = insertvalue { i1, { ptr, i64 }, i64 } %57, { ptr, i64 } %"013.0", 1 - br label %65 + %57 = insertvalue { i1, { ptr, i64 }, i64 } { i1 false, { ptr, i64 } poison, i64 poison }, i64 %"031.0", 2, !dbg !14 + %58 = insertvalue { i1, { ptr, i64 }, i64 } %57, { ptr, i64 } %"013.0", 1, !dbg !14 + br label %65, !dbg !14 59: ; preds = %cond_exit_31 - %60 = add i64 1, %array_offset42 - %61 = getelementptr inbounds i64, ptr %array_ptr41, i64 %60 - %62 = load i64, ptr %61, align 4 - store i64 %"031.0", ptr %61, align 4 - %63 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %62, 2 - %64 = insertvalue { i1, { ptr, i64 }, i64 } %63, { ptr, i64 } %"013.0", 1 - br label %65 + %60 = add i64 1, %array_offset42, !dbg !14 + %61 = getelementptr inbounds i64, ptr %array_ptr41, i64 %60, !dbg !14 + %62 = load i64, ptr %61, align 4, !dbg !14 + store i64 %"031.0", ptr %61, align 4, !dbg !14 + %63 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %62, 2, !dbg !14 + %64 = insertvalue { i1, { ptr, i64 }, i64 } %63, { ptr, i64 } %"013.0", 1, !dbg !14 + br label %65, !dbg !14 65: ; preds = %56, %59 - %"043.0" = phi { i1, { ptr, i64 }, i64 } [ %64, %59 ], [ %58, %56 ] + %"043.0" = phi { i1, { ptr, i64 }, i64 } [ %64, %59 ], [ %58, %56 ], !dbg !14 %66 = extractvalue { i1, { ptr, i64 }, i64 } %"043.0", 0 switch i1 %66, label %67 [ i1 true, label %70 @@ -173,10 +173,10 @@ cond_exit_31: ; preds = %cond_31_case_1, %co br label %cond_42_case_1 cond_42_case_0: ; preds = %67 - %73 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 0 - %74 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 1 - %75 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %73, ptr %74) - call void @abort() + %73 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 0, !dbg !15 + %74 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 1, !dbg !15 + %75 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %73, ptr %74), !dbg !15 + call void @abort(), !dbg !15 br label %cond_exit_42 cond_42_case_1: ; preds = %70 @@ -185,15 +185,15 @@ cond_42_case_1: ; preds = %70 cond_exit_42: ; preds = %cond_42_case_1, %cond_42_case_0 %"046.0" = phi i64 [ 0, %cond_42_case_0 ], [ %71, %cond_42_case_1 ] %"147.0" = phi { ptr, i64 } [ zeroinitializer, %cond_42_case_0 ], [ %72, %cond_42_case_1 ] - %array_ptr66 = extractvalue { ptr, i64 } %"147.0", 0 - %array_offset67 = extractvalue { ptr, i64 } %"147.0", 1 - %new_offset = add i64 %array_offset67, 1 - %76 = getelementptr inbounds ptr, ptr %array_ptr66, i64 %array_offset67 - %77 = load i64, ptr %76, align 4 - %78 = insertvalue { ptr, i64 } poison, ptr %array_ptr66, 0 - %79 = insertvalue { ptr, i64 } %78, i64 %new_offset, 1 - %80 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %77, 2 - %81 = insertvalue { i1, { ptr, i64 }, i64 } %80, { ptr, i64 } %79, 1 + %array_ptr66 = extractvalue { ptr, i64 } %"147.0", 0, !dbg !16 + %array_offset67 = extractvalue { ptr, i64 } %"147.0", 1, !dbg !16 + %new_offset = add i64 %array_offset67, 1, !dbg !16 + %76 = getelementptr inbounds ptr, ptr %array_ptr66, i64 %array_offset67, !dbg !16 + %77 = load i64, ptr %76, align 4, !dbg !16 + %78 = insertvalue { ptr, i64 } poison, ptr %array_ptr66, 0, !dbg !16 + %79 = insertvalue { ptr, i64 } %78, i64 %new_offset, 1, !dbg !16 + %80 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %77, 2, !dbg !16 + %81 = insertvalue { i1, { ptr, i64 }, i64 } %80, { ptr, i64 } %79, 1, !dbg !16 %82 = extractvalue { i1, { ptr, i64 }, i64 } %81, 0 switch i1 %82, label %83 [ i1 true, label %84 @@ -208,10 +208,10 @@ cond_exit_42: ; preds = %cond_42_case_1, %co br label %cond_53_case_1 cond_53_case_0: ; preds = %83 - %87 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 0 - %88 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 1 - %89 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %87, ptr %88) - call void @abort() + %87 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 0, !dbg !17 + %88 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 1, !dbg !17 + %89 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %87, ptr %88), !dbg !17 + call void @abort(), !dbg !17 br label %cond_exit_53 cond_53_case_1: ; preds = %84 @@ -220,15 +220,15 @@ cond_53_case_1: ; preds = %84 cond_exit_53: ; preds = %cond_53_case_1, %cond_53_case_0 %"069.0" = phi i64 [ 0, %cond_53_case_0 ], [ %85, %cond_53_case_1 ] %"170.0" = phi { ptr, i64 } [ zeroinitializer, %cond_53_case_0 ], [ %86, %cond_53_case_1 ] - %array_ptr83 = extractvalue { ptr, i64 } %"170.0", 0 - %array_offset84 = extractvalue { ptr, i64 } %"170.0", 1 - %90 = add i64 %array_offset84, 0 - %91 = getelementptr inbounds ptr, ptr %array_ptr83, i64 %90 - %92 = load i64, ptr %91, align 4 - %93 = insertvalue { ptr, i64 } poison, ptr %array_ptr83, 0 - %94 = insertvalue { ptr, i64 } %93, i64 %array_offset84, 1 - %95 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %92, 2 - %96 = insertvalue { i1, { ptr, i64 }, i64 } %95, { ptr, i64 } %94, 1 + %array_ptr83 = extractvalue { ptr, i64 } %"170.0", 0, !dbg !18 + %array_offset84 = extractvalue { ptr, i64 } %"170.0", 1, !dbg !18 + %90 = add i64 %array_offset84, 0, !dbg !18 + %91 = getelementptr inbounds ptr, ptr %array_ptr83, i64 %90, !dbg !18 + %92 = load i64, ptr %91, align 4, !dbg !18 + %93 = insertvalue { ptr, i64 } poison, ptr %array_ptr83, 0, !dbg !18 + %94 = insertvalue { ptr, i64 } %93, i64 %array_offset84, 1, !dbg !18 + %95 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %92, 2, !dbg !18 + %96 = insertvalue { i1, { ptr, i64 }, i64 } %95, { ptr, i64 } %94, 1, !dbg !18 %97 = extractvalue { i1, { ptr, i64 }, i64 } %96, 0 switch i1 %97, label %98 [ i1 true, label %99 @@ -243,10 +243,10 @@ cond_exit_53: ; preds = %cond_53_case_1, %co br label %cond_64_case_1 cond_64_case_0: ; preds = %98 - %102 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 0 - %103 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 1 - %104 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %102, ptr %103) - call void @abort() + %102 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 0, !dbg !19 + %103 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 1, !dbg !19 + %104 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %102, ptr %103), !dbg !19 + call void @abort(), !dbg !19 br label %cond_exit_64 cond_64_case_1: ; preds = %99 @@ -255,9 +255,9 @@ cond_64_case_1: ; preds = %99 cond_exit_64: ; preds = %cond_64_case_1, %cond_64_case_0 %"086.0" = phi i64 [ 0, %cond_64_case_0 ], [ %100, %cond_64_case_1 ] %"187.0" = phi { ptr, i64 } [ zeroinitializer, %cond_64_case_0 ], [ %101, %cond_64_case_1 ] - %array_ptr100 = extractvalue { ptr, i64 } %"187.0", 0 - %array_offset101 = extractvalue { ptr, i64 } %"187.0", 1 - call void @free(ptr %array_ptr100) + %array_ptr100 = extractvalue { ptr, i64 } %"187.0", 0, !dbg !20 + %array_offset101 = extractvalue { ptr, i64 } %"187.0", 1, !dbg !20 + call void @free(ptr %array_ptr100), !dbg !20 ret void } @@ -268,3 +268,28 @@ declare i32 @printf(ptr, ...) declare void @abort() declare void @free(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/nyeIVwAutKJHa/EPSZwPXPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 10060, column: 368, scope: !3) +!8 = !DILocation(line: 27062, column: 402, scope: !3) +!9 = !DILocation(line: 5388, column: 404, scope: !3) +!10 = !DILocation(line: 32551, column: 131, scope: !3) +!11 = !DILocation(line: 13582, column: 372, scope: !3) +!12 = !DILocation(line: 1712, column: 109, scope: !3) +!13 = !DILocation(line: 352, column: 366, scope: !3) +!14 = !DILocation(line: 21129, column: 412, scope: !3) +!15 = !DILocation(line: 4112, column: 51, scope: !3) +!16 = !DILocation(line: 31810, column: 83, scope: !3) +!17 = !DILocation(line: 21101, column: 431, scope: !3) +!18 = !DILocation(line: 16173, column: 468, scope: !3) +!19 = !DILocation(line: 4687, column: 439, scope: !3) +!20 = !DILocation(line: 2116, column: 303, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@pre-mem2reg@llvm21.snap index 739b8cb94a..db1461e36c 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_all_ops@pre-mem2reg@llvm21.snap @@ -16,7 +16,7 @@ source_filename = "test_context" @4 = private unnamed_addr constant [37 x i8] c"Expected variant 1 but got variant 0\00", align 1 @prelude.panic_template.4 = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"12_0" = alloca i64, align 8 %"10_0" = alloca i64, align 8 @@ -26,7 +26,7 @@ alloca_block: %"14_1" = alloca i64, align 8 %"8_0" = alloca i64, align 8 %"18_0" = alloca { i1, { ptr, i64 } }, align 8 - %"0" = alloca { i1, { ptr, i64 } }, align 8 + %"0" = alloca { i1, { ptr, i64 } }, align 8, !dbg !7 %"19_0" = alloca { ptr, i64 }, align 8 %"013" = alloca { ptr, i64 }, align 8 %"015" = alloca { ptr, i64 }, align 8 @@ -37,8 +37,8 @@ alloca_block: %"27_0" = alloca { ptr, i64 }, align 8 %"29_0" = alloca { i1, i64 }, align 8 %"29_1" = alloca { ptr, i64 }, align 8 - %"027" = alloca { i1, i64 }, align 8 - %"1" = alloca { ptr, i64 }, align 8 + %"027" = alloca { i1, i64 }, align 8, !dbg !8 + %"1" = alloca { ptr, i64 }, align 8, !dbg !8 %"31_0" = alloca i64, align 8 %"031" = alloca i64, align 8 %"36_0" = alloca { i32, ptr }, align 8 @@ -46,7 +46,7 @@ alloca_block: %"035" = alloca i64, align 8 %"39_0" = alloca i64, align 8 %"41_0" = alloca { i1, { ptr, i64 }, i64 }, align 8 - %"043" = alloca { i1, { ptr, i64 }, i64 }, align 8 + %"043" = alloca { i1, { ptr, i64 }, i64 }, align 8, !dbg !9 %"42_0" = alloca i64, align 8 %"42_1" = alloca { ptr, i64 }, align 8 %"046" = alloca i64, align 8 @@ -93,69 +93,69 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"10_0", align 4 %"10_01" = load i64, ptr %"10_0", align 4 %"12_02" = load i64, ptr %"12_0", align 4 - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 %"10_01", ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 %"12_02", ptr %5, align 4 - store { ptr, i64 } %3, ptr %"15_0", align 8 + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !10 + %1 = call ptr @malloc(i64 %0), !dbg !10 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !10 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !10 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !10 + store i64 %"10_01", ptr %4, align 4, !dbg !10 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !10 + store i64 %"12_02", ptr %5, align 4, !dbg !10 + store { ptr, i64 } %3, ptr %"15_0", align 8, !dbg !10 %"10_03" = load i64, ptr %"10_0", align 4 %"12_04" = load i64, ptr %"12_0", align 4 - %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %6) - %8 = insertvalue { ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, i64 } %8, i64 0, 1 - %10 = getelementptr inbounds i64, ptr %7, i64 0 - store i64 %"10_03", ptr %10, align 4 - %11 = getelementptr inbounds i64, ptr %7, i64 1 - store i64 %"12_04", ptr %11, align 4 - store { ptr, i64 } %9, ptr %"13_0", align 8 + %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !11 + %7 = call ptr @malloc(i64 %6), !dbg !11 + %8 = insertvalue { ptr, i64 } poison, ptr %7, 0, !dbg !11 + %9 = insertvalue { ptr, i64 } %8, i64 0, 1, !dbg !11 + %10 = getelementptr inbounds i64, ptr %7, i64 0, !dbg !11 + store i64 %"10_03", ptr %10, align 4, !dbg !11 + %11 = getelementptr inbounds i64, ptr %7, i64 1, !dbg !11 + store i64 %"12_04", ptr %11, align 4, !dbg !11 + store { ptr, i64 } %9, ptr %"13_0", align 8, !dbg !11 %"13_05" = load { ptr, i64 }, ptr %"13_0", align 8 - %array_ptr = extractvalue { ptr, i64 } %"13_05", 0 - %array_offset = extractvalue { ptr, i64 } %"13_05", 1 - %12 = add i64 %array_offset, 0 - %13 = getelementptr inbounds i64, ptr %array_ptr, i64 %12 - %14 = load i64, ptr %13, align 4 - %15 = add i64 %array_offset, 1 - %16 = getelementptr inbounds i64, ptr %array_ptr, i64 %15 - %17 = load i64, ptr %16, align 4 - store i64 %14, ptr %"14_0", align 4 - store i64 %17, ptr %"14_1", align 4 + %array_ptr = extractvalue { ptr, i64 } %"13_05", 0, !dbg !12 + %array_offset = extractvalue { ptr, i64 } %"13_05", 1, !dbg !12 + %12 = add i64 %array_offset, 0, !dbg !12 + %13 = getelementptr inbounds i64, ptr %array_ptr, i64 %12, !dbg !12 + %14 = load i64, ptr %13, align 4, !dbg !12 + %15 = add i64 %array_offset, 1, !dbg !12 + %16 = getelementptr inbounds i64, ptr %array_ptr, i64 %15, !dbg !12 + %17 = load i64, ptr %16, align 4, !dbg !12 + store i64 %14, ptr %"14_0", align 4, !dbg !12 + store i64 %17, ptr %"14_1", align 4, !dbg !12 store i64 0, ptr %"8_0", align 4 %"15_06" = load { ptr, i64 }, ptr %"15_0", align 8 %"8_07" = load i64, ptr %"8_0", align 4 %"10_08" = load i64, ptr %"10_0", align 4 - %array_ptr9 = extractvalue { ptr, i64 } %"15_06", 0 - %array_offset10 = extractvalue { ptr, i64 } %"15_06", 1 - %18 = icmp ult i64 %"8_07", 2 - %19 = icmp ult i64 %"10_08", 2 - %20 = and i1 %18, %19 - br i1 %20, label %23, label %21 + %array_ptr9 = extractvalue { ptr, i64 } %"15_06", 0, !dbg !7 + %array_offset10 = extractvalue { ptr, i64 } %"15_06", 1, !dbg !7 + %18 = icmp ult i64 %"8_07", 2, !dbg !7 + %19 = icmp ult i64 %"10_08", 2, !dbg !7 + %20 = and i1 %18, %19, !dbg !7 + br i1 %20, label %23, label %21, !dbg !7 21: ; preds = %entry_block - %22 = insertvalue { i1, { ptr, i64 } } { i1 false, { ptr, i64 } poison }, { ptr, i64 } %"15_06", 1 - store { i1, { ptr, i64 } } %22, ptr %"0", align 8 - br label %31 + %22 = insertvalue { i1, { ptr, i64 } } { i1 false, { ptr, i64 } poison }, { ptr, i64 } %"15_06", 1, !dbg !7 + store { i1, { ptr, i64 } } %22, ptr %"0", align 8, !dbg !7 + br label %31, !dbg !7 23: ; preds = %entry_block - %24 = add i64 %"8_07", %array_offset10 - %25 = add i64 %"10_08", %array_offset10 - %26 = getelementptr inbounds i64, ptr %array_ptr9, i64 %24 - %27 = load i64, ptr %26, align 4 - %28 = getelementptr inbounds i64, ptr %array_ptr9, i64 %25 - %29 = load i64, ptr %28, align 4 - store i64 %29, ptr %26, align 4 - store i64 %27, ptr %28, align 4 - %30 = insertvalue { i1, { ptr, i64 } } { i1 true, { ptr, i64 } poison }, { ptr, i64 } %"15_06", 1 - store { i1, { ptr, i64 } } %30, ptr %"0", align 8 - br label %31 + %24 = add i64 %"8_07", %array_offset10, !dbg !7 + %25 = add i64 %"10_08", %array_offset10, !dbg !7 + %26 = getelementptr inbounds i64, ptr %array_ptr9, i64 %24, !dbg !7 + %27 = load i64, ptr %26, align 4, !dbg !7 + %28 = getelementptr inbounds i64, ptr %array_ptr9, i64 %25, !dbg !7 + %29 = load i64, ptr %28, align 4, !dbg !7 + store i64 %29, ptr %26, align 4, !dbg !7 + store i64 %27, ptr %28, align 4, !dbg !7 + %30 = insertvalue { i1, { ptr, i64 } } { i1 true, { ptr, i64 } poison }, { ptr, i64 } %"15_06", 1, !dbg !7 + store { i1, { ptr, i64 } } %30, ptr %"0", align 8, !dbg !7 + br label %31, !dbg !7 31: ; preds = %21, %23 - %"011" = load { i1, { ptr, i64 } }, ptr %"0", align 8 - store { i1, { ptr, i64 } } %"011", ptr %"18_0", align 8 + %"011" = load { i1, { ptr, i64 } }, ptr %"0", align 8, !dbg !7 + store { i1, { ptr, i64 } } %"011", ptr %"18_0", align 8, !dbg !7 %"18_012" = load { i1, { ptr, i64 } }, ptr %"18_0", align 8 %32 = extractvalue { i1, { ptr, i64 } } %"18_012", 0 switch i1 %32, label %33 [ @@ -178,11 +178,11 @@ cond_19_case_0: ; preds = %33 store { ptr, i64 } %"016", ptr %"21_0", align 8 %"24_017" = load { i32, ptr }, ptr %"24_0", align 8 %"21_018" = load { ptr, i64 }, ptr %"21_0", align 8 - %37 = extractvalue { i32, ptr } %"24_017", 0 - %38 = extractvalue { i32, ptr } %"24_017", 1 - %39 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %37, ptr %38) - call void @abort() - store { ptr, i64 } zeroinitializer, ptr %"25_0", align 8 + %37 = extractvalue { i32, ptr } %"24_017", 0, !dbg !13 + %38 = extractvalue { i32, ptr } %"24_017", 1, !dbg !13 + %39 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %37, ptr %38), !dbg !13 + call void @abort(), !dbg !13 + store { ptr, i64 } zeroinitializer, ptr %"25_0", align 8, !dbg !13 %"25_019" = load { ptr, i64 }, ptr %"25_0", align 8 store { ptr, i64 } %"25_019", ptr %"013", align 8 br label %cond_exit_19 @@ -199,30 +199,30 @@ cond_exit_19: ; preds = %cond_19_case_1, %co store { ptr, i64 } %"014", ptr %"19_0", align 8 %"19_023" = load { ptr, i64 }, ptr %"19_0", align 8 %"8_024" = load i64, ptr %"8_0", align 4 - %array_ptr25 = extractvalue { ptr, i64 } %"19_023", 0 - %array_offset26 = extractvalue { ptr, i64 } %"19_023", 1 - %40 = icmp ult i64 %"8_024", 2 - br i1 %40, label %42, label %41 + %array_ptr25 = extractvalue { ptr, i64 } %"19_023", 0, !dbg !8 + %array_offset26 = extractvalue { ptr, i64 } %"19_023", 1, !dbg !8 + %40 = icmp ult i64 %"8_024", 2, !dbg !8 + br i1 %40, label %42, label %41, !dbg !8 41: ; preds = %cond_exit_19 - store { i1, i64 } { i1 false, i64 poison }, ptr %"027", align 4 - store { ptr, i64 } %"19_023", ptr %"1", align 8 - br label %47 + store { i1, i64 } { i1 false, i64 poison }, ptr %"027", align 4, !dbg !8 + store { ptr, i64 } %"19_023", ptr %"1", align 8, !dbg !8 + br label %47, !dbg !8 42: ; preds = %cond_exit_19 - %43 = add i64 %"8_024", %array_offset26 - %44 = getelementptr inbounds i64, ptr %array_ptr25, i64 %43 - %45 = load i64, ptr %44, align 4 - %46 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %45, 1 - store { i1, i64 } %46, ptr %"027", align 4 - store { ptr, i64 } %"19_023", ptr %"1", align 8 - br label %47 + %43 = add i64 %"8_024", %array_offset26, !dbg !8 + %44 = getelementptr inbounds i64, ptr %array_ptr25, i64 %43, !dbg !8 + %45 = load i64, ptr %44, align 4, !dbg !8 + %46 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %45, 1, !dbg !8 + store { i1, i64 } %46, ptr %"027", align 4, !dbg !8 + store { ptr, i64 } %"19_023", ptr %"1", align 8, !dbg !8 + br label %47, !dbg !8 47: ; preds = %41, %42 - %"028" = load { i1, i64 }, ptr %"027", align 4 - %"129" = load { ptr, i64 }, ptr %"1", align 8 - store { i1, i64 } %"028", ptr %"29_0", align 4 - store { ptr, i64 } %"129", ptr %"29_1", align 8 + %"028" = load { i1, i64 }, ptr %"027", align 4, !dbg !8 + %"129" = load { ptr, i64 }, ptr %"1", align 8, !dbg !8 + store { i1, i64 } %"028", ptr %"29_0", align 4, !dbg !8 + store { ptr, i64 } %"129", ptr %"29_1", align 8, !dbg !8 %"29_030" = load { i1, i64 }, ptr %"29_0", align 4 %48 = extractvalue { i1, i64 } %"29_030", 0 switch i1 %48, label %49 [ @@ -240,11 +240,11 @@ cond_exit_19: ; preds = %cond_19_case_1, %co cond_31_case_0: ; preds = %49 store { i32, ptr } { i32 1, ptr @1 }, ptr %"36_0", align 8 %"36_033" = load { i32, ptr }, ptr %"36_0", align 8 - %52 = extractvalue { i32, ptr } %"36_033", 0 - %53 = extractvalue { i32, ptr } %"36_033", 1 - %54 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %52, ptr %53) - call void @abort() - store i64 0, ptr %"37_0", align 4 + %52 = extractvalue { i32, ptr } %"36_033", 0, !dbg !14 + %53 = extractvalue { i32, ptr } %"36_033", 1, !dbg !14 + %54 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %52, ptr %53), !dbg !14 + call void @abort(), !dbg !14 + store i64 0, ptr %"37_0", align 4, !dbg !14 %"37_034" = load i64, ptr %"37_0", align 4 store i64 %"37_034", ptr %"031", align 4 br label %cond_exit_31 @@ -262,30 +262,30 @@ cond_exit_31: ; preds = %cond_31_case_1, %co %"29_138" = load { ptr, i64 }, ptr %"29_1", align 8 %"10_039" = load i64, ptr %"10_0", align 4 %"31_040" = load i64, ptr %"31_0", align 4 - %array_ptr41 = extractvalue { ptr, i64 } %"29_138", 0 - %array_offset42 = extractvalue { ptr, i64 } %"29_138", 1 - %55 = icmp ult i64 %"10_039", 2 - br i1 %55, label %59, label %56 + %array_ptr41 = extractvalue { ptr, i64 } %"29_138", 0, !dbg !9 + %array_offset42 = extractvalue { ptr, i64 } %"29_138", 1, !dbg !9 + %55 = icmp ult i64 %"10_039", 2, !dbg !9 + br i1 %55, label %59, label %56, !dbg !9 56: ; preds = %cond_exit_31 - %57 = insertvalue { i1, { ptr, i64 }, i64 } { i1 false, { ptr, i64 } poison, i64 poison }, i64 %"31_040", 2 - %58 = insertvalue { i1, { ptr, i64 }, i64 } %57, { ptr, i64 } %"29_138", 1 - store { i1, { ptr, i64 }, i64 } %58, ptr %"043", align 8 - br label %65 + %57 = insertvalue { i1, { ptr, i64 }, i64 } { i1 false, { ptr, i64 } poison, i64 poison }, i64 %"31_040", 2, !dbg !9 + %58 = insertvalue { i1, { ptr, i64 }, i64 } %57, { ptr, i64 } %"29_138", 1, !dbg !9 + store { i1, { ptr, i64 }, i64 } %58, ptr %"043", align 8, !dbg !9 + br label %65, !dbg !9 59: ; preds = %cond_exit_31 - %60 = add i64 %"10_039", %array_offset42 - %61 = getelementptr inbounds i64, ptr %array_ptr41, i64 %60 - %62 = load i64, ptr %61, align 4 - store i64 %"31_040", ptr %61, align 4 - %63 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %62, 2 - %64 = insertvalue { i1, { ptr, i64 }, i64 } %63, { ptr, i64 } %"29_138", 1 - store { i1, { ptr, i64 }, i64 } %64, ptr %"043", align 8 - br label %65 + %60 = add i64 %"10_039", %array_offset42, !dbg !9 + %61 = getelementptr inbounds i64, ptr %array_ptr41, i64 %60, !dbg !9 + %62 = load i64, ptr %61, align 4, !dbg !9 + store i64 %"31_040", ptr %61, align 4, !dbg !9 + %63 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %62, 2, !dbg !9 + %64 = insertvalue { i1, { ptr, i64 }, i64 } %63, { ptr, i64 } %"29_138", 1, !dbg !9 + store { i1, { ptr, i64 }, i64 } %64, ptr %"043", align 8, !dbg !9 + br label %65, !dbg !9 65: ; preds = %56, %59 - %"044" = load { i1, { ptr, i64 }, i64 }, ptr %"043", align 8 - store { i1, { ptr, i64 }, i64 } %"044", ptr %"41_0", align 8 + %"044" = load { i1, { ptr, i64 }, i64 }, ptr %"043", align 8, !dbg !9 + store { i1, { ptr, i64 }, i64 } %"044", ptr %"41_0", align 8, !dbg !9 %"41_045" = load { i1, { ptr, i64 }, i64 }, ptr %"41_0", align 8 %66 = extractvalue { i1, { ptr, i64 }, i64 } %"41_045", 0 switch i1 %66, label %67 [ @@ -315,12 +315,12 @@ cond_42_case_0: ; preds = %67 %"47_054" = load { i32, ptr }, ptr %"47_0", align 8 %"44_055" = load i64, ptr %"44_0", align 4 %"44_156" = load { ptr, i64 }, ptr %"44_1", align 8 - %73 = extractvalue { i32, ptr } %"47_054", 0 - %74 = extractvalue { i32, ptr } %"47_054", 1 - %75 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %73, ptr %74) - call void @abort() - store i64 0, ptr %"48_0", align 4 - store { ptr, i64 } zeroinitializer, ptr %"48_1", align 8 + %73 = extractvalue { i32, ptr } %"47_054", 0, !dbg !15 + %74 = extractvalue { i32, ptr } %"47_054", 1, !dbg !15 + %75 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %73, ptr %74), !dbg !15 + call void @abort(), !dbg !15 + store i64 0, ptr %"48_0", align 4, !dbg !15 + store { ptr, i64 } zeroinitializer, ptr %"48_1", align 8, !dbg !15 %"48_057" = load i64, ptr %"48_0", align 4 %"48_158" = load { ptr, i64 }, ptr %"48_1", align 8 store i64 %"48_057", ptr %"046", align 4 @@ -344,16 +344,16 @@ cond_exit_42: ; preds = %cond_42_case_1, %co store i64 %"048", ptr %"42_0", align 4 store { ptr, i64 } %"149", ptr %"42_1", align 8 %"42_165" = load { ptr, i64 }, ptr %"42_1", align 8 - %array_ptr66 = extractvalue { ptr, i64 } %"42_165", 0 - %array_offset67 = extractvalue { ptr, i64 } %"42_165", 1 - %new_offset = add i64 %array_offset67, 1 - %76 = getelementptr inbounds ptr, ptr %array_ptr66, i64 %array_offset67 - %77 = load i64, ptr %76, align 4 - %78 = insertvalue { ptr, i64 } poison, ptr %array_ptr66, 0 - %79 = insertvalue { ptr, i64 } %78, i64 %new_offset, 1 - %80 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %77, 2 - %81 = insertvalue { i1, { ptr, i64 }, i64 } %80, { ptr, i64 } %79, 1 - store { i1, { ptr, i64 }, i64 } %81, ptr %"52_0", align 8 + %array_ptr66 = extractvalue { ptr, i64 } %"42_165", 0, !dbg !16 + %array_offset67 = extractvalue { ptr, i64 } %"42_165", 1, !dbg !16 + %new_offset = add i64 %array_offset67, 1, !dbg !16 + %76 = getelementptr inbounds ptr, ptr %array_ptr66, i64 %array_offset67, !dbg !16 + %77 = load i64, ptr %76, align 4, !dbg !16 + %78 = insertvalue { ptr, i64 } poison, ptr %array_ptr66, 0, !dbg !16 + %79 = insertvalue { ptr, i64 } %78, i64 %new_offset, 1, !dbg !16 + %80 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %77, 2, !dbg !16 + %81 = insertvalue { i1, { ptr, i64 }, i64 } %80, { ptr, i64 } %79, 1, !dbg !16 + store { i1, { ptr, i64 }, i64 } %81, ptr %"52_0", align 8, !dbg !16 %"52_068" = load { i1, { ptr, i64 }, i64 }, ptr %"52_0", align 8 %82 = extractvalue { i1, { ptr, i64 }, i64 } %"52_068", 0 switch i1 %82, label %83 [ @@ -373,12 +373,12 @@ cond_exit_42: ; preds = %cond_42_case_1, %co cond_53_case_0: ; preds = %83 store { i32, ptr } { i32 1, ptr @3 }, ptr %"58_0", align 8 %"58_073" = load { i32, ptr }, ptr %"58_0", align 8 - %87 = extractvalue { i32, ptr } %"58_073", 0 - %88 = extractvalue { i32, ptr } %"58_073", 1 - %89 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %87, ptr %88) - call void @abort() - store i64 0, ptr %"59_0", align 4 - store { ptr, i64 } zeroinitializer, ptr %"59_1", align 8 + %87 = extractvalue { i32, ptr } %"58_073", 0, !dbg !17 + %88 = extractvalue { i32, ptr } %"58_073", 1, !dbg !17 + %89 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %87, ptr %88), !dbg !17 + call void @abort(), !dbg !17 + store i64 0, ptr %"59_0", align 4, !dbg !17 + store { ptr, i64 } zeroinitializer, ptr %"59_1", align 8, !dbg !17 %"59_074" = load i64, ptr %"59_0", align 4 %"59_175" = load { ptr, i64 }, ptr %"59_1", align 8 store i64 %"59_074", ptr %"069", align 4 @@ -402,16 +402,16 @@ cond_exit_53: ; preds = %cond_53_case_1, %co store i64 %"071", ptr %"53_0", align 4 store { ptr, i64 } %"172", ptr %"53_1", align 8 %"53_182" = load { ptr, i64 }, ptr %"53_1", align 8 - %array_ptr83 = extractvalue { ptr, i64 } %"53_182", 0 - %array_offset84 = extractvalue { ptr, i64 } %"53_182", 1 - %90 = add i64 %array_offset84, 0 - %91 = getelementptr inbounds ptr, ptr %array_ptr83, i64 %90 - %92 = load i64, ptr %91, align 4 - %93 = insertvalue { ptr, i64 } poison, ptr %array_ptr83, 0 - %94 = insertvalue { ptr, i64 } %93, i64 %array_offset84, 1 - %95 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %92, 2 - %96 = insertvalue { i1, { ptr, i64 }, i64 } %95, { ptr, i64 } %94, 1 - store { i1, { ptr, i64 }, i64 } %96, ptr %"63_0", align 8 + %array_ptr83 = extractvalue { ptr, i64 } %"53_182", 0, !dbg !18 + %array_offset84 = extractvalue { ptr, i64 } %"53_182", 1, !dbg !18 + %90 = add i64 %array_offset84, 0, !dbg !18 + %91 = getelementptr inbounds ptr, ptr %array_ptr83, i64 %90, !dbg !18 + %92 = load i64, ptr %91, align 4, !dbg !18 + %93 = insertvalue { ptr, i64 } poison, ptr %array_ptr83, 0, !dbg !18 + %94 = insertvalue { ptr, i64 } %93, i64 %array_offset84, 1, !dbg !18 + %95 = insertvalue { i1, { ptr, i64 }, i64 } { i1 true, { ptr, i64 } poison, i64 poison }, i64 %92, 2, !dbg !18 + %96 = insertvalue { i1, { ptr, i64 }, i64 } %95, { ptr, i64 } %94, 1, !dbg !18 + store { i1, { ptr, i64 }, i64 } %96, ptr %"63_0", align 8, !dbg !18 %"63_085" = load { i1, { ptr, i64 }, i64 }, ptr %"63_0", align 8 %97 = extractvalue { i1, { ptr, i64 }, i64 } %"63_085", 0 switch i1 %97, label %98 [ @@ -431,12 +431,12 @@ cond_exit_53: ; preds = %cond_53_case_1, %co cond_64_case_0: ; preds = %98 store { i32, ptr } { i32 1, ptr @4 }, ptr %"69_0", align 8 %"69_090" = load { i32, ptr }, ptr %"69_0", align 8 - %102 = extractvalue { i32, ptr } %"69_090", 0 - %103 = extractvalue { i32, ptr } %"69_090", 1 - %104 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %102, ptr %103) - call void @abort() - store i64 0, ptr %"70_0", align 4 - store { ptr, i64 } zeroinitializer, ptr %"70_1", align 8 + %102 = extractvalue { i32, ptr } %"69_090", 0, !dbg !19 + %103 = extractvalue { i32, ptr } %"69_090", 1, !dbg !19 + %104 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %102, ptr %103), !dbg !19 + call void @abort(), !dbg !19 + store i64 0, ptr %"70_0", align 4, !dbg !19 + store { ptr, i64 } zeroinitializer, ptr %"70_1", align 8, !dbg !19 %"70_091" = load i64, ptr %"70_0", align 4 %"70_192" = load { ptr, i64 }, ptr %"70_1", align 8 store i64 %"70_091", ptr %"086", align 4 @@ -460,9 +460,9 @@ cond_exit_64: ; preds = %cond_64_case_1, %co store i64 %"088", ptr %"64_0", align 4 store { ptr, i64 } %"189", ptr %"64_1", align 8 %"64_199" = load { ptr, i64 }, ptr %"64_1", align 8 - %array_ptr100 = extractvalue { ptr, i64 } %"64_199", 0 - %array_offset101 = extractvalue { ptr, i64 } %"64_199", 1 - call void @free(ptr %array_ptr100) + %array_ptr100 = extractvalue { ptr, i64 } %"64_199", 0, !dbg !20 + %array_offset101 = extractvalue { ptr, i64 } %"64_199", 1, !dbg !20 + call void @free(ptr %array_ptr100), !dbg !20 ret void } @@ -473,3 +473,28 @@ declare i32 @printf(ptr, ...) declare void @abort() declare void @free(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/nyeIVwAutKJHa/EPSZwPXPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 32551, column: 131, scope: !3) +!8 = !DILocation(line: 1712, column: 109, scope: !3) +!9 = !DILocation(line: 21129, column: 412, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) +!11 = !DILocation(line: 27062, column: 402, scope: !3) +!12 = !DILocation(line: 5388, column: 404, scope: !3) +!13 = !DILocation(line: 13582, column: 372, scope: !3) +!14 = !DILocation(line: 352, column: 366, scope: !3) +!15 = !DILocation(line: 4112, column: 51, scope: !3) +!16 = !DILocation(line: 31810, column: 83, scope: !3) +!17 = !DILocation(line: 21101, column: 431, scope: !3) +!18 = !DILocation(line: 16173, column: 468, scope: !3) +!19 = !DILocation(line: 4687, column: 439, scope: !3) +!20 = !DILocation(line: 2116, column: 303, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@llvm21.snap index 27d251b8e2..1f64ea9300 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, i64 } @_hl.main.1() { +define internal { ptr, i64 } @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -22,3 +22,18 @@ entry_block: ; preds = %alloca_block } declare ptr @malloc(i64) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, i64 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@pre-mem2reg@llvm21.snap index 59d8781c09..fb1fbe350e 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_array_value@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, i64 } @_hl.main.1() { +define internal { ptr, i64 } @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca { ptr, i64 }, align 8 %"5_0" = alloca { ptr, i64 }, align 8 @@ -28,3 +28,18 @@ entry_block: ; preds = %alloca_block } declare ptr @malloc(i64) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, i64 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@llvm21.snap index a0510362cb..c82f49aa6c 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@llvm21.snap @@ -5,32 +5,32 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 1, ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 2, ptr %5, align 4 - %array_ptr = extractvalue { ptr, i64 } %3, 0 - %array_offset = extractvalue { ptr, i64 } %3, 1 - %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %6) - %8 = insertvalue { ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, i64 } %8, i64 0, 1 - %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset - %11 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %10, i64 %11, i1 false) - %array_ptr5 = extractvalue { ptr, i64 } %9, 0 - call void @free(ptr %array_ptr5) - %array_ptr7 = extractvalue { ptr, i64 } %3, 0 - call void @free(ptr %array_ptr7) + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %1 = call ptr @malloc(i64 %0), !dbg !7 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !7 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !7 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !7 + store i64 1, ptr %4, align 4, !dbg !7 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !7 + store i64 2, ptr %5, align 4, !dbg !7 + %array_ptr = extractvalue { ptr, i64 } %3, 0, !dbg !8 + %array_offset = extractvalue { ptr, i64 } %3, 1, !dbg !8 + %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %6), !dbg !8 + %8 = insertvalue { ptr, i64 } poison, ptr %7, 0, !dbg !8 + %9 = insertvalue { ptr, i64 } %8, i64 0, 1, !dbg !8 + %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset, !dbg !8 + %11 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %10, i64 %11, i1 false), !dbg !8 + %array_ptr5 = extractvalue { ptr, i64 } %9, 0, !dbg !9 + call void @free(ptr %array_ptr5), !dbg !9 + %array_ptr7 = extractvalue { ptr, i64 } %3, 0, !dbg !10 + call void @free(ptr %array_ptr7), !dbg !10 ret void } @@ -42,3 +42,18 @@ declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr no declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/LClAphFGIyrhv/sHeDgUnyeIVwAutK/HaZEPS/wPXPeycUvnujGxZK/RCTcNfsTEG") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 32551, column: 131, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@pre-mem2reg@llvm21.snap index 9d3e894149..92d9933f6c 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_clone@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"7_0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 @@ -19,33 +19,33 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load i64, ptr %"7_0", align 4 - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 %"5_01", ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 %"7_02", ptr %5, align 4 - store { ptr, i64 } %3, ptr %"8_0", align 8 + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %1 = call ptr @malloc(i64 %0), !dbg !7 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !7 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !7 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !7 + store i64 %"5_01", ptr %4, align 4, !dbg !7 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !7 + store i64 %"7_02", ptr %5, align 4, !dbg !7 + store { ptr, i64 } %3, ptr %"8_0", align 8, !dbg !7 %"8_03" = load { ptr, i64 }, ptr %"8_0", align 8 - %array_ptr = extractvalue { ptr, i64 } %"8_03", 0 - %array_offset = extractvalue { ptr, i64 } %"8_03", 1 - %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %6) - %8 = insertvalue { ptr, i64 } poison, ptr %7, 0 - %9 = insertvalue { ptr, i64 } %8, i64 0, 1 - %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset - %11 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %10, i64 %11, i1 false) - store { ptr, i64 } %"8_03", ptr %"9_0", align 8 - store { ptr, i64 } %9, ptr %"9_1", align 8 + %array_ptr = extractvalue { ptr, i64 } %"8_03", 0, !dbg !8 + %array_offset = extractvalue { ptr, i64 } %"8_03", 1, !dbg !8 + %6 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %6), !dbg !8 + %8 = insertvalue { ptr, i64 } poison, ptr %7, 0, !dbg !8 + %9 = insertvalue { ptr, i64 } %8, i64 0, 1, !dbg !8 + %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset, !dbg !8 + %11 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %10, i64 %11, i1 false), !dbg !8 + store { ptr, i64 } %"8_03", ptr %"9_0", align 8, !dbg !8 + store { ptr, i64 } %9, ptr %"9_1", align 8, !dbg !8 %"9_14" = load { ptr, i64 }, ptr %"9_1", align 8 - %array_ptr5 = extractvalue { ptr, i64 } %"9_14", 0 - call void @free(ptr %array_ptr5) + %array_ptr5 = extractvalue { ptr, i64 } %"9_14", 0, !dbg !9 + call void @free(ptr %array_ptr5), !dbg !9 %"9_06" = load { ptr, i64 }, ptr %"9_0", align 8 - %array_ptr7 = extractvalue { ptr, i64 } %"9_06", 0 - call void @free(ptr %array_ptr7) + %array_ptr7 = extractvalue { ptr, i64 } %"9_06", 0, !dbg !10 + call void @free(ptr %array_ptr7), !dbg !10 ret void } @@ -57,3 +57,18 @@ declare void @llvm.memcpy.p0.p0.i64(ptr noalias writeonly captures(none), ptr no declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/LClAphFGIyrhv/sHeDgUnyeIVwAutK/HaZEPS/wPXPeycUvnujGxZK/RCTcNfsTEG") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 32551, column: 131, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@llvm21.snap index 129f7df482..6fb5208a92 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@llvm21.snap @@ -5,41 +5,55 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 1, ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 2, ptr %5, align 4 - %array_ptr = extractvalue { ptr, i64 } %3, 0 - %array_offset = extractvalue { ptr, i64 } %3, 1 - %6 = icmp ult i64 1, 2 - br i1 %6, label %8, label %7 + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %1 = call ptr @malloc(i64 %0), !dbg !7 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !7 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !7 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !7 + store i64 1, ptr %4, align 4, !dbg !7 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !7 + store i64 2, ptr %5, align 4, !dbg !7 + %array_ptr = extractvalue { ptr, i64 } %3, 0, !dbg !8 + %array_offset = extractvalue { ptr, i64 } %3, 1, !dbg !8 + %6 = icmp ult i64 1, 2, !dbg !8 + br i1 %6, label %8, label %7, !dbg !8 7: ; preds = %entry_block - br label %13 + br label %13, !dbg !8 8: ; preds = %entry_block - %9 = add i64 1, %array_offset - %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %9 - %11 = load i64, ptr %10, align 4 - %12 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %11, 1 - br label %13 + %9 = add i64 1, %array_offset, !dbg !8 + %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %9, !dbg !8 + %11 = load i64, ptr %10, align 4, !dbg !8 + %12 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %11, 1, !dbg !8 + br label %13, !dbg !8 13: ; preds = %7, %8 - %"0.0" = phi { i1, i64 } [ %12, %8 ], [ { i1 false, i64 poison }, %7 ] - %array_ptr8 = extractvalue { ptr, i64 } %3, 0 - call void @free(ptr %array_ptr8) + %"0.0" = phi { i1, i64 } [ %12, %8 ], [ { i1 false, i64 poison }, %7 ], !dbg !8 + %array_ptr8 = extractvalue { ptr, i64 } %3, 0, !dbg !9 + call void @free(ptr %array_ptr8), !dbg !9 ret void } declare ptr @malloc(i64) declare void @free(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@pre-mem2reg@llvm21.snap index b940a4ccd4..bcba30ac47 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__array__test__emit_get@pre-mem2reg@llvm21.snap @@ -5,15 +5,15 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"7_0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 %"8_0" = alloca { ptr, i64 }, align 8 %"9_0" = alloca { i1, i64 }, align 8 %"9_1" = alloca { ptr, i64 }, align 8 - %"0" = alloca { i1, i64 }, align 8 - %"1" = alloca { ptr, i64 }, align 8 + %"0" = alloca { i1, i64 }, align 8, !dbg !7 + %"1" = alloca { ptr, i64 }, align 8, !dbg !7 br label %entry_block entry_block: ; preds = %alloca_block @@ -21,47 +21,61 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load i64, ptr %"7_0", align 4 - %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %1 = call ptr @malloc(i64 %0) - %2 = insertvalue { ptr, i64 } poison, ptr %1, 0 - %3 = insertvalue { ptr, i64 } %2, i64 0, 1 - %4 = getelementptr inbounds i64, ptr %1, i64 0 - store i64 %"5_01", ptr %4, align 4 - %5 = getelementptr inbounds i64, ptr %1, i64 1 - store i64 %"7_02", ptr %5, align 4 - store { ptr, i64 } %3, ptr %"8_0", align 8 + %0 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %1 = call ptr @malloc(i64 %0), !dbg !8 + %2 = insertvalue { ptr, i64 } poison, ptr %1, 0, !dbg !8 + %3 = insertvalue { ptr, i64 } %2, i64 0, 1, !dbg !8 + %4 = getelementptr inbounds i64, ptr %1, i64 0, !dbg !8 + store i64 %"5_01", ptr %4, align 4, !dbg !8 + %5 = getelementptr inbounds i64, ptr %1, i64 1, !dbg !8 + store i64 %"7_02", ptr %5, align 4, !dbg !8 + store { ptr, i64 } %3, ptr %"8_0", align 8, !dbg !8 %"8_03" = load { ptr, i64 }, ptr %"8_0", align 8 %"5_04" = load i64, ptr %"5_0", align 4 - %array_ptr = extractvalue { ptr, i64 } %"8_03", 0 - %array_offset = extractvalue { ptr, i64 } %"8_03", 1 - %6 = icmp ult i64 %"5_04", 2 - br i1 %6, label %8, label %7 + %array_ptr = extractvalue { ptr, i64 } %"8_03", 0, !dbg !7 + %array_offset = extractvalue { ptr, i64 } %"8_03", 1, !dbg !7 + %6 = icmp ult i64 %"5_04", 2, !dbg !7 + br i1 %6, label %8, label %7, !dbg !7 7: ; preds = %entry_block - store { i1, i64 } { i1 false, i64 poison }, ptr %"0", align 4 - store { ptr, i64 } %"8_03", ptr %"1", align 8 - br label %13 + store { i1, i64 } { i1 false, i64 poison }, ptr %"0", align 4, !dbg !7 + store { ptr, i64 } %"8_03", ptr %"1", align 8, !dbg !7 + br label %13, !dbg !7 8: ; preds = %entry_block - %9 = add i64 %"5_04", %array_offset - %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %9 - %11 = load i64, ptr %10, align 4 - %12 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %11, 1 - store { i1, i64 } %12, ptr %"0", align 4 - store { ptr, i64 } %"8_03", ptr %"1", align 8 - br label %13 + %9 = add i64 %"5_04", %array_offset, !dbg !7 + %10 = getelementptr inbounds i64, ptr %array_ptr, i64 %9, !dbg !7 + %11 = load i64, ptr %10, align 4, !dbg !7 + %12 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %11, 1, !dbg !7 + store { i1, i64 } %12, ptr %"0", align 4, !dbg !7 + store { ptr, i64 } %"8_03", ptr %"1", align 8, !dbg !7 + br label %13, !dbg !7 13: ; preds = %7, %8 - %"05" = load { i1, i64 }, ptr %"0", align 4 - %"16" = load { ptr, i64 }, ptr %"1", align 8 - store { i1, i64 } %"05", ptr %"9_0", align 4 - store { ptr, i64 } %"16", ptr %"9_1", align 8 + %"05" = load { i1, i64 }, ptr %"0", align 4, !dbg !7 + %"16" = load { ptr, i64 }, ptr %"1", align 8, !dbg !7 + store { i1, i64 } %"05", ptr %"9_0", align 4, !dbg !7 + store { ptr, i64 } %"16", ptr %"9_1", align 8, !dbg !7 %"9_17" = load { ptr, i64 }, ptr %"9_1", align 8 - %array_ptr8 = extractvalue { ptr, i64 } %"9_17", 0 - call void @free(ptr %array_ptr8) + %array_ptr8 = extractvalue { ptr, i64 } %"9_17", 0, !dbg !9 + call void @free(ptr %array_ptr8), !dbg !9 ret void } declare ptr @malloc(i64) declare void @free(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 5388, column: 404, scope: !3) +!8 = !DILocation(line: 27062, column: 402, scope: !3) +!9 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@llvm21.snap index 8466deef53..18eb6335c0 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@llvm21.snap @@ -18,72 +18,72 @@ source_filename = "test_context" @5 = private unnamed_addr constant [37 x i8] c"Expected variant 1 but got variant 0\00", align 1 @prelude.panic_template.5 = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 1, ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 2, ptr %6, align 4 - %array_size5 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %array_size5) - %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1 - %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2 - %12 = getelementptr inbounds i64, ptr %7, i64 0 - store i64 1, ptr %12, align 4 - %13 = getelementptr inbounds i64, ptr %7, i64 1 - store i64 2, ptr %13, align 4 - %array_ptr = extractvalue { ptr, ptr, i64 } %11, 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %11, 1 - %array_offset = extractvalue { ptr, ptr, i64 } %11, 2 - %14 = add i64 %array_offset, 0 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %14) - %15 = getelementptr inbounds i64, ptr %array_ptr, i64 %14 - %16 = load i64, ptr %15, align 4 - %17 = add i64 %array_offset, 1 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %17) - %18 = getelementptr inbounds i64, ptr %array_ptr, i64 %17 - %19 = load i64, ptr %18, align 4 - %array_ptr10 = extractvalue { ptr, ptr, i64 } %4, 0 - %array_mask_ptr11 = extractvalue { ptr, ptr, i64 } %4, 1 - %array_offset12 = extractvalue { ptr, ptr, i64 } %4, 2 - %20 = icmp ult i64 0, 2 - %21 = icmp ult i64 1, 2 - %22 = and i1 %20, %21 - br i1 %22, label %25, label %23 + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %0 = call ptr @malloc(i64 %array_size), !dbg !7 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !7 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !7 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !7 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !7 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !7 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !7 + store i64 1, ptr %5, align 4, !dbg !7 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !7 + store i64 2, ptr %6, align 4, !dbg !7 + %array_size5 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %array_size5), !dbg !8 + %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !8 + call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !8 + %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0, !dbg !8 + %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1, !dbg !8 + %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2, !dbg !8 + %12 = getelementptr inbounds i64, ptr %7, i64 0, !dbg !8 + store i64 1, ptr %12, align 4, !dbg !8 + %13 = getelementptr inbounds i64, ptr %7, i64 1, !dbg !8 + store i64 2, ptr %13, align 4, !dbg !8 + %array_ptr = extractvalue { ptr, ptr, i64 } %11, 0, !dbg !9 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %11, 1, !dbg !9 + %array_offset = extractvalue { ptr, ptr, i64 } %11, 2, !dbg !9 + %14 = add i64 %array_offset, 0, !dbg !9 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %14), !dbg !9 + %15 = getelementptr inbounds i64, ptr %array_ptr, i64 %14, !dbg !9 + %16 = load i64, ptr %15, align 4, !dbg !9 + %17 = add i64 %array_offset, 1, !dbg !9 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %17), !dbg !9 + %18 = getelementptr inbounds i64, ptr %array_ptr, i64 %17, !dbg !9 + %19 = load i64, ptr %18, align 4, !dbg !9 + %array_ptr10 = extractvalue { ptr, ptr, i64 } %4, 0, !dbg !10 + %array_mask_ptr11 = extractvalue { ptr, ptr, i64 } %4, 1, !dbg !10 + %array_offset12 = extractvalue { ptr, ptr, i64 } %4, 2, !dbg !10 + %20 = icmp ult i64 0, 2, !dbg !10 + %21 = icmp ult i64 1, 2, !dbg !10 + %22 = and i1 %20, %21, !dbg !10 + br i1 %22, label %25, label %23, !dbg !10 23: ; preds = %entry_block - %24 = insertvalue { i1, { ptr, ptr, i64 } } { i1 false, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %4, 1 - br label %33 + %24 = insertvalue { i1, { ptr, ptr, i64 } } { i1 false, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %4, 1, !dbg !10 + br label %33, !dbg !10 25: ; preds = %entry_block - %26 = add i64 0, %array_offset12 - %27 = add i64 1, %array_offset12 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %26) - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %27) - %28 = getelementptr inbounds i64, ptr %array_ptr10, i64 %26 - %29 = load i64, ptr %28, align 4 - %30 = getelementptr inbounds i64, ptr %array_ptr10, i64 %27 - %31 = load i64, ptr %30, align 4 - store i64 %31, ptr %28, align 4 - store i64 %29, ptr %30, align 4 - %32 = insertvalue { i1, { ptr, ptr, i64 } } { i1 true, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %4, 1 - br label %33 + %26 = add i64 0, %array_offset12, !dbg !10 + %27 = add i64 1, %array_offset12, !dbg !10 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %26), !dbg !10 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %27), !dbg !10 + %28 = getelementptr inbounds i64, ptr %array_ptr10, i64 %26, !dbg !10 + %29 = load i64, ptr %28, align 4, !dbg !10 + %30 = getelementptr inbounds i64, ptr %array_ptr10, i64 %27, !dbg !10 + %31 = load i64, ptr %30, align 4, !dbg !10 + store i64 %31, ptr %28, align 4, !dbg !10 + store i64 %29, ptr %30, align 4, !dbg !10 + %32 = insertvalue { i1, { ptr, ptr, i64 } } { i1 true, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %4, 1, !dbg !10 + br label %33, !dbg !10 33: ; preds = %23, %25 - %"0.0" = phi { i1, { ptr, ptr, i64 } } [ %32, %25 ], [ %24, %23 ] + %"0.0" = phi { i1, { ptr, ptr, i64 } } [ %32, %25 ], [ %24, %23 ], !dbg !10 %34 = extractvalue { i1, { ptr, ptr, i64 } } %"0.0", 0 switch i1 %34, label %35 [ i1 true, label %37 @@ -98,10 +98,10 @@ entry_block: ; preds = %alloca_block br label %cond_19_case_1 cond_19_case_0: ; preds = %35 - %39 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 0 - %40 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 1 - %41 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %39, ptr %40) - call void @abort() + %39 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 0, !dbg !11 + %40 = extractvalue { i32, ptr } { i32 1, ptr @1 }, 1, !dbg !11 + %41 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %39, ptr %40), !dbg !11 + call void @abort(), !dbg !11 br label %cond_exit_19 cond_19_case_1: ; preds = %37 @@ -109,25 +109,25 @@ cond_19_case_1: ; preds = %37 cond_exit_19: ; preds = %cond_19_case_1, %cond_19_case_0 %"015.0" = phi { ptr, ptr, i64 } [ zeroinitializer, %cond_19_case_0 ], [ %38, %cond_19_case_1 ] - %array_ptr27 = extractvalue { ptr, ptr, i64 } %"015.0", 0 - %array_mask_ptr28 = extractvalue { ptr, ptr, i64 } %"015.0", 1 - %array_offset29 = extractvalue { ptr, ptr, i64 } %"015.0", 2 - %42 = icmp ult i64 0, 2 - br i1 %42, label %44, label %43 + %array_ptr27 = extractvalue { ptr, ptr, i64 } %"015.0", 0, !dbg !12 + %array_mask_ptr28 = extractvalue { ptr, ptr, i64 } %"015.0", 1, !dbg !12 + %array_offset29 = extractvalue { ptr, ptr, i64 } %"015.0", 2, !dbg !12 + %42 = icmp ult i64 0, 2, !dbg !12 + br i1 %42, label %44, label %43, !dbg !12 43: ; preds = %cond_exit_19 - br label %49 + br label %49, !dbg !12 44: ; preds = %cond_exit_19 - %45 = add i64 0, %array_offset29 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr28, i64 %45) - %46 = getelementptr inbounds i64, ptr %array_ptr27, i64 %45 - %47 = load i64, ptr %46, align 4 - %48 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %47, 1 - br label %49 + %45 = add i64 0, %array_offset29, !dbg !12 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr28, i64 %45), !dbg !12 + %46 = getelementptr inbounds i64, ptr %array_ptr27, i64 %45, !dbg !12 + %47 = load i64, ptr %46, align 4, !dbg !12 + %48 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %47, 1, !dbg !12 + br label %49, !dbg !12 49: ; preds = %43, %44 - %"030.0" = phi { i1, i64 } [ %48, %44 ], [ { i1 false, i64 poison }, %43 ] + %"030.0" = phi { i1, i64 } [ %48, %44 ], [ { i1 false, i64 poison }, %43 ], !dbg !12 %50 = extractvalue { i1, i64 } %"030.0", 0 switch i1 %50, label %51 [ i1 true, label %52 @@ -141,10 +141,10 @@ cond_exit_19: ; preds = %cond_19_case_1, %co br label %cond_31_case_1 cond_31_case_0: ; preds = %51 - %54 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 0 - %55 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 1 - %56 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %54, ptr %55) - call void @abort() + %54 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 0, !dbg !13 + %55 = extractvalue { i32, ptr } { i32 1, ptr @2 }, 1, !dbg !13 + %56 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %54, ptr %55), !dbg !13 + call void @abort(), !dbg !13 br label %cond_exit_31 cond_31_case_1: ; preds = %52 @@ -152,29 +152,29 @@ cond_31_case_1: ; preds = %52 cond_exit_31: ; preds = %cond_31_case_1, %cond_31_case_0 %"034.0" = phi i64 [ 0, %cond_31_case_0 ], [ %53, %cond_31_case_1 ] - %array_ptr44 = extractvalue { ptr, ptr, i64 } %"015.0", 0 - %array_mask_ptr45 = extractvalue { ptr, ptr, i64 } %"015.0", 1 - %array_offset46 = extractvalue { ptr, ptr, i64 } %"015.0", 2 - %57 = icmp ult i64 1, 2 - br i1 %57, label %61, label %58 + %array_ptr44 = extractvalue { ptr, ptr, i64 } %"015.0", 0, !dbg !14 + %array_mask_ptr45 = extractvalue { ptr, ptr, i64 } %"015.0", 1, !dbg !14 + %array_offset46 = extractvalue { ptr, ptr, i64 } %"015.0", 2, !dbg !14 + %57 = icmp ult i64 1, 2, !dbg !14 + br i1 %57, label %61, label %58, !dbg !14 58: ; preds = %cond_exit_31 - %59 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 false, { ptr, ptr, i64 } poison, i64 poison }, i64 %"034.0", 2 - %60 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %59, { ptr, ptr, i64 } %"015.0", 1 - br label %67 + %59 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 false, { ptr, ptr, i64 } poison, i64 poison }, i64 %"034.0", 2, !dbg !14 + %60 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %59, { ptr, ptr, i64 } %"015.0", 1, !dbg !14 + br label %67, !dbg !14 61: ; preds = %cond_exit_31 - %62 = add i64 1, %array_offset46 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr45, i64 %62) - %63 = getelementptr inbounds i64, ptr %array_ptr44, i64 %62 - %64 = load i64, ptr %63, align 4 - store i64 %"034.0", ptr %63, align 4 - %65 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %64, 2 - %66 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %65, { ptr, ptr, i64 } %"015.0", 1 - br label %67 + %62 = add i64 1, %array_offset46, !dbg !14 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr45, i64 %62), !dbg !14 + %63 = getelementptr inbounds i64, ptr %array_ptr44, i64 %62, !dbg !14 + %64 = load i64, ptr %63, align 4, !dbg !14 + store i64 %"034.0", ptr %63, align 4, !dbg !14 + %65 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %64, 2, !dbg !14 + %66 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %65, { ptr, ptr, i64 } %"015.0", 1, !dbg !14 + br label %67, !dbg !14 67: ; preds = %58, %61 - %"047.0" = phi { i1, { ptr, ptr, i64 }, i64 } [ %66, %61 ], [ %60, %58 ] + %"047.0" = phi { i1, { ptr, ptr, i64 }, i64 } [ %66, %61 ], [ %60, %58 ], !dbg !14 %68 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %"047.0", 0 switch i1 %68, label %69 [ i1 true, label %72 @@ -191,10 +191,10 @@ cond_exit_31: ; preds = %cond_31_case_1, %co br label %cond_42_case_1 cond_42_case_0: ; preds = %69 - %75 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 0 - %76 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 1 - %77 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %75, ptr %76) - call void @abort() + %75 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 0, !dbg !15 + %76 = extractvalue { i32, ptr } { i32 1, ptr @3 }, 1, !dbg !15 + %77 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %75, ptr %76), !dbg !15 + call void @abort(), !dbg !15 br label %cond_exit_42 cond_42_case_1: ; preds = %72 @@ -203,18 +203,18 @@ cond_42_case_1: ; preds = %72 cond_exit_42: ; preds = %cond_42_case_1, %cond_42_case_0 %"050.0" = phi i64 [ 0, %cond_42_case_0 ], [ %73, %cond_42_case_1 ] %"151.0" = phi { ptr, ptr, i64 } [ zeroinitializer, %cond_42_case_0 ], [ %74, %cond_42_case_1 ] - %array_ptr70 = extractvalue { ptr, ptr, i64 } %"151.0", 0 - %array_mask_ptr71 = extractvalue { ptr, ptr, i64 } %"151.0", 1 - %array_offset72 = extractvalue { ptr, ptr, i64 } %"151.0", 2 - %new_offset = add i64 %array_offset72, 1 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr71, i64 %array_offset72) - %78 = getelementptr inbounds i64, ptr %array_ptr70, i64 %array_offset72 - %79 = load i64, ptr %78, align 4 - %80 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr70, 0 - %81 = insertvalue { ptr, ptr, i64 } %80, ptr %array_mask_ptr71, 1 - %82 = insertvalue { ptr, ptr, i64 } %81, i64 %new_offset, 2 - %83 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %79, 2 - %84 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %83, { ptr, ptr, i64 } %82, 1 + %array_ptr70 = extractvalue { ptr, ptr, i64 } %"151.0", 0, !dbg !16 + %array_mask_ptr71 = extractvalue { ptr, ptr, i64 } %"151.0", 1, !dbg !16 + %array_offset72 = extractvalue { ptr, ptr, i64 } %"151.0", 2, !dbg !16 + %new_offset = add i64 %array_offset72, 1, !dbg !16 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr71, i64 %array_offset72), !dbg !16 + %78 = getelementptr inbounds i64, ptr %array_ptr70, i64 %array_offset72, !dbg !16 + %79 = load i64, ptr %78, align 4, !dbg !16 + %80 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr70, 0, !dbg !16 + %81 = insertvalue { ptr, ptr, i64 } %80, ptr %array_mask_ptr71, 1, !dbg !16 + %82 = insertvalue { ptr, ptr, i64 } %81, i64 %new_offset, 2, !dbg !16 + %83 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %79, 2, !dbg !16 + %84 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %83, { ptr, ptr, i64 } %82, 1, !dbg !16 %85 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %84, 0 switch i1 %85, label %86 [ i1 true, label %87 @@ -229,10 +229,10 @@ cond_exit_42: ; preds = %cond_42_case_1, %co br label %cond_53_case_1 cond_53_case_0: ; preds = %86 - %90 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 0 - %91 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 1 - %92 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %90, ptr %91) - call void @abort() + %90 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 0, !dbg !17 + %91 = extractvalue { i32, ptr } { i32 1, ptr @4 }, 1, !dbg !17 + %92 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %90, ptr %91), !dbg !17 + call void @abort(), !dbg !17 br label %cond_exit_53 cond_53_case_1: ; preds = %87 @@ -241,18 +241,18 @@ cond_53_case_1: ; preds = %87 cond_exit_53: ; preds = %cond_53_case_1, %cond_53_case_0 %"074.0" = phi i64 [ 0, %cond_53_case_0 ], [ %88, %cond_53_case_1 ] %"175.0" = phi { ptr, ptr, i64 } [ zeroinitializer, %cond_53_case_0 ], [ %89, %cond_53_case_1 ] - %array_ptr88 = extractvalue { ptr, ptr, i64 } %"175.0", 0 - %array_mask_ptr89 = extractvalue { ptr, ptr, i64 } %"175.0", 1 - %array_offset90 = extractvalue { ptr, ptr, i64 } %"175.0", 2 - %93 = add i64 %array_offset90, 0 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr89, i64 %93) - %94 = getelementptr inbounds i64, ptr %array_ptr88, i64 %93 - %95 = load i64, ptr %94, align 4 - %96 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr88, 0 - %97 = insertvalue { ptr, ptr, i64 } %96, ptr %array_mask_ptr89, 1 - %98 = insertvalue { ptr, ptr, i64 } %97, i64 %array_offset90, 2 - %99 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %95, 2 - %100 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %99, { ptr, ptr, i64 } %98, 1 + %array_ptr88 = extractvalue { ptr, ptr, i64 } %"175.0", 0, !dbg !18 + %array_mask_ptr89 = extractvalue { ptr, ptr, i64 } %"175.0", 1, !dbg !18 + %array_offset90 = extractvalue { ptr, ptr, i64 } %"175.0", 2, !dbg !18 + %93 = add i64 %array_offset90, 0, !dbg !18 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr89, i64 %93), !dbg !18 + %94 = getelementptr inbounds i64, ptr %array_ptr88, i64 %93, !dbg !18 + %95 = load i64, ptr %94, align 4, !dbg !18 + %96 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr88, 0, !dbg !18 + %97 = insertvalue { ptr, ptr, i64 } %96, ptr %array_mask_ptr89, 1, !dbg !18 + %98 = insertvalue { ptr, ptr, i64 } %97, i64 %array_offset90, 2, !dbg !18 + %99 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %95, 2, !dbg !18 + %100 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %99, { ptr, ptr, i64 } %98, 1, !dbg !18 %101 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %100, 0 switch i1 %101, label %102 [ i1 true, label %103 @@ -267,10 +267,10 @@ cond_exit_53: ; preds = %cond_53_case_1, %co br label %cond_64_case_1 cond_64_case_0: ; preds = %102 - %106 = extractvalue { i32, ptr } { i32 1, ptr @5 }, 0 - %107 = extractvalue { i32, ptr } { i32 1, ptr @5 }, 1 - %108 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.5, i32 %106, ptr %107) - call void @abort() + %106 = extractvalue { i32, ptr } { i32 1, ptr @5 }, 0, !dbg !19 + %107 = extractvalue { i32, ptr } { i32 1, ptr @5 }, 1, !dbg !19 + %108 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.5, i32 %106, ptr %107), !dbg !19 + call void @abort(), !dbg !19 br label %cond_exit_64 cond_64_case_1: ; preds = %103 @@ -279,11 +279,11 @@ cond_64_case_1: ; preds = %103 cond_exit_64: ; preds = %cond_64_case_1, %cond_64_case_0 %"092.0" = phi i64 [ 0, %cond_64_case_0 ], [ %104, %cond_64_case_1 ] %"193.0" = phi { ptr, ptr, i64 } [ zeroinitializer, %cond_64_case_0 ], [ %105, %cond_64_case_1 ] - %array_ptr106 = extractvalue { ptr, ptr, i64 } %"193.0", 0 - %array_mask_ptr107 = extractvalue { ptr, ptr, i64 } %"193.0", 1 - %array_offset108 = extractvalue { ptr, ptr, i64 } %"193.0", 2 - call void @free(ptr %array_ptr106) - call void @free(ptr %array_mask_ptr107) + %array_ptr106 = extractvalue { ptr, ptr, i64 } %"193.0", 0, !dbg !20 + %array_mask_ptr107 = extractvalue { ptr, ptr, i64 } %"193.0", 1, !dbg !20 + %array_offset108 = extractvalue { ptr, ptr, i64 } %"193.0", 2, !dbg !20 + call void @free(ptr %array_ptr106), !dbg !20 + call void @free(ptr %array_mask_ptr107), !dbg !20 ret void } @@ -293,21 +293,21 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_mask_check_not_borrowed(ptr %0, i64 %1) { - %3 = udiv i64 %1, 64 - %4 = getelementptr inbounds i64, ptr %0, i64 %3 - %5 = load i64, ptr %4, align 4 - %6 = urem i64 %1, 64 - %7 = lshr i64 %5, %6 - %8 = trunc i64 %7 to i1 - br i1 %8, label %panic, label %ok + %3 = udiv i64 %1, 64, !dbg !9 + %4 = getelementptr inbounds i64, ptr %0, i64 %3, !dbg !9 + %5 = load i64, ptr %4, align 4, !dbg !9 + %6 = urem i64 %1, 64, !dbg !9 + %7 = lshr i64 %5, %6, !dbg !9 + %8 = trunc i64 %7 to i1, !dbg !9 + br i1 %8, label %panic, label %ok, !dbg !9 panic: ; preds = %2 - %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !9 + call void @abort(), !dbg !9 + unreachable, !dbg !9 ok: ; preds = %2 - ret void + ret void, !dbg !9 } declare i32 @printf(ptr, ...) @@ -317,3 +317,28 @@ declare void @abort() declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/nyeIVwAutKJHa/EPSZwPXPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 10060, column: 368, scope: !3) +!8 = !DILocation(line: 27062, column: 402, scope: !3) +!9 = !DILocation(line: 5388, column: 404, scope: !3) +!10 = !DILocation(line: 32551, column: 131, scope: !3) +!11 = !DILocation(line: 13582, column: 372, scope: !3) +!12 = !DILocation(line: 1712, column: 109, scope: !3) +!13 = !DILocation(line: 352, column: 366, scope: !3) +!14 = !DILocation(line: 21129, column: 412, scope: !3) +!15 = !DILocation(line: 4112, column: 51, scope: !3) +!16 = !DILocation(line: 31810, column: 83, scope: !3) +!17 = !DILocation(line: 21101, column: 431, scope: !3) +!18 = !DILocation(line: 16173, column: 468, scope: !3) +!19 = !DILocation(line: 4687, column: 439, scope: !3) +!20 = !DILocation(line: 2116, column: 303, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@pre-mem2reg@llvm21.snap index 1d58be25df..a4addcb0bb 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_all_ops@pre-mem2reg@llvm21.snap @@ -18,7 +18,7 @@ source_filename = "test_context" @5 = private unnamed_addr constant [37 x i8] c"Expected variant 1 but got variant 0\00", align 1 @prelude.panic_template.5 = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"12_0" = alloca i64, align 8 %"10_0" = alloca i64, align 8 @@ -28,7 +28,7 @@ alloca_block: %"14_1" = alloca i64, align 8 %"8_0" = alloca i64, align 8 %"18_0" = alloca { i1, { ptr, ptr, i64 } }, align 8 - %"0" = alloca { i1, { ptr, ptr, i64 } }, align 8 + %"0" = alloca { i1, { ptr, ptr, i64 } }, align 8, !dbg !7 %"19_0" = alloca { ptr, ptr, i64 }, align 8 %"015" = alloca { ptr, ptr, i64 }, align 8 %"017" = alloca { ptr, ptr, i64 }, align 8 @@ -39,8 +39,8 @@ alloca_block: %"27_0" = alloca { ptr, ptr, i64 }, align 8 %"29_0" = alloca { i1, i64 }, align 8 %"29_1" = alloca { ptr, ptr, i64 }, align 8 - %"030" = alloca { i1, i64 }, align 8 - %"1" = alloca { ptr, ptr, i64 }, align 8 + %"030" = alloca { i1, i64 }, align 8, !dbg !8 + %"1" = alloca { ptr, ptr, i64 }, align 8, !dbg !8 %"31_0" = alloca i64, align 8 %"034" = alloca i64, align 8 %"36_0" = alloca { i32, ptr }, align 8 @@ -48,7 +48,7 @@ alloca_block: %"038" = alloca i64, align 8 %"39_0" = alloca i64, align 8 %"41_0" = alloca { i1, { ptr, ptr, i64 }, i64 }, align 8 - %"047" = alloca { i1, { ptr, ptr, i64 }, i64 }, align 8 + %"047" = alloca { i1, { ptr, ptr, i64 }, i64 }, align 8, !dbg !9 %"42_0" = alloca i64, align 8 %"42_1" = alloca { ptr, ptr, i64 }, align 8 %"050" = alloca i64, align 8 @@ -95,81 +95,81 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"10_0", align 4 %"10_01" = load i64, ptr %"10_0", align 4 %"12_02" = load i64, ptr %"12_0", align 4 - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 %"10_01", ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 %"12_02", ptr %6, align 4 - store { ptr, ptr, i64 } %4, ptr %"15_0", align 8 + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !10 + %0 = call ptr @malloc(i64 %array_size), !dbg !10 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !10 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !10 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !10 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !10 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !10 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !10 + store i64 %"10_01", ptr %5, align 4, !dbg !10 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !10 + store i64 %"12_02", ptr %6, align 4, !dbg !10 + store { ptr, ptr, i64 } %4, ptr %"15_0", align 8, !dbg !10 %"10_03" = load i64, ptr %"10_0", align 4 %"12_04" = load i64, ptr %"12_0", align 4 - %array_size5 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %array_size5) - %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1 - %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2 - %12 = getelementptr inbounds i64, ptr %7, i64 0 - store i64 %"10_03", ptr %12, align 4 - %13 = getelementptr inbounds i64, ptr %7, i64 1 - store i64 %"12_04", ptr %13, align 4 - store { ptr, ptr, i64 } %11, ptr %"13_0", align 8 + %array_size5 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !11 + %7 = call ptr @malloc(i64 %array_size5), !dbg !11 + %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !11 + call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !11 + %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0, !dbg !11 + %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1, !dbg !11 + %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2, !dbg !11 + %12 = getelementptr inbounds i64, ptr %7, i64 0, !dbg !11 + store i64 %"10_03", ptr %12, align 4, !dbg !11 + %13 = getelementptr inbounds i64, ptr %7, i64 1, !dbg !11 + store i64 %"12_04", ptr %13, align 4, !dbg !11 + store { ptr, ptr, i64 } %11, ptr %"13_0", align 8, !dbg !11 %"13_06" = load { ptr, ptr, i64 }, ptr %"13_0", align 8 - %array_ptr = extractvalue { ptr, ptr, i64 } %"13_06", 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"13_06", 1 - %array_offset = extractvalue { ptr, ptr, i64 } %"13_06", 2 - %14 = add i64 %array_offset, 0 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %14) - %15 = getelementptr inbounds i64, ptr %array_ptr, i64 %14 - %16 = load i64, ptr %15, align 4 - %17 = add i64 %array_offset, 1 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %17) - %18 = getelementptr inbounds i64, ptr %array_ptr, i64 %17 - %19 = load i64, ptr %18, align 4 - store i64 %16, ptr %"14_0", align 4 - store i64 %19, ptr %"14_1", align 4 + %array_ptr = extractvalue { ptr, ptr, i64 } %"13_06", 0, !dbg !12 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"13_06", 1, !dbg !12 + %array_offset = extractvalue { ptr, ptr, i64 } %"13_06", 2, !dbg !12 + %14 = add i64 %array_offset, 0, !dbg !12 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %14), !dbg !12 + %15 = getelementptr inbounds i64, ptr %array_ptr, i64 %14, !dbg !12 + %16 = load i64, ptr %15, align 4, !dbg !12 + %17 = add i64 %array_offset, 1, !dbg !12 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %17), !dbg !12 + %18 = getelementptr inbounds i64, ptr %array_ptr, i64 %17, !dbg !12 + %19 = load i64, ptr %18, align 4, !dbg !12 + store i64 %16, ptr %"14_0", align 4, !dbg !12 + store i64 %19, ptr %"14_1", align 4, !dbg !12 store i64 0, ptr %"8_0", align 4 %"15_07" = load { ptr, ptr, i64 }, ptr %"15_0", align 8 %"8_08" = load i64, ptr %"8_0", align 4 %"10_09" = load i64, ptr %"10_0", align 4 - %array_ptr10 = extractvalue { ptr, ptr, i64 } %"15_07", 0 - %array_mask_ptr11 = extractvalue { ptr, ptr, i64 } %"15_07", 1 - %array_offset12 = extractvalue { ptr, ptr, i64 } %"15_07", 2 - %20 = icmp ult i64 %"8_08", 2 - %21 = icmp ult i64 %"10_09", 2 - %22 = and i1 %20, %21 - br i1 %22, label %25, label %23 + %array_ptr10 = extractvalue { ptr, ptr, i64 } %"15_07", 0, !dbg !7 + %array_mask_ptr11 = extractvalue { ptr, ptr, i64 } %"15_07", 1, !dbg !7 + %array_offset12 = extractvalue { ptr, ptr, i64 } %"15_07", 2, !dbg !7 + %20 = icmp ult i64 %"8_08", 2, !dbg !7 + %21 = icmp ult i64 %"10_09", 2, !dbg !7 + %22 = and i1 %20, %21, !dbg !7 + br i1 %22, label %25, label %23, !dbg !7 23: ; preds = %entry_block - %24 = insertvalue { i1, { ptr, ptr, i64 } } { i1 false, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %"15_07", 1 - store { i1, { ptr, ptr, i64 } } %24, ptr %"0", align 8 - br label %33 + %24 = insertvalue { i1, { ptr, ptr, i64 } } { i1 false, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %"15_07", 1, !dbg !7 + store { i1, { ptr, ptr, i64 } } %24, ptr %"0", align 8, !dbg !7 + br label %33, !dbg !7 25: ; preds = %entry_block - %26 = add i64 %"8_08", %array_offset12 - %27 = add i64 %"10_09", %array_offset12 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %26) - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %27) - %28 = getelementptr inbounds i64, ptr %array_ptr10, i64 %26 - %29 = load i64, ptr %28, align 4 - %30 = getelementptr inbounds i64, ptr %array_ptr10, i64 %27 - %31 = load i64, ptr %30, align 4 - store i64 %31, ptr %28, align 4 - store i64 %29, ptr %30, align 4 - %32 = insertvalue { i1, { ptr, ptr, i64 } } { i1 true, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %"15_07", 1 - store { i1, { ptr, ptr, i64 } } %32, ptr %"0", align 8 - br label %33 + %26 = add i64 %"8_08", %array_offset12, !dbg !7 + %27 = add i64 %"10_09", %array_offset12, !dbg !7 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %26), !dbg !7 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr11, i64 %27), !dbg !7 + %28 = getelementptr inbounds i64, ptr %array_ptr10, i64 %26, !dbg !7 + %29 = load i64, ptr %28, align 4, !dbg !7 + %30 = getelementptr inbounds i64, ptr %array_ptr10, i64 %27, !dbg !7 + %31 = load i64, ptr %30, align 4, !dbg !7 + store i64 %31, ptr %28, align 4, !dbg !7 + store i64 %29, ptr %30, align 4, !dbg !7 + %32 = insertvalue { i1, { ptr, ptr, i64 } } { i1 true, { ptr, ptr, i64 } poison }, { ptr, ptr, i64 } %"15_07", 1, !dbg !7 + store { i1, { ptr, ptr, i64 } } %32, ptr %"0", align 8, !dbg !7 + br label %33, !dbg !7 33: ; preds = %23, %25 - %"013" = load { i1, { ptr, ptr, i64 } }, ptr %"0", align 8 - store { i1, { ptr, ptr, i64 } } %"013", ptr %"18_0", align 8 + %"013" = load { i1, { ptr, ptr, i64 } }, ptr %"0", align 8, !dbg !7 + store { i1, { ptr, ptr, i64 } } %"013", ptr %"18_0", align 8, !dbg !7 %"18_014" = load { i1, { ptr, ptr, i64 } }, ptr %"18_0", align 8 %34 = extractvalue { i1, { ptr, ptr, i64 } } %"18_014", 0 switch i1 %34, label %35 [ @@ -192,11 +192,11 @@ cond_19_case_0: ; preds = %35 store { ptr, ptr, i64 } %"018", ptr %"21_0", align 8 %"24_019" = load { i32, ptr }, ptr %"24_0", align 8 %"21_020" = load { ptr, ptr, i64 }, ptr %"21_0", align 8 - %39 = extractvalue { i32, ptr } %"24_019", 0 - %40 = extractvalue { i32, ptr } %"24_019", 1 - %41 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %39, ptr %40) - call void @abort() - store { ptr, ptr, i64 } zeroinitializer, ptr %"25_0", align 8 + %39 = extractvalue { i32, ptr } %"24_019", 0, !dbg !13 + %40 = extractvalue { i32, ptr } %"24_019", 1, !dbg !13 + %41 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.1, i32 %39, ptr %40), !dbg !13 + call void @abort(), !dbg !13 + store { ptr, ptr, i64 } zeroinitializer, ptr %"25_0", align 8, !dbg !13 %"25_021" = load { ptr, ptr, i64 }, ptr %"25_0", align 8 store { ptr, ptr, i64 } %"25_021", ptr %"015", align 8 br label %cond_exit_19 @@ -213,32 +213,32 @@ cond_exit_19: ; preds = %cond_19_case_1, %co store { ptr, ptr, i64 } %"016", ptr %"19_0", align 8 %"19_025" = load { ptr, ptr, i64 }, ptr %"19_0", align 8 %"8_026" = load i64, ptr %"8_0", align 4 - %array_ptr27 = extractvalue { ptr, ptr, i64 } %"19_025", 0 - %array_mask_ptr28 = extractvalue { ptr, ptr, i64 } %"19_025", 1 - %array_offset29 = extractvalue { ptr, ptr, i64 } %"19_025", 2 - %42 = icmp ult i64 %"8_026", 2 - br i1 %42, label %44, label %43 + %array_ptr27 = extractvalue { ptr, ptr, i64 } %"19_025", 0, !dbg !8 + %array_mask_ptr28 = extractvalue { ptr, ptr, i64 } %"19_025", 1, !dbg !8 + %array_offset29 = extractvalue { ptr, ptr, i64 } %"19_025", 2, !dbg !8 + %42 = icmp ult i64 %"8_026", 2, !dbg !8 + br i1 %42, label %44, label %43, !dbg !8 43: ; preds = %cond_exit_19 - store { i1, i64 } { i1 false, i64 poison }, ptr %"030", align 4 - store { ptr, ptr, i64 } %"19_025", ptr %"1", align 8 - br label %49 + store { i1, i64 } { i1 false, i64 poison }, ptr %"030", align 4, !dbg !8 + store { ptr, ptr, i64 } %"19_025", ptr %"1", align 8, !dbg !8 + br label %49, !dbg !8 44: ; preds = %cond_exit_19 - %45 = add i64 %"8_026", %array_offset29 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr28, i64 %45) - %46 = getelementptr inbounds i64, ptr %array_ptr27, i64 %45 - %47 = load i64, ptr %46, align 4 - %48 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %47, 1 - store { i1, i64 } %48, ptr %"030", align 4 - store { ptr, ptr, i64 } %"19_025", ptr %"1", align 8 - br label %49 + %45 = add i64 %"8_026", %array_offset29, !dbg !8 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr28, i64 %45), !dbg !8 + %46 = getelementptr inbounds i64, ptr %array_ptr27, i64 %45, !dbg !8 + %47 = load i64, ptr %46, align 4, !dbg !8 + %48 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %47, 1, !dbg !8 + store { i1, i64 } %48, ptr %"030", align 4, !dbg !8 + store { ptr, ptr, i64 } %"19_025", ptr %"1", align 8, !dbg !8 + br label %49, !dbg !8 49: ; preds = %43, %44 - %"031" = load { i1, i64 }, ptr %"030", align 4 - %"132" = load { ptr, ptr, i64 }, ptr %"1", align 8 - store { i1, i64 } %"031", ptr %"29_0", align 4 - store { ptr, ptr, i64 } %"132", ptr %"29_1", align 8 + %"031" = load { i1, i64 }, ptr %"030", align 4, !dbg !8 + %"132" = load { ptr, ptr, i64 }, ptr %"1", align 8, !dbg !8 + store { i1, i64 } %"031", ptr %"29_0", align 4, !dbg !8 + store { ptr, ptr, i64 } %"132", ptr %"29_1", align 8, !dbg !8 %"29_033" = load { i1, i64 }, ptr %"29_0", align 4 %50 = extractvalue { i1, i64 } %"29_033", 0 switch i1 %50, label %51 [ @@ -256,11 +256,11 @@ cond_exit_19: ; preds = %cond_19_case_1, %co cond_31_case_0: ; preds = %51 store { i32, ptr } { i32 1, ptr @2 }, ptr %"36_0", align 8 %"36_036" = load { i32, ptr }, ptr %"36_0", align 8 - %54 = extractvalue { i32, ptr } %"36_036", 0 - %55 = extractvalue { i32, ptr } %"36_036", 1 - %56 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %54, ptr %55) - call void @abort() - store i64 0, ptr %"37_0", align 4 + %54 = extractvalue { i32, ptr } %"36_036", 0, !dbg !14 + %55 = extractvalue { i32, ptr } %"36_036", 1, !dbg !14 + %56 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.2, i32 %54, ptr %55), !dbg !14 + call void @abort(), !dbg !14 + store i64 0, ptr %"37_0", align 4, !dbg !14 %"37_037" = load i64, ptr %"37_0", align 4 store i64 %"37_037", ptr %"034", align 4 br label %cond_exit_31 @@ -278,32 +278,32 @@ cond_exit_31: ; preds = %cond_31_case_1, %co %"29_141" = load { ptr, ptr, i64 }, ptr %"29_1", align 8 %"10_042" = load i64, ptr %"10_0", align 4 %"31_043" = load i64, ptr %"31_0", align 4 - %array_ptr44 = extractvalue { ptr, ptr, i64 } %"29_141", 0 - %array_mask_ptr45 = extractvalue { ptr, ptr, i64 } %"29_141", 1 - %array_offset46 = extractvalue { ptr, ptr, i64 } %"29_141", 2 - %57 = icmp ult i64 %"10_042", 2 - br i1 %57, label %61, label %58 + %array_ptr44 = extractvalue { ptr, ptr, i64 } %"29_141", 0, !dbg !9 + %array_mask_ptr45 = extractvalue { ptr, ptr, i64 } %"29_141", 1, !dbg !9 + %array_offset46 = extractvalue { ptr, ptr, i64 } %"29_141", 2, !dbg !9 + %57 = icmp ult i64 %"10_042", 2, !dbg !9 + br i1 %57, label %61, label %58, !dbg !9 58: ; preds = %cond_exit_31 - %59 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 false, { ptr, ptr, i64 } poison, i64 poison }, i64 %"31_043", 2 - %60 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %59, { ptr, ptr, i64 } %"29_141", 1 - store { i1, { ptr, ptr, i64 }, i64 } %60, ptr %"047", align 8 - br label %67 + %59 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 false, { ptr, ptr, i64 } poison, i64 poison }, i64 %"31_043", 2, !dbg !9 + %60 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %59, { ptr, ptr, i64 } %"29_141", 1, !dbg !9 + store { i1, { ptr, ptr, i64 }, i64 } %60, ptr %"047", align 8, !dbg !9 + br label %67, !dbg !9 61: ; preds = %cond_exit_31 - %62 = add i64 %"10_042", %array_offset46 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr45, i64 %62) - %63 = getelementptr inbounds i64, ptr %array_ptr44, i64 %62 - %64 = load i64, ptr %63, align 4 - store i64 %"31_043", ptr %63, align 4 - %65 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %64, 2 - %66 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %65, { ptr, ptr, i64 } %"29_141", 1 - store { i1, { ptr, ptr, i64 }, i64 } %66, ptr %"047", align 8 - br label %67 + %62 = add i64 %"10_042", %array_offset46, !dbg !9 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr45, i64 %62), !dbg !9 + %63 = getelementptr inbounds i64, ptr %array_ptr44, i64 %62, !dbg !9 + %64 = load i64, ptr %63, align 4, !dbg !9 + store i64 %"31_043", ptr %63, align 4, !dbg !9 + %65 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %64, 2, !dbg !9 + %66 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %65, { ptr, ptr, i64 } %"29_141", 1, !dbg !9 + store { i1, { ptr, ptr, i64 }, i64 } %66, ptr %"047", align 8, !dbg !9 + br label %67, !dbg !9 67: ; preds = %58, %61 - %"048" = load { i1, { ptr, ptr, i64 }, i64 }, ptr %"047", align 8 - store { i1, { ptr, ptr, i64 }, i64 } %"048", ptr %"41_0", align 8 + %"048" = load { i1, { ptr, ptr, i64 }, i64 }, ptr %"047", align 8, !dbg !9 + store { i1, { ptr, ptr, i64 }, i64 } %"048", ptr %"41_0", align 8, !dbg !9 %"41_049" = load { i1, { ptr, ptr, i64 }, i64 }, ptr %"41_0", align 8 %68 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %"41_049", 0 switch i1 %68, label %69 [ @@ -333,12 +333,12 @@ cond_42_case_0: ; preds = %69 %"47_058" = load { i32, ptr }, ptr %"47_0", align 8 %"44_059" = load i64, ptr %"44_0", align 4 %"44_160" = load { ptr, ptr, i64 }, ptr %"44_1", align 8 - %75 = extractvalue { i32, ptr } %"47_058", 0 - %76 = extractvalue { i32, ptr } %"47_058", 1 - %77 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %75, ptr %76) - call void @abort() - store i64 0, ptr %"48_0", align 4 - store { ptr, ptr, i64 } zeroinitializer, ptr %"48_1", align 8 + %75 = extractvalue { i32, ptr } %"47_058", 0, !dbg !15 + %76 = extractvalue { i32, ptr } %"47_058", 1, !dbg !15 + %77 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.3, i32 %75, ptr %76), !dbg !15 + call void @abort(), !dbg !15 + store i64 0, ptr %"48_0", align 4, !dbg !15 + store { ptr, ptr, i64 } zeroinitializer, ptr %"48_1", align 8, !dbg !15 %"48_061" = load i64, ptr %"48_0", align 4 %"48_162" = load { ptr, ptr, i64 }, ptr %"48_1", align 8 store i64 %"48_061", ptr %"050", align 4 @@ -362,19 +362,19 @@ cond_exit_42: ; preds = %cond_42_case_1, %co store i64 %"052", ptr %"42_0", align 4 store { ptr, ptr, i64 } %"153", ptr %"42_1", align 8 %"42_169" = load { ptr, ptr, i64 }, ptr %"42_1", align 8 - %array_ptr70 = extractvalue { ptr, ptr, i64 } %"42_169", 0 - %array_mask_ptr71 = extractvalue { ptr, ptr, i64 } %"42_169", 1 - %array_offset72 = extractvalue { ptr, ptr, i64 } %"42_169", 2 - %new_offset = add i64 %array_offset72, 1 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr71, i64 %array_offset72) - %78 = getelementptr inbounds i64, ptr %array_ptr70, i64 %array_offset72 - %79 = load i64, ptr %78, align 4 - %80 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr70, 0 - %81 = insertvalue { ptr, ptr, i64 } %80, ptr %array_mask_ptr71, 1 - %82 = insertvalue { ptr, ptr, i64 } %81, i64 %new_offset, 2 - %83 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %79, 2 - %84 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %83, { ptr, ptr, i64 } %82, 1 - store { i1, { ptr, ptr, i64 }, i64 } %84, ptr %"52_0", align 8 + %array_ptr70 = extractvalue { ptr, ptr, i64 } %"42_169", 0, !dbg !16 + %array_mask_ptr71 = extractvalue { ptr, ptr, i64 } %"42_169", 1, !dbg !16 + %array_offset72 = extractvalue { ptr, ptr, i64 } %"42_169", 2, !dbg !16 + %new_offset = add i64 %array_offset72, 1, !dbg !16 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr71, i64 %array_offset72), !dbg !16 + %78 = getelementptr inbounds i64, ptr %array_ptr70, i64 %array_offset72, !dbg !16 + %79 = load i64, ptr %78, align 4, !dbg !16 + %80 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr70, 0, !dbg !16 + %81 = insertvalue { ptr, ptr, i64 } %80, ptr %array_mask_ptr71, 1, !dbg !16 + %82 = insertvalue { ptr, ptr, i64 } %81, i64 %new_offset, 2, !dbg !16 + %83 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %79, 2, !dbg !16 + %84 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %83, { ptr, ptr, i64 } %82, 1, !dbg !16 + store { i1, { ptr, ptr, i64 }, i64 } %84, ptr %"52_0", align 8, !dbg !16 %"52_073" = load { i1, { ptr, ptr, i64 }, i64 }, ptr %"52_0", align 8 %85 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %"52_073", 0 switch i1 %85, label %86 [ @@ -394,12 +394,12 @@ cond_exit_42: ; preds = %cond_42_case_1, %co cond_53_case_0: ; preds = %86 store { i32, ptr } { i32 1, ptr @4 }, ptr %"58_0", align 8 %"58_078" = load { i32, ptr }, ptr %"58_0", align 8 - %90 = extractvalue { i32, ptr } %"58_078", 0 - %91 = extractvalue { i32, ptr } %"58_078", 1 - %92 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %90, ptr %91) - call void @abort() - store i64 0, ptr %"59_0", align 4 - store { ptr, ptr, i64 } zeroinitializer, ptr %"59_1", align 8 + %90 = extractvalue { i32, ptr } %"58_078", 0, !dbg !17 + %91 = extractvalue { i32, ptr } %"58_078", 1, !dbg !17 + %92 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.4, i32 %90, ptr %91), !dbg !17 + call void @abort(), !dbg !17 + store i64 0, ptr %"59_0", align 4, !dbg !17 + store { ptr, ptr, i64 } zeroinitializer, ptr %"59_1", align 8, !dbg !17 %"59_079" = load i64, ptr %"59_0", align 4 %"59_180" = load { ptr, ptr, i64 }, ptr %"59_1", align 8 store i64 %"59_079", ptr %"074", align 4 @@ -423,19 +423,19 @@ cond_exit_53: ; preds = %cond_53_case_1, %co store i64 %"076", ptr %"53_0", align 4 store { ptr, ptr, i64 } %"177", ptr %"53_1", align 8 %"53_187" = load { ptr, ptr, i64 }, ptr %"53_1", align 8 - %array_ptr88 = extractvalue { ptr, ptr, i64 } %"53_187", 0 - %array_mask_ptr89 = extractvalue { ptr, ptr, i64 } %"53_187", 1 - %array_offset90 = extractvalue { ptr, ptr, i64 } %"53_187", 2 - %93 = add i64 %array_offset90, 0 - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr89, i64 %93) - %94 = getelementptr inbounds i64, ptr %array_ptr88, i64 %93 - %95 = load i64, ptr %94, align 4 - %96 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr88, 0 - %97 = insertvalue { ptr, ptr, i64 } %96, ptr %array_mask_ptr89, 1 - %98 = insertvalue { ptr, ptr, i64 } %97, i64 %array_offset90, 2 - %99 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %95, 2 - %100 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %99, { ptr, ptr, i64 } %98, 1 - store { i1, { ptr, ptr, i64 }, i64 } %100, ptr %"63_0", align 8 + %array_ptr88 = extractvalue { ptr, ptr, i64 } %"53_187", 0, !dbg !18 + %array_mask_ptr89 = extractvalue { ptr, ptr, i64 } %"53_187", 1, !dbg !18 + %array_offset90 = extractvalue { ptr, ptr, i64 } %"53_187", 2, !dbg !18 + %93 = add i64 %array_offset90, 0, !dbg !18 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr89, i64 %93), !dbg !18 + %94 = getelementptr inbounds i64, ptr %array_ptr88, i64 %93, !dbg !18 + %95 = load i64, ptr %94, align 4, !dbg !18 + %96 = insertvalue { ptr, ptr, i64 } poison, ptr %array_ptr88, 0, !dbg !18 + %97 = insertvalue { ptr, ptr, i64 } %96, ptr %array_mask_ptr89, 1, !dbg !18 + %98 = insertvalue { ptr, ptr, i64 } %97, i64 %array_offset90, 2, !dbg !18 + %99 = insertvalue { i1, { ptr, ptr, i64 }, i64 } { i1 true, { ptr, ptr, i64 } poison, i64 poison }, i64 %95, 2, !dbg !18 + %100 = insertvalue { i1, { ptr, ptr, i64 }, i64 } %99, { ptr, ptr, i64 } %98, 1, !dbg !18 + store { i1, { ptr, ptr, i64 }, i64 } %100, ptr %"63_0", align 8, !dbg !18 %"63_091" = load { i1, { ptr, ptr, i64 }, i64 }, ptr %"63_0", align 8 %101 = extractvalue { i1, { ptr, ptr, i64 }, i64 } %"63_091", 0 switch i1 %101, label %102 [ @@ -455,12 +455,12 @@ cond_exit_53: ; preds = %cond_53_case_1, %co cond_64_case_0: ; preds = %102 store { i32, ptr } { i32 1, ptr @5 }, ptr %"69_0", align 8 %"69_096" = load { i32, ptr }, ptr %"69_0", align 8 - %106 = extractvalue { i32, ptr } %"69_096", 0 - %107 = extractvalue { i32, ptr } %"69_096", 1 - %108 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.5, i32 %106, ptr %107) - call void @abort() - store i64 0, ptr %"70_0", align 4 - store { ptr, ptr, i64 } zeroinitializer, ptr %"70_1", align 8 + %106 = extractvalue { i32, ptr } %"69_096", 0, !dbg !19 + %107 = extractvalue { i32, ptr } %"69_096", 1, !dbg !19 + %108 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template.5, i32 %106, ptr %107), !dbg !19 + call void @abort(), !dbg !19 + store i64 0, ptr %"70_0", align 4, !dbg !19 + store { ptr, ptr, i64 } zeroinitializer, ptr %"70_1", align 8, !dbg !19 %"70_097" = load i64, ptr %"70_0", align 4 %"70_198" = load { ptr, ptr, i64 }, ptr %"70_1", align 8 store i64 %"70_097", ptr %"092", align 4 @@ -484,11 +484,11 @@ cond_exit_64: ; preds = %cond_64_case_1, %co store i64 %"094", ptr %"64_0", align 4 store { ptr, ptr, i64 } %"195", ptr %"64_1", align 8 %"64_1105" = load { ptr, ptr, i64 }, ptr %"64_1", align 8 - %array_ptr106 = extractvalue { ptr, ptr, i64 } %"64_1105", 0 - %array_mask_ptr107 = extractvalue { ptr, ptr, i64 } %"64_1105", 1 - %array_offset108 = extractvalue { ptr, ptr, i64 } %"64_1105", 2 - call void @free(ptr %array_ptr106) - call void @free(ptr %array_mask_ptr107) + %array_ptr106 = extractvalue { ptr, ptr, i64 } %"64_1105", 0, !dbg !20 + %array_mask_ptr107 = extractvalue { ptr, ptr, i64 } %"64_1105", 1, !dbg !20 + %array_offset108 = extractvalue { ptr, ptr, i64 } %"64_1105", 2, !dbg !20 + call void @free(ptr %array_ptr106), !dbg !20 + call void @free(ptr %array_mask_ptr107), !dbg !20 ret void } @@ -498,21 +498,21 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_mask_check_not_borrowed(ptr %0, i64 %1) { - %3 = udiv i64 %1, 64 - %4 = getelementptr inbounds i64, ptr %0, i64 %3 - %5 = load i64, ptr %4, align 4 - %6 = urem i64 %1, 64 - %7 = lshr i64 %5, %6 - %8 = trunc i64 %7 to i1 - br i1 %8, label %panic, label %ok + %3 = udiv i64 %1, 64, !dbg !12 + %4 = getelementptr inbounds i64, ptr %0, i64 %3, !dbg !12 + %5 = load i64, ptr %4, align 4, !dbg !12 + %6 = urem i64 %1, 64, !dbg !12 + %7 = lshr i64 %5, %6, !dbg !12 + %8 = trunc i64 %7 to i1, !dbg !12 + br i1 %8, label %panic, label %ok, !dbg !12 panic: ; preds = %2 - %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !12 + call void @abort(), !dbg !12 + unreachable, !dbg !12 ok: ; preds = %2 - ret void + ret void, !dbg !12 } declare i32 @printf(ptr, ...) @@ -522,3 +522,28 @@ declare void @abort() declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/nyeIVwAutKJHa/EPSZwPXPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 32551, column: 131, scope: !3) +!8 = !DILocation(line: 1712, column: 109, scope: !3) +!9 = !DILocation(line: 21129, column: 412, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) +!11 = !DILocation(line: 27062, column: 402, scope: !3) +!12 = !DILocation(line: 5388, column: 404, scope: !3) +!13 = !DILocation(line: 13582, column: 372, scope: !3) +!14 = !DILocation(line: 352, column: 366, scope: !3) +!15 = !DILocation(line: 4112, column: 51, scope: !3) +!16 = !DILocation(line: 31810, column: 83, scope: !3) +!17 = !DILocation(line: 21101, column: 431, scope: !3) +!18 = !DILocation(line: 16173, column: 468, scope: !3) +!19 = !DILocation(line: 4687, column: 439, scope: !3) +!20 = !DILocation(line: 2116, column: 303, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@llvm21.snap index 408182b7c8..6f9398fc5d 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, ptr, i64 } @_hl.main.1() { +define internal { ptr, ptr, i64 } @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -30,3 +30,18 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, ptr, i64 }", file: !2, size: 24, align: 8, elements: !8) +!8 = !{!9, !9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@pre-mem2reg@llvm21.snap index 0ae63b0109..e867915c87 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_array_value@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, ptr, i64 } @_hl.main.1() { +define internal { ptr, ptr, i64 } @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca { ptr, ptr, i64 }, align 8 %"5_0" = alloca { ptr, ptr, i64 }, align 8 @@ -36,3 +36,18 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, ptr, i64 }", file: !2, size: 24, align: 8, elements: !8) +!8 = !{!9, !9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@llvm21.snap index 7e73f36162..bd897b72f0 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@llvm21.snap @@ -8,40 +8,40 @@ source_filename = "test_context" @0 = private unnamed_addr constant [39 x i8] c"Some array elements have been borrowed\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 1, ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 2, ptr %6, align 4 - %array_ptr = extractvalue { ptr, ptr, i64 } %4, 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %4, 1 - %array_offset = extractvalue { ptr, ptr, i64 } %4, 2 - call void @__barray_check_none_borrowed(ptr %array_mask_ptr, i64 %array_offset, i64 2) - %array_size4 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %array_size4) - %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1 - %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2 - %12 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset - %13 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %12, i64 %13, i1 false) - %array_ptr6 = extractvalue { ptr, ptr, i64 } %11, 0 - call void @free(ptr %array_ptr6) - %array_ptr8 = extractvalue { ptr, ptr, i64 } %4, 0 - call void @free(ptr %array_ptr8) + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %0 = call ptr @malloc(i64 %array_size), !dbg !7 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !7 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !7 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !7 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !7 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !7 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !7 + store i64 1, ptr %5, align 4, !dbg !7 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !7 + store i64 2, ptr %6, align 4, !dbg !7 + %array_ptr = extractvalue { ptr, ptr, i64 } %4, 0, !dbg !8 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %4, 1, !dbg !8 + %array_offset = extractvalue { ptr, ptr, i64 } %4, 2, !dbg !8 + call void @__barray_check_none_borrowed(ptr %array_mask_ptr, i64 %array_offset, i64 2), !dbg !8 + %array_size4 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %array_size4), !dbg !8 + %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !8 + call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !8 + %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0, !dbg !8 + %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1, !dbg !8 + %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2, !dbg !8 + %12 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset, !dbg !8 + %13 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %12, i64 %13, i1 false), !dbg !8 + %array_ptr6 = extractvalue { ptr, ptr, i64 } %11, 0, !dbg !9 + call void @free(ptr %array_ptr6), !dbg !9 + %array_ptr8 = extractvalue { ptr, ptr, i64 } %4, 0, !dbg !10 + call void @free(ptr %array_ptr8), !dbg !10 ret void } @@ -51,53 +51,53 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_check_none_borrowed(ptr %0, i64 %1, i64 %2) { - %4 = udiv i64 %1, 64 - %5 = getelementptr inbounds i64, ptr %0, i64 %4 - %6 = load i64, ptr %5, align 4 - %7 = urem i64 %1, 64 - %8 = shl i64 -1, %7 - %9 = and i64 %6, %8 - store i64 %9, ptr %5, align 4 - %10 = add i64 %1, %2 - %last_valid = sub i64 %10, 1 - %11 = udiv i64 %last_valid, 64 - %12 = getelementptr inbounds i64, ptr %0, i64 %11 - %13 = load i64, ptr %12, align 4 - %14 = urem i64 %last_valid, 64 - %15 = add i64 %14, 1 - %16 = sub i64 64, %15 - %17 = lshr i64 -1, %16 - %18 = and i64 %13, %17 - store i64 %18, ptr %12, align 4 - %19 = udiv i64 %1, 64 - %20 = udiv i64 %last_valid, 64 - %21 = sub i64 %20, %19 - %22 = add i64 %21, 1 - br label %23 + %4 = udiv i64 %1, 64, !dbg !8 + %5 = getelementptr inbounds i64, ptr %0, i64 %4, !dbg !8 + %6 = load i64, ptr %5, align 4, !dbg !8 + %7 = urem i64 %1, 64, !dbg !8 + %8 = shl i64 -1, %7, !dbg !8 + %9 = and i64 %6, %8, !dbg !8 + store i64 %9, ptr %5, align 4, !dbg !8 + %10 = add i64 %1, %2, !dbg !8 + %last_valid = sub i64 %10, 1, !dbg !8 + %11 = udiv i64 %last_valid, 64, !dbg !8 + %12 = getelementptr inbounds i64, ptr %0, i64 %11, !dbg !8 + %13 = load i64, ptr %12, align 4, !dbg !8 + %14 = urem i64 %last_valid, 64, !dbg !8 + %15 = add i64 %14, 1, !dbg !8 + %16 = sub i64 64, %15, !dbg !8 + %17 = lshr i64 -1, %16, !dbg !8 + %18 = and i64 %13, %17, !dbg !8 + store i64 %18, ptr %12, align 4, !dbg !8 + %19 = udiv i64 %1, 64, !dbg !8 + %20 = udiv i64 %last_valid, 64, !dbg !8 + %21 = sub i64 %20, %19, !dbg !8 + %22 = add i64 %21, 1, !dbg !8 + br label %23, !dbg !8 23: ; preds = %mask_block_ok, %3 - %.0 = phi i64 [ 0, %3 ], [ %32, %mask_block_ok ] - %24 = icmp ult i64 %.0, %22 - br i1 %24, label %25, label %30 + %.0 = phi i64 [ 0, %3 ], [ %32, %mask_block_ok ], !dbg !8 + %24 = icmp ult i64 %.0, %22, !dbg !8 + br i1 %24, label %25, label %30, !dbg !8 25: ; preds = %23 - %26 = add i64 %.0, %19 - %27 = getelementptr inbounds i64, ptr %0, i64 %26 - %28 = load i64, ptr %27, align 4 - %29 = icmp eq i64 %28, 0 - br i1 %29, label %mask_block_ok, label %mask_block_err + %26 = add i64 %.0, %19, !dbg !8 + %27 = getelementptr inbounds i64, ptr %0, i64 %26, !dbg !8 + %28 = load i64, ptr %27, align 4, !dbg !8 + %29 = icmp eq i64 %28, 0, !dbg !8 + br i1 %29, label %mask_block_ok, label %mask_block_err, !dbg !8 30: ; preds = %23 - ret void + ret void, !dbg !8 mask_block_err: ; preds = %25 - %31 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %31 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + unreachable, !dbg !8 mask_block_ok: ; preds = %25 - %32 = add i64 %.0, 1 - br label %23 + %32 = add i64 %.0, 1, !dbg !8 + br label %23, !dbg !8 } declare i32 @printf(ptr, ...) @@ -111,3 +111,18 @@ declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/LClAphFGIyrhv/sHeDgUnyeIVwAutK/HaZEPS/wPXPeycUvnujGxZK/RCTcNfsTEG") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 32551, column: 131, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@pre-mem2reg@llvm21.snap index 2526944113..6979ae3a9b 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_clone@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [39 x i8] c"Some array elements have been borrowed\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"7_0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 @@ -22,41 +22,41 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load i64, ptr %"7_0", align 4 - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 %"5_01", ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 %"7_02", ptr %6, align 4 - store { ptr, ptr, i64 } %4, ptr %"8_0", align 8 + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %0 = call ptr @malloc(i64 %array_size), !dbg !7 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !7 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !7 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !7 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !7 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !7 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !7 + store i64 %"5_01", ptr %5, align 4, !dbg !7 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !7 + store i64 %"7_02", ptr %6, align 4, !dbg !7 + store { ptr, ptr, i64 } %4, ptr %"8_0", align 8, !dbg !7 %"8_03" = load { ptr, ptr, i64 }, ptr %"8_0", align 8 - %array_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 1 - %array_offset = extractvalue { ptr, ptr, i64 } %"8_03", 2 - call void @__barray_check_none_borrowed(ptr %array_mask_ptr, i64 %array_offset, i64 2) - %array_size4 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %7 = call ptr @malloc(i64 %array_size4) - %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0 - %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1 - %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2 - %12 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset - %13 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %12, i64 %13, i1 false) - store { ptr, ptr, i64 } %"8_03", ptr %"9_0", align 8 - store { ptr, ptr, i64 } %11, ptr %"9_1", align 8 + %array_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 0, !dbg !8 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 1, !dbg !8 + %array_offset = extractvalue { ptr, ptr, i64 } %"8_03", 2, !dbg !8 + call void @__barray_check_none_borrowed(ptr %array_mask_ptr, i64 %array_offset, i64 2), !dbg !8 + %array_size4 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %7 = call ptr @malloc(i64 %array_size4), !dbg !8 + %8 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !8 + call void @llvm.memset.p0.i64(ptr %8, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !8 + %9 = insertvalue { ptr, ptr, i64 } poison, ptr %7, 0, !dbg !8 + %10 = insertvalue { ptr, ptr, i64 } %9, ptr %8, 1, !dbg !8 + %11 = insertvalue { ptr, ptr, i64 } %10, i64 0, 2, !dbg !8 + %12 = getelementptr inbounds i64, ptr %array_ptr, i64 %array_offset, !dbg !8 + %13 = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + call void @llvm.memcpy.p0.p0.i64(ptr %7, ptr %12, i64 %13, i1 false), !dbg !8 + store { ptr, ptr, i64 } %"8_03", ptr %"9_0", align 8, !dbg !8 + store { ptr, ptr, i64 } %11, ptr %"9_1", align 8, !dbg !8 %"9_15" = load { ptr, ptr, i64 }, ptr %"9_1", align 8 - %array_ptr6 = extractvalue { ptr, ptr, i64 } %"9_15", 0 - call void @free(ptr %array_ptr6) + %array_ptr6 = extractvalue { ptr, ptr, i64 } %"9_15", 0, !dbg !9 + call void @free(ptr %array_ptr6), !dbg !9 %"9_07" = load { ptr, ptr, i64 }, ptr %"9_0", align 8 - %array_ptr8 = extractvalue { ptr, ptr, i64 } %"9_07", 0 - call void @free(ptr %array_ptr8) + %array_ptr8 = extractvalue { ptr, ptr, i64 } %"9_07", 0, !dbg !10 + call void @free(ptr %array_ptr8), !dbg !10 ret void } @@ -66,57 +66,57 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_check_none_borrowed(ptr %0, i64 %1, i64 %2) { - %4 = udiv i64 %1, 64 - %5 = getelementptr inbounds i64, ptr %0, i64 %4 - %6 = load i64, ptr %5, align 4 - %7 = urem i64 %1, 64 - %8 = shl i64 -1, %7 - %9 = and i64 %6, %8 - store i64 %9, ptr %5, align 4 - %10 = add i64 %1, %2 - %last_valid = sub i64 %10, 1 - %11 = udiv i64 %last_valid, 64 - %12 = getelementptr inbounds i64, ptr %0, i64 %11 - %13 = load i64, ptr %12, align 4 - %14 = urem i64 %last_valid, 64 - %15 = add i64 %14, 1 - %16 = sub i64 64, %15 - %17 = lshr i64 -1, %16 - %18 = and i64 %13, %17 - store i64 %18, ptr %12, align 4 - %19 = udiv i64 %1, 64 - %20 = udiv i64 %last_valid, 64 - %21 = sub i64 %20, %19 - %22 = add i64 %21, 1 - %23 = alloca i64, align 8 - store i64 0, ptr %23, align 4 - br label %24 + %4 = udiv i64 %1, 64, !dbg !8 + %5 = getelementptr inbounds i64, ptr %0, i64 %4, !dbg !8 + %6 = load i64, ptr %5, align 4, !dbg !8 + %7 = urem i64 %1, 64, !dbg !8 + %8 = shl i64 -1, %7, !dbg !8 + %9 = and i64 %6, %8, !dbg !8 + store i64 %9, ptr %5, align 4, !dbg !8 + %10 = add i64 %1, %2, !dbg !8 + %last_valid = sub i64 %10, 1, !dbg !8 + %11 = udiv i64 %last_valid, 64, !dbg !8 + %12 = getelementptr inbounds i64, ptr %0, i64 %11, !dbg !8 + %13 = load i64, ptr %12, align 4, !dbg !8 + %14 = urem i64 %last_valid, 64, !dbg !8 + %15 = add i64 %14, 1, !dbg !8 + %16 = sub i64 64, %15, !dbg !8 + %17 = lshr i64 -1, %16, !dbg !8 + %18 = and i64 %13, %17, !dbg !8 + store i64 %18, ptr %12, align 4, !dbg !8 + %19 = udiv i64 %1, 64, !dbg !8 + %20 = udiv i64 %last_valid, 64, !dbg !8 + %21 = sub i64 %20, %19, !dbg !8 + %22 = add i64 %21, 1, !dbg !8 + %23 = alloca i64, align 8, !dbg !8 + store i64 0, ptr %23, align 4, !dbg !8 + br label %24, !dbg !8 24: ; preds = %mask_block_ok, %3 - %25 = load i64, ptr %23, align 4 - %26 = icmp ult i64 %25, %22 - br i1 %26, label %27, label %33 + %25 = load i64, ptr %23, align 4, !dbg !8 + %26 = icmp ult i64 %25, %22, !dbg !8 + br i1 %26, label %27, label %33, !dbg !8 27: ; preds = %24 - %28 = load i64, ptr %23, align 4 - %29 = add i64 %28, %19 - %30 = getelementptr inbounds i64, ptr %0, i64 %29 - %31 = load i64, ptr %30, align 4 - %32 = icmp eq i64 %31, 0 - br i1 %32, label %mask_block_ok, label %mask_block_err + %28 = load i64, ptr %23, align 4, !dbg !8 + %29 = add i64 %28, %19, !dbg !8 + %30 = getelementptr inbounds i64, ptr %0, i64 %29, !dbg !8 + %31 = load i64, ptr %30, align 4, !dbg !8 + %32 = icmp eq i64 %31, 0, !dbg !8 + br i1 %32, label %mask_block_ok, label %mask_block_err, !dbg !8 33: ; preds = %24 - ret void + ret void, !dbg !8 mask_block_err: ; preds = %27 - %34 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %34 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + unreachable, !dbg !8 mask_block_ok: ; preds = %27 - %35 = add i64 %28, 1 - store i64 %35, ptr %23, align 4 - br label %24 + %35 = add i64 %28, 1, !dbg !8 + store i64 %35, ptr %23, align 4, !dbg !8 + br label %24, !dbg !8 } declare i32 @printf(ptr, ...) @@ -130,3 +130,18 @@ declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } attributes #1 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/LClAphFGIyrhv/sHeDgUnyeIVwAutK/HaZEPS/wPXPeycUvnujGxZK/RCTcNfsTEG") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 32551, column: 131, scope: !3) +!10 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@llvm21.snap index a66761e8ba..2b8bde943c 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@llvm21.snap @@ -8,43 +8,43 @@ source_filename = "test_context" @0 = private unnamed_addr constant [34 x i8] c"Array element is already borrowed\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 1, ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 2, ptr %6, align 4 - %array_ptr = extractvalue { ptr, ptr, i64 } %4, 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %4, 1 - %array_offset = extractvalue { ptr, ptr, i64 } %4, 2 - %7 = icmp ult i64 1, 2 - br i1 %7, label %9, label %8 + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !7 + %0 = call ptr @malloc(i64 %array_size), !dbg !7 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !7 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !7 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !7 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !7 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !7 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !7 + store i64 1, ptr %5, align 4, !dbg !7 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !7 + store i64 2, ptr %6, align 4, !dbg !7 + %array_ptr = extractvalue { ptr, ptr, i64 } %4, 0, !dbg !8 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %4, 1, !dbg !8 + %array_offset = extractvalue { ptr, ptr, i64 } %4, 2, !dbg !8 + %7 = icmp ult i64 1, 2, !dbg !8 + br i1 %7, label %9, label %8, !dbg !8 8: ; preds = %entry_block - br label %14 + br label %14, !dbg !8 9: ; preds = %entry_block - %10 = add i64 1, %array_offset - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %10) - %11 = getelementptr inbounds i64, ptr %array_ptr, i64 %10 - %12 = load i64, ptr %11, align 4 - %13 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %12, 1 - br label %14 + %10 = add i64 1, %array_offset, !dbg !8 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %10), !dbg !8 + %11 = getelementptr inbounds i64, ptr %array_ptr, i64 %10, !dbg !8 + %12 = load i64, ptr %11, align 4, !dbg !8 + %13 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %12, 1, !dbg !8 + br label %14, !dbg !8 14: ; preds = %8, %9 - %"0.0" = phi { i1, i64 } [ %13, %9 ], [ { i1 false, i64 poison }, %8 ] - %array_ptr8 = extractvalue { ptr, ptr, i64 } %4, 0 - call void @free(ptr %array_ptr8) + %"0.0" = phi { i1, i64 } [ %13, %9 ], [ { i1 false, i64 poison }, %8 ], !dbg !8 + %array_ptr8 = extractvalue { ptr, ptr, i64 } %4, 0, !dbg !9 + call void @free(ptr %array_ptr8), !dbg !9 ret void } @@ -54,21 +54,21 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_mask_check_not_borrowed(ptr %0, i64 %1) { - %3 = udiv i64 %1, 64 - %4 = getelementptr inbounds i64, ptr %0, i64 %3 - %5 = load i64, ptr %4, align 4 - %6 = urem i64 %1, 64 - %7 = lshr i64 %5, %6 - %8 = trunc i64 %7 to i1 - br i1 %8, label %panic, label %ok + %3 = udiv i64 %1, 64, !dbg !8 + %4 = getelementptr inbounds i64, ptr %0, i64 %3, !dbg !8 + %5 = load i64, ptr %4, align 4, !dbg !8 + %6 = urem i64 %1, 64, !dbg !8 + %7 = lshr i64 %5, %6, !dbg !8 + %8 = trunc i64 %7 to i1, !dbg !8 + br i1 %8, label %panic, label %ok, !dbg !8 panic: ; preds = %2 - %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + unreachable, !dbg !8 ok: ; preds = %2 - ret void + ret void, !dbg !8 } declare i32 @printf(ptr, ...) @@ -78,3 +78,17 @@ declare void @abort() declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) +!9 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@pre-mem2reg@llvm21.snap index 285e5cad33..7412c364dc 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__borrow_array__test__emit_get@pre-mem2reg@llvm21.snap @@ -8,15 +8,15 @@ source_filename = "test_context" @0 = private unnamed_addr constant [34 x i8] c"Array element is already borrowed\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"7_0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 %"8_0" = alloca { ptr, ptr, i64 }, align 8 %"9_0" = alloca { i1, i64 }, align 8 %"9_1" = alloca { ptr, ptr, i64 }, align 8 - %"0" = alloca { i1, i64 }, align 8 - %"1" = alloca { ptr, ptr, i64 }, align 8 + %"0" = alloca { i1, i64 }, align 8, !dbg !7 + %"1" = alloca { ptr, ptr, i64 }, align 8, !dbg !7 br label %entry_block entry_block: ; preds = %alloca_block @@ -24,49 +24,49 @@ entry_block: ; preds = %alloca_block store i64 1, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load i64, ptr %"7_0", align 4 - %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64) - %0 = call ptr @malloc(i64 %array_size) - %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)) - call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false) - %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0 - %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1 - %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2 - %5 = getelementptr inbounds i64, ptr %0, i64 0 - store i64 %"5_01", ptr %5, align 4 - %6 = getelementptr inbounds i64, ptr %0, i64 1 - store i64 %"7_02", ptr %6, align 4 - store { ptr, ptr, i64 } %4, ptr %"8_0", align 8 + %array_size = mul i64 2, ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), !dbg !8 + %0 = call ptr @malloc(i64 %array_size), !dbg !8 + %1 = call ptr @malloc(i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64)), !dbg !8 + call void @llvm.memset.p0.i64(ptr %1, i8 0, i64 ptrtoint (ptr getelementptr (i64, ptr null, i32 1) to i64), i1 false), !dbg !8 + %2 = insertvalue { ptr, ptr, i64 } poison, ptr %0, 0, !dbg !8 + %3 = insertvalue { ptr, ptr, i64 } %2, ptr %1, 1, !dbg !8 + %4 = insertvalue { ptr, ptr, i64 } %3, i64 0, 2, !dbg !8 + %5 = getelementptr inbounds i64, ptr %0, i64 0, !dbg !8 + store i64 %"5_01", ptr %5, align 4, !dbg !8 + %6 = getelementptr inbounds i64, ptr %0, i64 1, !dbg !8 + store i64 %"7_02", ptr %6, align 4, !dbg !8 + store { ptr, ptr, i64 } %4, ptr %"8_0", align 8, !dbg !8 %"8_03" = load { ptr, ptr, i64 }, ptr %"8_0", align 8 %"5_04" = load i64, ptr %"5_0", align 4 - %array_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 0 - %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 1 - %array_offset = extractvalue { ptr, ptr, i64 } %"8_03", 2 - %7 = icmp ult i64 %"5_04", 2 - br i1 %7, label %9, label %8 + %array_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 0, !dbg !7 + %array_mask_ptr = extractvalue { ptr, ptr, i64 } %"8_03", 1, !dbg !7 + %array_offset = extractvalue { ptr, ptr, i64 } %"8_03", 2, !dbg !7 + %7 = icmp ult i64 %"5_04", 2, !dbg !7 + br i1 %7, label %9, label %8, !dbg !7 8: ; preds = %entry_block - store { i1, i64 } { i1 false, i64 poison }, ptr %"0", align 4 - store { ptr, ptr, i64 } %"8_03", ptr %"1", align 8 - br label %14 + store { i1, i64 } { i1 false, i64 poison }, ptr %"0", align 4, !dbg !7 + store { ptr, ptr, i64 } %"8_03", ptr %"1", align 8, !dbg !7 + br label %14, !dbg !7 9: ; preds = %entry_block - %10 = add i64 %"5_04", %array_offset - call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %10) - %11 = getelementptr inbounds i64, ptr %array_ptr, i64 %10 - %12 = load i64, ptr %11, align 4 - %13 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %12, 1 - store { i1, i64 } %13, ptr %"0", align 4 - store { ptr, ptr, i64 } %"8_03", ptr %"1", align 8 - br label %14 + %10 = add i64 %"5_04", %array_offset, !dbg !7 + call void @__barray_mask_check_not_borrowed(ptr %array_mask_ptr, i64 %10), !dbg !7 + %11 = getelementptr inbounds i64, ptr %array_ptr, i64 %10, !dbg !7 + %12 = load i64, ptr %11, align 4, !dbg !7 + %13 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %12, 1, !dbg !7 + store { i1, i64 } %13, ptr %"0", align 4, !dbg !7 + store { ptr, ptr, i64 } %"8_03", ptr %"1", align 8, !dbg !7 + br label %14, !dbg !7 14: ; preds = %8, %9 - %"05" = load { i1, i64 }, ptr %"0", align 4 - %"16" = load { ptr, ptr, i64 }, ptr %"1", align 8 - store { i1, i64 } %"05", ptr %"9_0", align 4 - store { ptr, ptr, i64 } %"16", ptr %"9_1", align 8 + %"05" = load { i1, i64 }, ptr %"0", align 4, !dbg !7 + %"16" = load { ptr, ptr, i64 }, ptr %"1", align 8, !dbg !7 + store { i1, i64 } %"05", ptr %"9_0", align 4, !dbg !7 + store { ptr, ptr, i64 } %"16", ptr %"9_1", align 8, !dbg !7 %"9_17" = load { ptr, ptr, i64 }, ptr %"9_1", align 8 - %array_ptr8 = extractvalue { ptr, ptr, i64 } %"9_17", 0 - call void @free(ptr %array_ptr8) + %array_ptr8 = extractvalue { ptr, ptr, i64 } %"9_17", 0, !dbg !9 + call void @free(ptr %array_ptr8), !dbg !9 ret void } @@ -76,21 +76,21 @@ declare ptr @malloc(i64) declare void @llvm.memset.p0.i64(ptr writeonly captures(none), i8, i64, i1 immarg) #0 define internal void @__barray_mask_check_not_borrowed(ptr %0, i64 %1) { - %3 = udiv i64 %1, 64 - %4 = getelementptr inbounds i64, ptr %0, i64 %3 - %5 = load i64, ptr %4, align 4 - %6 = urem i64 %1, 64 - %7 = lshr i64 %5, %6 - %8 = trunc i64 %7 to i1 - br i1 %8, label %panic, label %ok + %3 = udiv i64 %1, 64, !dbg !7 + %4 = getelementptr inbounds i64, ptr %0, i64 %3, !dbg !7 + %5 = load i64, ptr %4, align 4, !dbg !7 + %6 = urem i64 %1, 64, !dbg !7 + %7 = lshr i64 %5, %6, !dbg !7 + %8 = trunc i64 %7 to i1, !dbg !7 + br i1 %8, label %panic, label %ok, !dbg !7 panic: ; preds = %2 - %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - unreachable + %9 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !7 + call void @abort(), !dbg !7 + unreachable, !dbg !7 ok: ; preds = %2 - ret void + ret void, !dbg !7 } declare i32 @printf(ptr, ...) @@ -100,3 +100,17 @@ declare void @abort() declare void @free(ptr) attributes #0 = { nocallback nofree nounwind willreturn memory(argmem: write) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lVLClAphFGIyrhvZsHeDgUnyeIVwAut") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 5388, column: 404, scope: !3) +!8 = !DILocation(line: 27062, column: 402, scope: !3) +!9 = !DILocation(line: 10060, column: 368, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@llvm21.snap index b54f24773f..8fd70e31a3 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -26,3 +26,15 @@ entry_block: ; preds = %alloca_block declare ptr @__rt__list__new(i64, i64, i64, ptr) declare void @__rt__list__push(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@pre-mem2reg@llvm21.snap index dbfbe7445c..621a2cabb2 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__const@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -32,3 +32,15 @@ entry_block: ; preds = %alloca_block declare ptr @__rt__list__new(i64, i64, i64, ptr) declare void @__rt__list__push(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@llvm21.snap index 29131adf63..cb716ccc7f 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@llvm21.snap @@ -5,17 +5,35 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i16 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i16 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = alloca i16, align 2 - %3 = call i1 @__rt__list__get(ptr %0, i64 %1, ptr %2) - %4 = load i16, ptr %2, align 2 - %5 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %4, 1 - %6 = select i1 %3, { i1, i16 } %5, { i1, i16 } { i1 false, i16 poison } + %2 = alloca i16, align 2, !dbg !13 + %3 = call i1 @__rt__list__get(ptr %0, i64 %1, ptr %2), !dbg !13 + %4 = load i16, ptr %2, align 2, !dbg !13 + %5 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %4, 1, !dbg !13 + %6 = select i1 %3, { i1, i16 } %5, { i1, i16 } { i1 false, i16 poison }, !dbg !13 ret { i1, i16 } %6 } declare i1 @__rt__list__get(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !11, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!11 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@pre-mem2reg@llvm21.snap index d4df4fd3d9..371b43b93f 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__get@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i16 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i16 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, i16 }, align 8 %"2_0" = alloca ptr, align 8 @@ -18,12 +18,12 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i64, ptr %"2_1", align 4 - %2 = alloca i16, align 2 - %3 = call i1 @__rt__list__get(ptr %"2_01", i64 %"2_12", ptr %2) - %4 = load i16, ptr %2, align 2 - %5 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %4, 1 - %6 = select i1 %3, { i1, i16 } %5, { i1, i16 } { i1 false, i16 poison } - store { i1, i16 } %6, ptr %"4_0", align 2 + %2 = alloca i16, align 2, !dbg !13 + %3 = call i1 @__rt__list__get(ptr %"2_01", i64 %"2_12", ptr %2), !dbg !13 + %4 = load i16, ptr %2, align 2, !dbg !13 + %5 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %4, 1, !dbg !13 + %6 = select i1 %3, { i1, i16 } %5, { i1, i16 } { i1 false, i16 poison }, !dbg !13 + store { i1, i16 } %6, ptr %"4_0", align 2, !dbg !13 %"4_03" = load { i1, i16 }, ptr %"4_0", align 2 store { i1, i16 } %"4_03", ptr %"0", align 2 %"04" = load { i1, i16 }, ptr %"0", align 2 @@ -31,3 +31,21 @@ entry_block: ; preds = %alloca_block } declare i1 @__rt__list__get(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !11, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!11 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@llvm21.snap index d30df6d996..7907f1b363 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@llvm21.snap @@ -5,19 +5,39 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %3 = alloca i16, align 2 - store i16 %2, ptr %3, align 2 - %4 = call i1 @__rt__list__insert(ptr %0, i64 %1, ptr %3) - %5 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %2, 1 - %6 = select i1 %4, { i1, i16 } { i1 true, i16 poison }, { i1, i16 } %5 + %3 = alloca i16, align 2, !dbg !15 + store i16 %2, ptr %3, align 2, !dbg !15 + %4 = call i1 @__rt__list__insert(ptr %0, i64 %1, ptr %3), !dbg !15 + %5 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %2, 1, !dbg !15 + %6 = select i1 %4, { i1, i16 } { i1 true, i16 poison }, { i1, i16 } %5, !dbg !15 %mrv = insertvalue { ptr, { i1, i16 } } poison, ptr %0, 0 %mrv8 = insertvalue { ptr, { i1, i16 } } %mrv, { i1, i16 } %6, 1 ret { ptr, { i1, i16 } } %mrv8 } declare i1 @__rt__list__insert(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !14, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@pre-mem2reg@llvm21.snap index fe12329ff3..ce94ef41e9 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__insert@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"1" = alloca { i1, i16 }, align 8 @@ -23,13 +23,13 @@ entry_block: ; preds = %alloca_block %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i64, ptr %"2_1", align 4 %"2_23" = load i16, ptr %"2_2", align 2 - %3 = alloca i16, align 2 - store i16 %"2_23", ptr %3, align 2 - %4 = call i1 @__rt__list__insert(ptr %"2_01", i64 %"2_12", ptr %3) - %5 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %"2_23", 1 - %6 = select i1 %4, { i1, i16 } { i1 true, i16 poison }, { i1, i16 } %5 - store ptr %"2_01", ptr %"4_0", align 8 - store { i1, i16 } %6, ptr %"4_1", align 2 + %3 = alloca i16, align 2, !dbg !15 + store i16 %"2_23", ptr %3, align 2, !dbg !15 + %4 = call i1 @__rt__list__insert(ptr %"2_01", i64 %"2_12", ptr %3), !dbg !15 + %5 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %"2_23", 1, !dbg !15 + %6 = select i1 %4, { i1, i16 } { i1 true, i16 poison }, { i1, i16 } %5, !dbg !15 + store ptr %"2_01", ptr %"4_0", align 8, !dbg !15 + store { i1, i16 } %6, ptr %"4_1", align 2, !dbg !15 %"4_04" = load ptr, ptr %"4_0", align 8 %"4_15" = load { i1, i16 }, ptr %"4_1", align 2 store ptr %"4_04", ptr %"0", align 8 @@ -42,3 +42,23 @@ entry_block: ; preds = %alloca_block } declare i1 @__rt__list__insert(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !14, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@llvm21.snap index 14189cd439..95f3d7097e 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@llvm21.snap @@ -5,15 +5,31 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, i64 } @_hl.main.1(ptr %0) { +define internal { ptr, i64 } @_hl.main.1(ptr %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = call i64 @__rt__list__length(ptr %0) + %1 = call i64 @__rt__list__length(ptr %0), !dbg !11 %mrv = insertvalue { ptr, i64 } poison, ptr %0, 0 %mrv6 = insertvalue { ptr, i64 } %mrv, i64 %1, 1 ret { ptr, i64 } %mrv6 } declare i64 @__rt__list__length(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, i64 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!11 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@pre-mem2reg@llvm21.snap index 253f314894..d09f0fe277 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__length@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, i64 } @_hl.main.1(ptr %0) { +define internal { ptr, i64 } @_hl.main.1(ptr %0) !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"1" = alloca i64, align 8 @@ -17,9 +17,9 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr %0, ptr %"2_0", align 8 %"2_01" = load ptr, ptr %"2_0", align 8 - %1 = call i64 @__rt__list__length(ptr %"2_01") - store ptr %"2_01", ptr %"4_0", align 8 - store i64 %1, ptr %"4_1", align 4 + %1 = call i64 @__rt__list__length(ptr %"2_01"), !dbg !11 + store ptr %"2_01", ptr %"4_0", align 8, !dbg !11 + store i64 %1, ptr %"4_1", align 4, !dbg !11 %"4_02" = load ptr, ptr %"4_0", align 8 %"4_13" = load i64, ptr %"4_1", align 4 store ptr %"4_02", ptr %"0", align 8 @@ -32,3 +32,19 @@ entry_block: ; preds = %alloca_block } declare i64 @__rt__list__length(ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, i64 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!11 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@llvm21.snap index 4b36ca1f58..2932821fc4 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@llvm21.snap @@ -5,19 +5,38 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = alloca i16, align 2 - %2 = call i1 @__rt__list__pop(ptr %0, ptr %1) - %3 = load i16, ptr %1, align 2 - %4 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %3, 1 - %5 = select i1 %2, { i1, i16 } %4, { i1, i16 } { i1 false, i16 poison } + %1 = alloca i16, align 2, !dbg !14 + %2 = call i1 @__rt__list__pop(ptr %0, ptr %1), !dbg !14 + %3 = load i16, ptr %1, align 2, !dbg !14 + %4 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %3, 1, !dbg !14 + %5 = select i1 %2, { i1, i16 } %4, { i1, i16 } { i1 false, i16 poison }, !dbg !14 %mrv = insertvalue { ptr, { i1, i16 } } poison, ptr %0, 0 %mrv6 = insertvalue { ptr, { i1, i16 } } %mrv, { i1, i16 } %5, 1 ret { ptr, { i1, i16 } } %mrv6 } declare i1 @__rt__list__pop(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@pre-mem2reg@llvm21.snap index f3f43906cb..310d60a507 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__pop@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0) !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"1" = alloca { i1, i16 }, align 8 @@ -17,13 +17,13 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr %0, ptr %"2_0", align 8 %"2_01" = load ptr, ptr %"2_0", align 8 - %1 = alloca i16, align 2 - %2 = call i1 @__rt__list__pop(ptr %"2_01", ptr %1) - %3 = load i16, ptr %1, align 2 - %4 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %3, 1 - %5 = select i1 %2, { i1, i16 } %4, { i1, i16 } { i1 false, i16 poison } - store ptr %"2_01", ptr %"4_0", align 8 - store { i1, i16 } %5, ptr %"4_1", align 2 + %1 = alloca i16, align 2, !dbg !14 + %2 = call i1 @__rt__list__pop(ptr %"2_01", ptr %1), !dbg !14 + %3 = load i16, ptr %1, align 2, !dbg !14 + %4 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %3, 1, !dbg !14 + %5 = select i1 %2, { i1, i16 } %4, { i1, i16 } { i1 false, i16 poison }, !dbg !14 + store ptr %"2_01", ptr %"4_0", align 8, !dbg !14 + store { i1, i16 } %5, ptr %"4_1", align 2, !dbg !14 %"4_02" = load ptr, ptr %"4_0", align 8 %"4_13" = load { i1, i16 }, ptr %"4_1", align 2 store ptr %"4_02", ptr %"0", align 8 @@ -36,3 +36,22 @@ entry_block: ; preds = %alloca_block } declare i1 @__rt__list__pop(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@llvm21.snap index 3e9731f79f..02f86effe0 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@llvm21.snap @@ -5,15 +5,29 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.1(ptr %0, i16 %1) { +define internal ptr @_hl.main.1(ptr %0, i16 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = alloca i16, align 2 - store i16 %1, ptr %2, align 2 - call void @__rt__list__push(ptr %0, ptr %2) + %2 = alloca i16, align 2, !dbg !9 + store i16 %1, ptr %2, align 2, !dbg !9 + call void @__rt__list__push(ptr %0, ptr %2), !dbg !9 ret ptr %0 } declare void @__rt__list__push(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !8} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!8 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@pre-mem2reg@llvm21.snap index 04f7d10b31..47c056b732 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__push@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal ptr @_hl.main.1(ptr %0, i16 %1) { +define internal ptr @_hl.main.1(ptr %0, i16 %1) !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"2_0" = alloca ptr, align 8 @@ -18,10 +18,10 @@ entry_block: ; preds = %alloca_block store i16 %1, ptr %"2_1", align 2 %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i16, ptr %"2_1", align 2 - %2 = alloca i16, align 2 - store i16 %"2_12", ptr %2, align 2 - call void @__rt__list__push(ptr %"2_01", ptr %2) - store ptr %"2_01", ptr %"4_0", align 8 + %2 = alloca i16, align 2, !dbg !9 + store i16 %"2_12", ptr %2, align 2, !dbg !9 + call void @__rt__list__push(ptr %"2_01", ptr %2), !dbg !9 + store ptr %"2_01", ptr %"4_0", align 8, !dbg !9 %"4_03" = load ptr, ptr %"4_0", align 8 store ptr %"4_03", ptr %"0", align 8 %"04" = load ptr, ptr %"0", align 8 @@ -29,3 +29,17 @@ entry_block: ; preds = %alloca_block } declare void @__rt__list__push(ptr, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !8} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!8 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@llvm21.snap index b84dfcecdd..45dcca2e93 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@llvm21.snap @@ -5,21 +5,41 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %3 = alloca i16, align 2 - store i16 %2, ptr %3, align 2 - %4 = call i1 @__rt__list__set(ptr %0, i64 %1, ptr %3) - %5 = load i16, ptr %3, align 2 - %6 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %5, 1 - %7 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %2, 1 - %8 = select i1 %4, { i1, i16 } %7, { i1, i16 } %6 + %3 = alloca i16, align 2, !dbg !15 + store i16 %2, ptr %3, align 2, !dbg !15 + %4 = call i1 @__rt__list__set(ptr %0, i64 %1, ptr %3), !dbg !15 + %5 = load i16, ptr %3, align 2, !dbg !15 + %6 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %5, 1, !dbg !15 + %7 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %2, 1, !dbg !15 + %8 = select i1 %4, { i1, i16 } %7, { i1, i16 } %6, !dbg !15 %mrv = insertvalue { ptr, { i1, i16 } } poison, ptr %0, 0 %mrv8 = insertvalue { ptr, { i1, i16 } } %mrv, { i1, i16 } %8, 1 ret { ptr, { i1, i16 } } %mrv8 } declare i1 @__rt__list__set(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !14, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@pre-mem2reg@llvm21.snap index cb218a2d64..8828838f46 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__list__test__set@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) { +define internal { ptr, { i1, i16 } } @_hl.main.1(ptr %0, i64 %1, i16 %2) !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"1" = alloca { i1, i16 }, align 8 @@ -23,15 +23,15 @@ entry_block: ; preds = %alloca_block %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i64, ptr %"2_1", align 4 %"2_23" = load i16, ptr %"2_2", align 2 - %3 = alloca i16, align 2 - store i16 %"2_23", ptr %3, align 2 - %4 = call i1 @__rt__list__set(ptr %"2_01", i64 %"2_12", ptr %3) - %5 = load i16, ptr %3, align 2 - %6 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %5, 1 - %7 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %"2_23", 1 - %8 = select i1 %4, { i1, i16 } %7, { i1, i16 } %6 - store ptr %"2_01", ptr %"4_0", align 8 - store { i1, i16 } %8, ptr %"4_1", align 2 + %3 = alloca i16, align 2, !dbg !15 + store i16 %"2_23", ptr %3, align 2, !dbg !15 + %4 = call i1 @__rt__list__set(ptr %"2_01", i64 %"2_12", ptr %3), !dbg !15 + %5 = load i16, ptr %3, align 2, !dbg !15 + %6 = insertvalue { i1, i16 } { i1 false, i16 poison }, i16 %5, 1, !dbg !15 + %7 = insertvalue { i1, i16 } { i1 true, i16 poison }, i16 %"2_23", 1, !dbg !15 + %8 = select i1 %4, { i1, i16 } %7, { i1, i16 } %6, !dbg !15 + store ptr %"2_01", ptr %"4_0", align 8, !dbg !15 + store { i1, i16 } %8, ptr %"4_1", align 2, !dbg !15 %"4_04" = load ptr, ptr %"4_0", align 8 %"4_15" = load { i1, i16 }, ptr %"4_1", align 2 store ptr %"4_04", ptr %"0", align 8 @@ -44,3 +44,23 @@ entry_block: ; preds = %alloca_block } declare i1 @__rt__list__set(ptr, i64, ptr) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !14, !13} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ ptr, { i1, i16 } }", file: !2, size: 10, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i16 }", file: !2, size: 2, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@llvm21.snap index 38d3385687..447e6354b2 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@llvm21.snap @@ -17,12 +17,25 @@ source_filename = "test_context" @sa.inner.1e8aada3.0 = constant { i64, [9 x i64] } { i64 9, [9 x i64] [i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9] } @sa.outer.e55b610a.0 = constant { i64, [10 x ptr] } { i64 10, [10 x ptr] [ptr @sa.inner.6acc1b76.0, ptr @sa.inner.e637bb5.0, ptr @sa.inner.2b6593f.0, ptr @sa.inner.1b9ad7c.0, ptr @sa.inner.e67fbfa4.0, ptr @sa.inner.15dc27f6.0, ptr @sa.inner.c43a2bb2.0, ptr @sa.inner.7f5d5e16.0, ptr @sa.inner.a0bc9c53.0, ptr @sa.inner.1e8aada3.0] } -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = getelementptr inbounds { i64, [0 x ptr] }, ptr @sa.outer.e55b610a.0, i32 0, i32 0 - %1 = load i64, ptr %0, align 4 + %0 = getelementptr inbounds { i64, [0 x ptr] }, ptr @sa.outer.e55b610a.0, i32 0, i32 0, !dbg !8 + %1 = load i64, ptr %0, align 4, !dbg !8 ret i64 %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@pre-mem2reg@llvm21.snap index 65ffc76d07..4dc60a9e10 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__emit_static_array_of_static_array@pre-mem2reg@llvm21.snap @@ -17,7 +17,7 @@ source_filename = "test_context" @sa.inner.1e8aada3.0 = constant { i64, [9 x i64] } { i64 9, [9 x i64] [i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9, i64 9] } @sa.outer.e55b610a.0 = constant { i64, [10 x ptr] } { i64 10, [10 x ptr] [ptr @sa.inner.6acc1b76.0, ptr @sa.inner.e637bb5.0, ptr @sa.inner.2b6593f.0, ptr @sa.inner.1b9ad7c.0, ptr @sa.inner.e67fbfa4.0, ptr @sa.inner.15dc27f6.0, ptr @sa.inner.c43a2bb2.0, ptr @sa.inner.7f5d5e16.0, ptr @sa.inner.a0bc9c53.0, ptr @sa.inner.1e8aada3.0] } -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"5_0" = alloca ptr, align 8 @@ -27,11 +27,24 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr @sa.outer.e55b610a.0, ptr %"5_0", align 8 %"5_01" = load ptr, ptr %"5_0", align 8 - %0 = getelementptr inbounds { i64, [0 x ptr] }, ptr %"5_01", i32 0, i32 0 - %1 = load i64, ptr %0, align 4 - store i64 %1, ptr %"6_0", align 4 + %0 = getelementptr inbounds { i64, [0 x ptr] }, ptr %"5_01", i32 0, i32 0, !dbg !8 + %1 = load i64, ptr %0, align 4, !dbg !8 + store i64 %1, ptr %"6_0", align 4, !dbg !8 %"6_02" = load i64, ptr %"6_0", align 4 store i64 %"6_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_0.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_0.snap index 59bbf8007b..2af7aa67e8 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_0.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_0.snap @@ -7,10 +7,22 @@ source_filename = "test_context" @sa.a.97cb22bf.0 = constant { i64, [10 x i64] } { i64 10, [10 x i64] [i64 0, i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret ptr @sa.a.97cb22bf.0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_1.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_1.snap index 34fd7985d0..7b651795f9 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_1.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_1.snap @@ -7,10 +7,22 @@ source_filename = "test_context" @sa.b.150c532c.0 = constant { i64, [10 x double] } { i64 10, [10 x double] [double 0.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 4.000000e+00, double 5.000000e+00, double 6.000000e+00, double 7.000000e+00, double 8.000000e+00, double 9.000000e+00] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret ptr @sa.b.150c532c.0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_2.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_2.snap index 0401cf0b50..5d905f3f70 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_2.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_2.snap @@ -7,10 +7,22 @@ source_filename = "test_context" @sa.c.d2dddd66.0 = constant { i64, [10 x i1] } { i64 10, [10 x i1] [i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret ptr @sa.c.d2dddd66.0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_3.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_3.snap index e682c3b6ce..0f83d9c562 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_3.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@llvm21_3.snap @@ -7,10 +7,22 @@ source_filename = "test_context" @sa.d.eee08a59.0 = constant { i64, [10 x { i1, i64 }] } { i64 10, [10 x { i1, i64 }] [{ i1, i64 } { i1 true, i64 0 }, { i1, i64 } { i1 true, i64 1 }, { i1, i64 } { i1 true, i64 2 }, { i1, i64 } { i1 true, i64 3 }, { i1, i64 } { i1 true, i64 4 }, { i1, i64 } { i1 true, i64 5 }, { i1, i64 } { i1 true, i64 6 }, { i1, i64 } { i1 true, i64 7 }, { i1, i64 } { i1 true, i64 8 }, { i1, i64 } { i1 true, i64 9 }] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret ptr @sa.d.eee08a59.0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_0.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_0.snap index 6f341ffa4d..6261dd6b44 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_0.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_0.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @sa.a.97cb22bf.0 = constant { i64, [10 x i64] } { i64 10, [10 x i64] [i64 0, i64 1, i64 2, i64 3, i64 4, i64 5, i64 6, i64 7, i64 8, i64 9] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -20,3 +20,15 @@ entry_block: ; preds = %alloca_block %"02" = load ptr, ptr %"0", align 8 ret ptr %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_1.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_1.snap index e89900d47c..09861f6083 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_1.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_1.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @sa.b.150c532c.0 = constant { i64, [10 x double] } { i64 10, [10 x double] [double 0.000000e+00, double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 4.000000e+00, double 5.000000e+00, double 6.000000e+00, double 7.000000e+00, double 8.000000e+00, double 9.000000e+00] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -20,3 +20,15 @@ entry_block: ; preds = %alloca_block %"02" = load ptr, ptr %"0", align 8 ret ptr %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_2.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_2.snap index 3fb020a531..24170a8f06 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_2.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_2.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @sa.c.d2dddd66.0 = constant { i64, [10 x i1] } { i64 10, [10 x i1] [i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false, i1 true, i1 false] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -20,3 +20,15 @@ entry_block: ; preds = %alloca_block %"02" = load ptr, ptr %"0", align 8 ret ptr %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_3.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_3.snap index 869b5a847f..c8ebbcd502 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_3.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_const_codegen@pre-mem2reg@llvm21_3.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @sa.d.eee08a59.0 = constant { i64, [10 x { i1, i64 }] } { i64 10, [10 x { i1, i64 }] [{ i1, i64 } { i1 true, i64 0 }, { i1, i64 } { i1 true, i64 1 }, { i1, i64 } { i1 true, i64 2 }, { i1, i64 } { i1 true, i64 3 }, { i1, i64 } { i1 true, i64 4 }, { i1, i64 } { i1 true, i64 5 }, { i1, i64 } { i1 true, i64 6 }, { i1, i64 } { i1 true, i64 7 }, { i1, i64 } { i1 true, i64 8 }, { i1, i64 } { i1 true, i64 9 }] } -define internal ptr @_hl.main.1() { +define internal ptr @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca ptr, align 8 %"5_0" = alloca ptr, align 8 @@ -20,3 +20,15 @@ entry_block: ; preds = %alloca_block %"02" = load ptr, ptr %"0", align 8 ret ptr %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_0.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_0.snap index 14951b66a5..c1a9a9602e 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_0.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_0.snap @@ -5,26 +5,43 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i64 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i64 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block static_array_get_out_of_bounds: ; preds = %entry_block - br label %static_array_get_exit + br label %static_array_get_exit, !dbg !12 static_array_get_in_bounds: ; preds = %entry_block - %2 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 1, i64 %1 - %3 = load i64, ptr %2, align 4 - %4 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %3, 1 - br label %static_array_get_exit + %2 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 1, i64 %1, !dbg !12 + %3 = load i64, ptr %2, align 4, !dbg !12 + %4 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %3, 1, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_exit: ; preds = %static_array_get_in_bounds, %static_array_get_out_of_bounds - %"03.0" = phi { i1, i64 } [ %4, %static_array_get_in_bounds ], [ { i1 false, i64 poison }, %static_array_get_out_of_bounds ] + %"03.0" = phi { i1, i64 } [ %4, %static_array_get_in_bounds ], [ { i1 false, i64 poison }, %static_array_get_out_of_bounds ], !dbg !12 ret { i1, i64 } %"03.0" entry_block: ; preds = %alloca_block - %5 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 0 - %6 = load i64, ptr %5, align 4 - %7 = icmp ult i64 %1, %6 - br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds + %5 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 0, !dbg !12 + %6 = load i64, ptr %5, align 4, !dbg !12 + %7 = icmp ult i64 %1, %6, !dbg !12 + br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds, !dbg !12 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !11, !10} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i64 }", file: !2, size: 8, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!11 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!12 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_1.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_1.snap index 937b9e9cdf..1cfcc8b8d5 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_1.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_1.snap @@ -5,26 +5,43 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i1 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block static_array_get_out_of_bounds: ; preds = %entry_block - br label %static_array_get_exit + br label %static_array_get_exit, !dbg !12 static_array_get_in_bounds: ; preds = %entry_block - %2 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 1, i64 %1 - %3 = load i1, ptr %2, align 1 - %4 = insertvalue { i1, i1 } { i1 true, i1 poison }, i1 %3, 1 - br label %static_array_get_exit + %2 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 1, i64 %1, !dbg !12 + %3 = load i1, ptr %2, align 1, !dbg !12 + %4 = insertvalue { i1, i1 } { i1 true, i1 poison }, i1 %3, 1, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_exit: ; preds = %static_array_get_in_bounds, %static_array_get_out_of_bounds - %"03.0" = phi { i1, i1 } [ %4, %static_array_get_in_bounds ], [ { i1 false, i1 poison }, %static_array_get_out_of_bounds ] + %"03.0" = phi { i1, i1 } [ %4, %static_array_get_in_bounds ], [ { i1 false, i1 poison }, %static_array_get_out_of_bounds ], !dbg !12 ret { i1, i1 } %"03.0" entry_block: ; preds = %alloca_block - %5 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 0 - %6 = load i64, ptr %5, align 4 - %7 = icmp ult i64 %1, %6 - br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds + %5 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 0, !dbg !12 + %6 = load i64, ptr %5, align 4, !dbg !12 + %7 = icmp ult i64 %1, %6, !dbg !12 + br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds, !dbg !12 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !10, !11} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!11 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_2.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_2.snap index b496a2977f..d5b1ec79e6 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_2.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_2.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(ptr %0) { +define internal i64 @_hl.main.1(ptr %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 0 - %2 = load i64, ptr %1, align 4 + %1 = getelementptr inbounds { i64, [0 x i64] }, ptr %0, i32 0, i32 0, !dbg !9 + %2 = load i64, ptr %1, align 4, !dbg !9 ret i64 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_3.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_3.snap index ae0c364c32..81284c75e4 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_3.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@llvm21_3.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(ptr %0) { +define internal i64 @_hl.main.1(ptr %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 0 - %2 = load i64, ptr %1, align 4 + %1 = getelementptr inbounds { i64, [0 x i1] }, ptr %0, i32 0, i32 0, !dbg !9 + %2 = load i64, ptr %1, align 4, !dbg !9 ret i64 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_0.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_0.snap index d9ad5f6a26..2f9c2fb648 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_0.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_0.snap @@ -5,29 +5,29 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i64 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i64 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, i64 }, align 8 %"2_0" = alloca ptr, align 8 %"2_1" = alloca i64, align 8 %"4_0" = alloca { i1, i64 }, align 8 - %"03" = alloca { i1, i64 }, align 8 + %"03" = alloca { i1, i64 }, align 8, !dbg !12 br label %entry_block static_array_get_out_of_bounds: ; preds = %entry_block - store { i1, i64 } { i1 false, i64 poison }, ptr %"03", align 4 - br label %static_array_get_exit + store { i1, i64 } { i1 false, i64 poison }, ptr %"03", align 4, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_in_bounds: ; preds = %entry_block - %2 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 1, i64 %"2_12" - %3 = load i64, ptr %2, align 4 - %4 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %3, 1 - store { i1, i64 } %4, ptr %"03", align 4 - br label %static_array_get_exit + %2 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 1, i64 %"2_12", !dbg !12 + %3 = load i64, ptr %2, align 4, !dbg !12 + %4 = insertvalue { i1, i64 } { i1 true, i64 poison }, i64 %3, 1, !dbg !12 + store { i1, i64 } %4, ptr %"03", align 4, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_exit: ; preds = %static_array_get_in_bounds, %static_array_get_out_of_bounds - %"04" = load { i1, i64 }, ptr %"03", align 4 - store { i1, i64 } %"04", ptr %"4_0", align 4 + %"04" = load { i1, i64 }, ptr %"03", align 4, !dbg !12 + store { i1, i64 } %"04", ptr %"4_0", align 4, !dbg !12 %"4_05" = load { i1, i64 }, ptr %"4_0", align 4 store { i1, i64 } %"4_05", ptr %"0", align 4 %"06" = load { i1, i64 }, ptr %"0", align 4 @@ -38,8 +38,25 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i64, ptr %"2_1", align 4 - %5 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 0 - %6 = load i64, ptr %5, align 4 - %7 = icmp ult i64 %"2_12", %6 - br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds + %5 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 0, !dbg !12 + %6 = load i64, ptr %5, align 4, !dbg !12 + %7 = icmp ult i64 %"2_12", %6, !dbg !12 + br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds, !dbg !12 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !11, !10} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i64 }", file: !2, size: 8, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!11 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!12 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_1.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_1.snap index f2cc9f5355..61626d7865 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_1.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_1.snap @@ -5,29 +5,29 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1(ptr %0, i64 %1) { +define internal { i1, i1 } @_hl.main.1(ptr %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, i1 }, align 8 %"2_0" = alloca ptr, align 8 %"2_1" = alloca i64, align 8 %"4_0" = alloca { i1, i1 }, align 8 - %"03" = alloca { i1, i1 }, align 8 + %"03" = alloca { i1, i1 }, align 8, !dbg !12 br label %entry_block static_array_get_out_of_bounds: ; preds = %entry_block - store { i1, i1 } { i1 false, i1 poison }, ptr %"03", align 1 - br label %static_array_get_exit + store { i1, i1 } { i1 false, i1 poison }, ptr %"03", align 1, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_in_bounds: ; preds = %entry_block - %2 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 1, i64 %"2_12" - %3 = load i1, ptr %2, align 1 - %4 = insertvalue { i1, i1 } { i1 true, i1 poison }, i1 %3, 1 - store { i1, i1 } %4, ptr %"03", align 1 - br label %static_array_get_exit + %2 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 1, i64 %"2_12", !dbg !12 + %3 = load i1, ptr %2, align 1, !dbg !12 + %4 = insertvalue { i1, i1 } { i1 true, i1 poison }, i1 %3, 1, !dbg !12 + store { i1, i1 } %4, ptr %"03", align 1, !dbg !12 + br label %static_array_get_exit, !dbg !12 static_array_get_exit: ; preds = %static_array_get_in_bounds, %static_array_get_out_of_bounds - %"04" = load { i1, i1 }, ptr %"03", align 1 - store { i1, i1 } %"04", ptr %"4_0", align 1 + %"04" = load { i1, i1 }, ptr %"03", align 1, !dbg !12 + store { i1, i1 } %"04", ptr %"4_0", align 1, !dbg !12 %"4_05" = load { i1, i1 }, ptr %"4_0", align 1 store { i1, i1 } %"4_05", ptr %"0", align 1 %"06" = load { i1, i1 }, ptr %"0", align 1 @@ -38,8 +38,25 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load ptr, ptr %"2_0", align 8 %"2_12" = load i64, ptr %"2_1", align 4 - %5 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 0 - %6 = load i64, ptr %5, align 4 - %7 = icmp ult i64 %"2_12", %6 - br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds + %5 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 0, !dbg !12 + %6 = load i64, ptr %5, align 4, !dbg !12 + %7 = icmp ult i64 %"2_12", %6, !dbg !12 + br i1 %7, label %static_array_get_in_bounds, label %static_array_get_out_of_bounds, !dbg !12 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !10, !11} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!11 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!12 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_2.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_2.snap index 48d4c6da80..550404f52d 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_2.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_2.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(ptr %0) { +define internal i64 @_hl.main.1(ptr %0) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca ptr, align 8 @@ -15,11 +15,25 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr %0, ptr %"2_0", align 8 %"2_01" = load ptr, ptr %"2_0", align 8 - %1 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 0 - %2 = load i64, ptr %1, align 4 - store i64 %2, ptr %"4_0", align 4 + %1 = getelementptr inbounds { i64, [0 x i64] }, ptr %"2_01", i32 0, i32 0, !dbg !9 + %2 = load i64, ptr %1, align 4, !dbg !9 + store i64 %2, ptr %"4_0", align 4, !dbg !9 %"4_02" = load i64, ptr %"4_0", align 4 store i64 %"4_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_3.snap b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_3.snap index 12ee0f3862..4332db60bd 100644 --- a/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_3.snap +++ b/hugr-llvm/src/extension/collections/snapshots/hugr_llvm__extension__collections__static_array__test__static_array_op_codegen@pre-mem2reg@llvm21_3.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(ptr %0) { +define internal i64 @_hl.main.1(ptr %0) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca ptr, align 8 @@ -15,11 +15,25 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr %0, ptr %"2_0", align 8 %"2_01" = load ptr, ptr %"2_0", align 8 - %1 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 0 - %2 = load i64, ptr %1, align 4 - store i64 %2, ptr %"4_0", align 4 + %1 = getelementptr inbounds { i64, [0 x i1] }, ptr %"2_01", i32 0, i32 0, !dbg !9 + %2 = load i64, ptr %1, align 4, !dbg !9 + store i64 %2, ptr %"4_0", align 4, !dbg !9 %"4_02" = load i64, ptr %"4_0", align 4 store i64 %"4_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/collections/stack_array.rs b/hugr-llvm/src/extension/collections/stack_array.rs index 285a1ba3ec..abdbf9c7b6 100644 --- a/hugr-llvm/src/extension/collections/stack_array.rs +++ b/hugr-llvm/src/extension/collections/stack_array.rs @@ -773,7 +773,7 @@ mod test { #[rstest] fn emit_all_ops(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { build_all_array_ops(builder.dfg_builder_endo([]).unwrap()) @@ -790,7 +790,7 @@ mod test { #[rstest] fn emit_get(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -809,7 +809,7 @@ mod test { #[rstest] fn emit_clone(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { let us1 = builder.add_load_value(ConstUsize::new(1)); @@ -829,7 +829,7 @@ mod test { #[rstest] fn emit_array_value(mut llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(STD_REG.to_owned()) .with_outs(vec![array_type(2, usize_t())]) .finish(|mut builder| { diff --git a/hugr-llvm/src/extension/collections/static_array.rs b/hugr-llvm/src/extension/collections/static_array.rs index 882fbad9f1..22ac6a062e 100644 --- a/hugr-llvm/src/extension/collections/static_array.rs +++ b/hugr-llvm/src/extension/collections/static_array.rs @@ -402,7 +402,7 @@ mod test { ceb.add_default_static_array_extensions() .add_default_prelude_extensions() }); - let hugr = single_op_hugr(op); + let mut hugr = single_op_hugr(op); check_emission!(hugr, llvm_ctx); } @@ -422,7 +422,7 @@ mod test { .add_float_extensions() }); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([value.get_type()]) .with_extensions(ExtensionRegistry::new(vec![ static_array::EXTENSION.to_owned(), @@ -521,7 +521,7 @@ mod test { ceb.add_default_static_array_extensions() .add_default_prelude_extensions() }); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([usize_t()]) .with_extensions(ExtensionRegistry::new(vec![ static_array::EXTENSION.to_owned(), diff --git a/hugr-llvm/src/extension/conversions.rs b/hugr-llvm/src/extension/conversions.rs index c620d0926c..e5de6889e0 100644 --- a/hugr-llvm/src/extension/conversions.rs +++ b/hugr-llvm/src/extension/conversions.rs @@ -326,7 +326,7 @@ mod test { }); let in_ty = INT_TYPES[log_width as usize].clone(); let out_ty = float64_type(); - let hugr = test_conversion_op(op_name, in_ty, out_ty, log_width); + let mut hugr = test_conversion_op(op_name, in_ty, out_ty, log_width); check_emission!(op_name, hugr, llvm_ctx); } @@ -347,7 +347,7 @@ mod test { }); let in_ty = float64_type(); let out_ty = sum_with_error([INT_TYPES[log_width as usize].clone()]); - let hugr = test_conversion_op(op_name, in_ty, out_ty.into(), log_width); + let mut hugr = test_conversion_op(op_name, in_ty, out_ty.into(), log_width); check_emission!(op_name, hugr, llvm_ctx); } @@ -370,7 +370,7 @@ mod test { .add_float_extensions() .add_conversion_extensions() }); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![in_t]) .with_outs(vec![out_t]) .with_extensions(STD_REG.to_owned()) diff --git a/hugr-llvm/src/extension/float.rs b/hugr-llvm/src/extension/float.rs index 3f7bc9b85f..ca01bd5c53 100644 --- a/hugr-llvm/src/extension/float.rs +++ b/hugr-llvm/src/extension/float.rs @@ -205,7 +205,7 @@ mod test { #[rstest] fn const_float(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_float_extensions); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([float64_type()]) .with_extensions(STD_REG.to_owned()) .finish(|mut builder| { @@ -231,7 +231,7 @@ mod test { #[case::fround(FloatOps::fround)] fn float_operations(mut llvm_ctx: TestContext, #[case] op: FloatOps) { let name: &str = op.into(); - let hugr = test_float_op(op); + let mut hugr = test_float_op(op); llvm_ctx.add_extensions(add_float_extensions); check_emission!(name, hugr, llvm_ctx); } diff --git a/hugr-llvm/src/extension/int.rs b/hugr-llvm/src/extension/int.rs index 390537d497..f674a8ffd7 100644 --- a/hugr-llvm/src/extension/int.rs +++ b/hugr-llvm/src/extension/int.rs @@ -1281,7 +1281,7 @@ mod test { _ => panic!("unexpected number of args to the op!"), }; insta.bind(|| { - let hugr = single_op_hugr(concrete.into()); + let mut hugr = single_op_hugr(concrete.into()); check_emission!(hugr, int_llvm_ctx); }); } @@ -1296,7 +1296,7 @@ mod test { #[case::imod_s("imod_s", 3)] fn test_binop_emission(int_llvm_ctx: TestContext, #[case] op: String, #[case] width: u8) { let ext_op = make_int_op(op.clone(), width); - let hugr = test_binary_int_op(ext_op, width); + let mut hugr = test_binary_int_op(ext_op, width); check_emission!(op.clone(), hugr, int_llvm_ctx); } @@ -1315,7 +1315,7 @@ mod test { let ext_op = int_ops::EXTENSION .instantiate_extension_op(&op, [u64::from(from).into(), u64::from(to).into()]) .unwrap(); - let hugr = test_int_op_with_results::<1>(ext_op, from, None, out_ty); + let mut hugr = test_int_op_with_results::<1>(ext_op, from, None, out_ty); check_emission!( format!("{}_{}_{}", op.clone(), from, to), @@ -1337,7 +1337,7 @@ mod test { let ext_op = int_ops::EXTENSION .instantiate_extension_op(&op, [u64::from(from).into(), u64::from(to).into()]) .unwrap(); - let hugr = test_int_op_with_results::<1>(ext_op, from, None, out_ty.into()); + let mut hugr = test_int_op_with_results::<1>(ext_op, from, None, out_ty.into()); check_emission!( format!("{}_{}_{}", op.clone(), from, to), @@ -1351,7 +1351,7 @@ mod test { #[case::ilt_s("ilt_s", 0)] fn test_cmp_emission(int_llvm_ctx: TestContext, #[case] op: String, #[case] width: u8) { let ext_op = make_int_op(op.clone(), width); - let hugr = test_binary_icmp_op(ext_op, width); + let mut hugr = test_binary_icmp_op(ext_op, width); check_emission!(op.clone(), hugr, int_llvm_ctx); } diff --git a/hugr-llvm/src/extension/logic.rs b/hugr-llvm/src/extension/logic.rs index b382a21408..61f269d0ba 100644 --- a/hugr-llvm/src/extension/logic.rs +++ b/hugr-llvm/src/extension/logic.rs @@ -106,35 +106,35 @@ mod test { #[rstest] fn and(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_logic_extensions); - let hugr = test_logic_op(LogicOp::And, 2); + let mut hugr = test_logic_op(LogicOp::And, 2); check_emission!(hugr, llvm_ctx); } #[rstest] fn or(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_logic_extensions); - let hugr = test_logic_op(LogicOp::Or, 2); + let mut hugr = test_logic_op(LogicOp::Or, 2); check_emission!(hugr, llvm_ctx); } #[rstest] fn eq(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_logic_extensions); - let hugr = test_logic_op(LogicOp::Eq, 2); + let mut hugr = test_logic_op(LogicOp::Eq, 2); check_emission!(hugr, llvm_ctx); } #[rstest] fn not(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_logic_extensions); - let hugr = test_logic_op(LogicOp::Not, 1); + let mut hugr = test_logic_op(LogicOp::Not, 1); check_emission!(hugr, llvm_ctx); } #[rstest] fn xor(mut llvm_ctx: TestContext) { llvm_ctx.add_extensions(add_logic_extensions); - let hugr = test_logic_op(LogicOp::Xor, 2); + let mut hugr = test_logic_op(LogicOp::Xor, 2); check_emission!(hugr, llvm_ctx); } } diff --git a/hugr-llvm/src/extension/prelude.rs b/hugr-llvm/src/extension/prelude.rs index 92d31a95ad..3497d93618 100644 --- a/hugr-llvm/src/extension/prelude.rs +++ b/hugr-llvm/src/extension/prelude.rs @@ -514,7 +514,7 @@ mod test { #[rstest] fn prelude_const_usize(prelude_llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([usize_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .finish(|mut builder| { @@ -536,7 +536,7 @@ mod test { false, ); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs(vec![konst1.get_type(), konst2.get_type()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .finish(|mut builder| { @@ -549,7 +549,7 @@ mod test { #[rstest] fn prelude_noop(prelude_llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins([usize_t()]) .with_outs([usize_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) @@ -566,7 +566,7 @@ mod test { #[rstest] fn prelude_make_tuple(prelude_llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![bool_t(), bool_t()]) .with_outs([Type::new_tuple(vec![bool_t(); 2])]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) @@ -580,7 +580,7 @@ mod test { #[rstest] fn prelude_unpack_tuple(prelude_llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins([Type::new_tuple(vec![bool_t(); 2])]) .with_outs(vec![bool_t(), bool_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) @@ -605,7 +605,7 @@ mod test { .instantiate_extension_op(&PANIC_OP_ID, [type_arg_2q.clone(), type_arg_2q.clone()]) .unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![qb_t(), qb_t()]) .with_outs(vec![qb_t(), qb_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) @@ -631,7 +631,7 @@ mod test { .instantiate_extension_op(&EXIT_OP_ID, [type_arg_2q.clone(), type_arg_2q.clone()]) .unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_ins(vec![qb_t(), qb_t()]) .with_outs(vec![qb_t(), qb_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) @@ -653,7 +653,7 @@ mod test { let greeting: ConstString = ConstString::new("Hello, world!".into()); let print_op = PRELUDE.instantiate_extension_op(&PRINT_OP_ID, []).unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .finish(|mut builder| { let greeting_out = builder.add_load_value(greeting); @@ -673,7 +673,7 @@ mod test { .instantiate_extension_op(&MAKE_ERROR_OP_ID, []) .unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .with_outs([error_type()]) .finish(|mut builder| { @@ -702,7 +702,7 @@ mod test { .instantiate_extension_op(&PANIC_OP_ID, [Term::new_list([]), Term::new_list([])]) .unwrap(); - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .finish(|mut builder| { let sig_out = builder.add_load_value(sig); @@ -720,7 +720,7 @@ mod test { #[rstest] fn prelude_load_nat(prelude_llvm_ctx: TestContext) { - let hugr = SimpleHugrConfig::new() + let mut hugr = SimpleHugrConfig::new() .with_outs([usize_t()]) .with_extensions(prelude::PRELUDE_REGISTRY.to_owned()) .finish(|mut builder| { @@ -746,7 +746,7 @@ mod test { } #[rstest] - fn prelude_barrier(prelude_llvm_ctx: TestContext, barrier_hugr: Hugr) { + fn prelude_barrier(prelude_llvm_ctx: TestContext, mut barrier_hugr: Hugr) { check_emission!(barrier_hugr, prelude_llvm_ctx); } #[rstest] diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@llvm21.snap index 7cd2a5a3d5..5f674597d4 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@llvm21.snap @@ -5,11 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(i32 %0) { +define internal double @_hl.main.1(i32 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = sitofp i32 %0 to double + %1 = sitofp i32 %0 to double, !dbg !9 ret double %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@pre-mem2reg@llvm21.snap index 64267802e6..963371c5fa 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_s@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(i32 %0) { +define internal double @_hl.main.1(i32 %0) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca i32, align 4 @@ -15,10 +15,24 @@ alloca_block: entry_block: ; preds = %alloca_block store i32 %0, ptr %"2_0", align 4 %"2_01" = load i32, ptr %"2_0", align 4 - %1 = sitofp i32 %"2_01" to double - store double %1, ptr %"4_0", align 8 + %1 = sitofp i32 %"2_01" to double, !dbg !9 + store double %1, ptr %"4_0", align 8, !dbg !9 %"4_02" = load double, ptr %"4_0", align 8 store double %"4_02", ptr %"0", align 8 %"03" = load double, ptr %"0", align 8 ret double %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@llvm21.snap index 563e00b3d9..0c2dbd0081 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@llvm21.snap @@ -5,11 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(i16 %0) { +define internal double @_hl.main.1(i16 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = uitofp i16 %0 to double + %1 = uitofp i16 %0 to double, !dbg !9 ret double %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@pre-mem2reg@llvm21.snap index e11674cc79..6cb9d1ab14 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__convert_u@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(i16 %0) { +define internal double @_hl.main.1(i16 %0) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca i16, align 2 @@ -15,10 +15,24 @@ alloca_block: entry_block: ; preds = %alloca_block store i16 %0, ptr %"2_0", align 2 %"2_01" = load i16, ptr %"2_0", align 2 - %1 = uitofp i16 %"2_01" to double - store double %1, ptr %"4_0", align 8 + %1 = uitofp i16 %"2_01" to double, !dbg !9 + store double %1, ptr %"4_0", align 8, !dbg !9 %"4_02" = load double, ptr %"4_0", align 8 store double %"4_02", ptr %"0", align 8 %"03" = load double, ptr %"0", align 8 ret double %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@llvm21.snap index de4fe36090..fae121c347 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i1 %0) { +define internal i8 @_hl.main.1(i1 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = icmp eq i1 %0, true - %2 = select i1 %1, i8 1, i8 0 + %1 = icmp eq i1 %0, true, !dbg !9 + %2 = select i1 %1, i8 1, i8 0, !dbg !9 ret i8 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@pre-mem2reg@llvm21.snap index bb65863092..5905b6087a 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__ifrombool@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i1 %0) { +define internal i8 @_hl.main.1(i1 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i1, align 1 @@ -15,11 +15,25 @@ alloca_block: entry_block: ; preds = %alloca_block store i1 %0, ptr %"2_0", align 1 %"2_01" = load i1, ptr %"2_0", align 1 - %1 = icmp eq i1 %"2_01", true - %2 = select i1 %1, i8 1, i8 0 - store i8 %2, ptr %"4_0", align 1 + %1 = icmp eq i1 %"2_01", true, !dbg !9 + %2 = select i1 %1, i8 1, i8 0, !dbg !9 + store i8 %2, ptr %"4_0", align 1, !dbg !9 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 ret i8 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@llvm21.snap index d80650327b..92285553a7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0) { +define internal i1 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %eq1 = icmp eq i8 %0, 1 - %1 = select i1 %eq1, i1 true, i1 false + %eq1 = icmp eq i8 %0, 1, !dbg !9 + %1 = select i1 %eq1, i1 true, i1 false, !dbg !9 ret i1 %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@pre-mem2reg@llvm21.snap index 9354bfecc7..4bfbcd6b20 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__itobool@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0) { +define internal i1 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i8, align 1 @@ -15,11 +15,25 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %eq1 = icmp eq i8 %"2_01", 1 - %1 = select i1 %eq1, i1 true, i1 false - store i1 %1, ptr %"4_0", align 1 + %eq1 = icmp eq i8 %"2_01", 1, !dbg !9 + %1 = select i1 %eq1, i1 true, i1 false, !dbg !9 + store i1 %1, ptr %"4_0", align 1, !dbg !9 %"4_02" = load i1, ptr %"4_0", align 1 store i1 %"4_02", ptr %"0", align 1 %"03" = load i1, ptr %"0", align 1 ret i1 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@llvm21.snap index 55ef5fa2ca..6217126e4d 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@llvm21.snap @@ -7,16 +7,36 @@ source_filename = "test_context" @0 = private unnamed_addr constant [58 x i8] c"Float value too big to convert to int of given width (32)\00", align 1 -define internal { i1, { i32, ptr }, i32 } @_hl.main.1(double %0) { +define internal { i1, { i32, ptr }, i32 } @_hl.main.1(double %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %within_upper_bound = fcmp olt double %0, 0x41DFFFFFFFC00000 - %within_lower_bound = fcmp ole double 0xC1E0000000000000, %0 - %success = and i1 %within_upper_bound, %within_lower_bound - %trunc_result = fptosi double %0 to i32 - %1 = insertvalue { i1, { i32, ptr }, i32 } { i1 true, { i32, ptr } poison, i32 poison }, i32 %trunc_result, 2 - %2 = select i1 %success, { i1, { i32, ptr }, i32 } %1, { i1, { i32, ptr }, i32 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i32 poison } + %within_upper_bound = fcmp olt double %0, 0x41DFFFFFFFC00000, !dbg !15 + %within_lower_bound = fcmp ole double 0xC1E0000000000000, %0, !dbg !15 + %success = and i1 %within_upper_bound, %within_lower_bound, !dbg !15 + %trunc_result = fptosi double %0 to i32, !dbg !15 + %1 = insertvalue { i1, { i32, ptr }, i32 } { i1 true, { i32, ptr } poison, i32 poison }, i32 %trunc_result, 2, !dbg !15 + %2 = select i1 %success, { i1, { i32, ptr }, i32 } %1, { i1, { i32, ptr }, i32 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i32 poison }, !dbg !15 ret { i1, { i32, ptr }, i32 } %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i32 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10, !12} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@pre-mem2reg@llvm21.snap index 37e28abb25..3064b136ee 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_s@pre-mem2reg@llvm21.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [58 x i8] c"Float value too big to convert to int of given width (32)\00", align 1 -define internal { i1, { i32, ptr }, i32 } @_hl.main.1(double %0) { +define internal { i1, { i32, ptr }, i32 } @_hl.main.1(double %0) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i32 }, align 8 %"2_0" = alloca double, align 8 @@ -17,15 +17,35 @@ alloca_block: entry_block: ; preds = %alloca_block store double %0, ptr %"2_0", align 8 %"2_01" = load double, ptr %"2_0", align 8 - %within_upper_bound = fcmp olt double %"2_01", 0x41DFFFFFFFC00000 - %within_lower_bound = fcmp ole double 0xC1E0000000000000, %"2_01" - %success = and i1 %within_upper_bound, %within_lower_bound - %trunc_result = fptosi double %"2_01" to i32 - %1 = insertvalue { i1, { i32, ptr }, i32 } { i1 true, { i32, ptr } poison, i32 poison }, i32 %trunc_result, 2 - %2 = select i1 %success, { i1, { i32, ptr }, i32 } %1, { i1, { i32, ptr }, i32 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i32 poison } - store { i1, { i32, ptr }, i32 } %2, ptr %"4_0", align 8 + %within_upper_bound = fcmp olt double %"2_01", 0x41DFFFFFFFC00000, !dbg !15 + %within_lower_bound = fcmp ole double 0xC1E0000000000000, %"2_01", !dbg !15 + %success = and i1 %within_upper_bound, %within_lower_bound, !dbg !15 + %trunc_result = fptosi double %"2_01" to i32, !dbg !15 + %1 = insertvalue { i1, { i32, ptr }, i32 } { i1 true, { i32, ptr } poison, i32 poison }, i32 %trunc_result, 2, !dbg !15 + %2 = select i1 %success, { i1, { i32, ptr }, i32 } %1, { i1, { i32, ptr }, i32 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i32 poison }, !dbg !15 + store { i1, { i32, ptr }, i32 } %2, ptr %"4_0", align 8, !dbg !15 %"4_02" = load { i1, { i32, ptr }, i32 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i32 } %"4_02", ptr %"0", align 8 %"03" = load { i1, { i32, ptr }, i32 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i32 } %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i32 }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10, !12} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@llvm21.snap index 98e22e7ba4..56b5d50d78 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@llvm21.snap @@ -7,16 +7,37 @@ source_filename = "test_context" @0 = private unnamed_addr constant [58 x i8] c"Float value too big to convert to int of given width (64)\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(double %0) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(double %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %within_upper_bound = fcmp olt double %0, 0x43F0000000000000 - %within_lower_bound = fcmp ole double 0.000000e+00, %0 - %success = and i1 %within_upper_bound, %within_lower_bound - %trunc_result = fptoui double %0 to i64 - %1 = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %trunc_result, 2 - %2 = select i1 %success, { i1, { i32, ptr }, i64 } %1, { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i64 poison } + %within_upper_bound = fcmp olt double %0, 0x43F0000000000000, !dbg !16 + %within_lower_bound = fcmp ole double 0.000000e+00, %0, !dbg !16 + %success = and i1 %within_upper_bound, %within_lower_bound, !dbg !16 + %trunc_result = fptoui double %0 to i64, !dbg !16 + %1 = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %trunc_result, 2, !dbg !16 + %2 = select i1 %success, { i1, { i32, ptr }, i64 } %1, { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i64 poison }, !dbg !16 ret { i1, { i32, ptr }, i64 } %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !15} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!16 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@pre-mem2reg@llvm21.snap index 81de12bd32..d6fb7f0a2d 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__conversions__test__trunc_u@pre-mem2reg@llvm21.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [58 x i8] c"Float value too big to convert to int of given width (64)\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(double %0) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(double %0) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i64 }, align 8 %"2_0" = alloca double, align 8 @@ -17,15 +17,36 @@ alloca_block: entry_block: ; preds = %alloca_block store double %0, ptr %"2_0", align 8 %"2_01" = load double, ptr %"2_0", align 8 - %within_upper_bound = fcmp olt double %"2_01", 0x43F0000000000000 - %within_lower_bound = fcmp ole double 0.000000e+00, %"2_01" - %success = and i1 %within_upper_bound, %within_lower_bound - %trunc_result = fptoui double %"2_01" to i64 - %1 = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %trunc_result, 2 - %2 = select i1 %success, { i1, { i32, ptr }, i64 } %1, { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i64 poison } - store { i1, { i32, ptr }, i64 } %2, ptr %"4_0", align 8 + %within_upper_bound = fcmp olt double %"2_01", 0x43F0000000000000, !dbg !16 + %within_lower_bound = fcmp ole double 0.000000e+00, %"2_01", !dbg !16 + %success = and i1 %within_upper_bound, %within_lower_bound, !dbg !16 + %trunc_result = fptoui double %"2_01" to i64, !dbg !16 + %1 = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %trunc_result, 2, !dbg !16 + %2 = select i1 %success, { i1, { i32, ptr }, i64 } %1, { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i64 poison }, !dbg !16 + store { i1, { i32, ptr }, i64 } %2, ptr %"4_0", align 8, !dbg !16 %"4_02" = load { i1, { i32, ptr }, i64 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i64 } %"4_02", ptr %"0", align 8 %"03" = load { i1, { i32, ptr }, i64 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i64 } %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !15} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!16 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@llvm21.snap index fb45bfc0cd..3254f2b4c7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1() { +define internal double @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret double 3.120000e+00 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@pre-mem2reg@llvm21.snap index 6517e30955..1467d94dc1 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__const_float@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1() { +define internal double @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"5_0" = alloca double, align 8 @@ -18,3 +18,15 @@ entry_block: ; preds = %alloca_block %"02" = load double, ptr %"0", align 8 ret double %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@llvm21.snap index 2d1187b050..f653393bcb 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fadd double %0, %1 + %2 = fadd double %0, %1, !dbg !8 ret double %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@pre-mem2reg@llvm21.snap index eb9da8a499..5d9d4833bb 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fadd@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fadd double %"2_01", %"2_12" - store double %2, ptr %"4_0", align 8 + %2 = fadd double %"2_01", %"2_12", !dbg !8 + store double %2, ptr %"4_0", align 8, !dbg !8 %"4_03" = load double, ptr %"4_0", align 8 store double %"4_03", ptr %"0", align 8 %"04" = load double, ptr %"0", align 8 ret double %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@llvm21.snap index f7437e95a6..b0fc237116 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fdiv double %0, %1 + %2 = fdiv double %0, %1, !dbg !8 ret double %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@pre-mem2reg@llvm21.snap index 91013e501b..7fd7deb4c7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fdiv@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fdiv double %"2_01", %"2_12" - store double %2, ptr %"4_0", align 8 + %2 = fdiv double %"2_01", %"2_12", !dbg !8 + store double %2, ptr %"4_0", align 8, !dbg !8 %"4_03" = load double, ptr %"4_0", align 8 store double %"4_03", ptr %"0", align 8 %"04" = load double, ptr %"0", align 8 ret double %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@llvm21.snap index 57a3724487..1e367f1f3e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp oeq double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp oeq double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@pre-mem2reg@llvm21.snap index fd3237d216..e4ef5af413 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__feq@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp oeq double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp oeq double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@llvm21.snap index 33a007d176..1e5a32e345 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp oge double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp oge double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@pre-mem2reg@llvm21.snap index 88b1f03b27..226b714ec6 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fge@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp oge double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp oge double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@llvm21.snap index bec01fa3f3..1f5503b3e3 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp ogt double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp ogt double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@pre-mem2reg@llvm21.snap index ce004c02d9..0e8d5021af 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fgt@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp ogt double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp ogt double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@llvm21.snap index eb7f7e01ac..0fdda98108 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp ole double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp ole double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@pre-mem2reg@llvm21.snap index 4129553a27..e9ecd6a8e5 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fle@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp ole double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp ole double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@llvm21.snap index de64e817e4..32b8fc8cd5 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp olt double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp olt double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@pre-mem2reg@llvm21.snap index 7112db0e45..f3af698eaf 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__flt@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp olt double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp olt double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@llvm21.snap index 1937d1c549..b59cf7ebdf 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fmul double %0, %1 + %2 = fmul double %0, %1, !dbg !8 ret double %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@pre-mem2reg@llvm21.snap index 8fb5ceaf4e..9cc6e216f9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fmul@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fmul double %"2_01", %"2_12" - store double %2, ptr %"4_0", align 8 + %2 = fmul double %"2_01", %"2_12", !dbg !8 + store double %2, ptr %"4_0", align 8, !dbg !8 %"4_03" = load double, ptr %"4_0", align 8 store double %"4_03", ptr %"0", align 8 %"04" = load double, ptr %"0", align 8 ret double %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@llvm21.snap index 9f330df318..b51a03037f 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fcmp one double %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = fcmp one double %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@pre-mem2reg@llvm21.snap index 0e134fae62..36b39ecd36 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fne@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(double %0, double %1) { +define internal i1 @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca double, align 8 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fcmp one double %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = fcmp one double %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@llvm21.snap index 3ceb777b31..466ee43ff7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0) { +define internal double @_hl.main.1(double %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = fneg double %0 + %1 = fneg double %0, !dbg !8 ret double %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@pre-mem2reg@llvm21.snap index 48606d13d7..f8055a0cc6 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fneg@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0) { +define internal double @_hl.main.1(double %0) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -15,10 +15,23 @@ alloca_block: entry_block: ; preds = %alloca_block store double %0, ptr %"2_0", align 8 %"2_01" = load double, ptr %"2_0", align 8 - %1 = fneg double %"2_01" - store double %1, ptr %"4_0", align 8 + %1 = fneg double %"2_01", !dbg !8 + store double %1, ptr %"4_0", align 8, !dbg !8 %"4_02" = load double, ptr %"4_0", align 8 store double %"4_02", ptr %"0", align 8 %"03" = load double, ptr %"0", align 8 ret double %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@llvm21.snap index c31472abb1..fc09114b9b 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@llvm21.snap @@ -5,12 +5,12 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = call double @llvm.pow.f64(double %0, double %1) + %2 = call double @llvm.pow.f64(double %0, double %1), !dbg !8 ret double %2 } @@ -18,3 +18,16 @@ entry_block: ; preds = %alloca_block declare double @llvm.pow.f64(double, double) #0 attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@pre-mem2reg@llvm21.snap index b1313cbca8..29e30a4a5e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fpow@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -18,8 +18,8 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = call double @llvm.pow.f64(double %"2_01", double %"2_12") - store double %2, ptr %"4_0", align 8 + %2 = call double @llvm.pow.f64(double %"2_01", double %"2_12"), !dbg !8 + store double %2, ptr %"4_0", align 8, !dbg !8 %"4_03" = load double, ptr %"4_0", align 8 store double %"4_03", ptr %"0", align 8 %"04" = load double, ptr %"0", align 8 @@ -30,3 +30,16 @@ entry_block: ; preds = %alloca_block declare double @llvm.pow.f64(double, double) #0 attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@llvm21.snap index a7449d6799..dd7871168b 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@llvm21.snap @@ -1,17 +1,16 @@ --- source: hugr-llvm/src/extension/float.rs -assertion_line: 234 expression: mod_str --- ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0) { +define internal double @_hl.main.1(double %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = call double @llvm.round.f64(double %0) + %1 = call double @llvm.round.f64(double %0), !dbg !8 ret double %1 } @@ -19,3 +18,16 @@ entry_block: ; preds = %alloca_block declare double @llvm.round.f64(double) #0 attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@pre-mem2reg@llvm21.snap index d46530dcd0..11d061d15e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fround@pre-mem2reg@llvm21.snap @@ -1,12 +1,11 @@ --- source: hugr-llvm/src/extension/float.rs -assertion_line: 234 expression: mod_str --- ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0) { +define internal double @_hl.main.1(double %0) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -16,8 +15,8 @@ alloca_block: entry_block: ; preds = %alloca_block store double %0, ptr %"2_0", align 8 %"2_01" = load double, ptr %"2_0", align 8 - %1 = call double @llvm.round.f64(double %"2_01") - store double %1, ptr %"4_0", align 8 + %1 = call double @llvm.round.f64(double %"2_01"), !dbg !8 + store double %1, ptr %"4_0", align 8, !dbg !8 %"4_02" = load double, ptr %"4_0", align 8 store double %"4_02", ptr %"0", align 8 %"03" = load double, ptr %"0", align 8 @@ -28,3 +27,16 @@ entry_block: ; preds = %alloca_block declare double @llvm.round.f64(double) #0 attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@llvm21.snap index eca14fb7d0..4147cb0b29 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = fsub double %0, %1 + %2 = fsub double %0, %1, !dbg !8 ret double %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@pre-mem2reg@llvm21.snap index 67aa8f3806..cbeb1cb2c1 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__float__test__fsub@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal double @_hl.main.1(double %0, double %1) { +define internal double @_hl.main.1(double %0, double %1) !dbg !3 { alloca_block: %"0" = alloca double, align 8 %"2_0" = alloca double, align 8 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store double %1, ptr %"2_1", align 8 %"2_01" = load double, ptr %"2_0", align 8 %"2_12" = load double, ptr %"2_1", align 8 - %2 = fsub double %"2_01", %"2_12" - store double %2, ptr %"4_0", align 8 + %2 = fsub double %"2_01", %"2_12", !dbg !8 + store double %2, ptr %"4_0", align 8, !dbg !8 %"4_03" = load double, ptr %"4_0", align 8 store double %"4_03", ptr %"0", align 8 %"04" = load double, ptr %"0", align 8 ret double %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "f64", size: 64, encoding: DW_ATE_float) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_s_[3].snap index c47d001e5e..7a4d8c089c 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_s_[3].snap @@ -7,67 +7,87 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - %is_divisor_large = icmp ugt i8 %1, 127 - %2 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %0, 0 - %3 = zext i1 %is_dividend_negative to i8 - %4 = shl i8 %2, 1 - %tag = or i8 %4, %3 - %quotient = sdiv i8 %0, %1 - %remainder = srem i8 %0, %1 - %result = alloca { i8, i8 }, align 8 + %valid_div = icmp ne i8 %1, 0, !dbg !15 + %is_divisor_large = icmp ugt i8 %1, 127, !dbg !15 + %2 = zext i1 %is_divisor_large to i8, !dbg !15 + %is_dividend_negative = icmp slt i8 %0, 0, !dbg !15 + %3 = zext i1 %is_dividend_negative to i8, !dbg !15 + %4 = shl i8 %2, 1, !dbg !15 + %tag = or i8 %4, %3, !dbg !15 + %quotient = sdiv i8 %0, %1, !dbg !15 + %remainder = srem i8 %0, %1, !dbg !15 + %result = alloca { i8, i8 }, align 8, !dbg !15 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !15 negative_bigdiv: ; preds = %entry_block - %5 = add i8 %0, %1 - %6 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %5, 1 - store { i8, i8 } %6, ptr %result, align 1 - br label %finish + %5 = add i8 %0, %1, !dbg !15 + %6 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %5, 1, !dbg !15 + store { i8, i8 } %6, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %8 = insertvalue { i8, i8 } %7, i8 0, 1 - %9 = sub i8 %quotient, 1 - %10 = add i8 %1, %remainder - %11 = insertvalue { i8, i8 } poison, i8 %9, 0 - %12 = insertvalue { i8, i8 } %11, i8 %10, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %13 = select i1 %is_rem_0, { i8, i8 } %8, { i8, i8 } %12 - store { i8, i8 } %13, ptr %result, align 1 - br label %finish + %7 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %8 = insertvalue { i8, i8 } %7, i8 0, 1, !dbg !15 + %9 = sub i8 %quotient, 1, !dbg !15 + %10 = add i8 %1, %remainder, !dbg !15 + %11 = insertvalue { i8, i8 } poison, i8 %9, 0, !dbg !15 + %12 = insertvalue { i8, i8 } %11, i8 %10, 1, !dbg !15 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !15 + %13 = select i1 %is_rem_0, { i8, i8 } %8, { i8, i8 } %12, !dbg !15 + store { i8, i8 } %13, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %14 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1, !dbg !15 + store { i8, i8 } %14, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %16 = insertvalue { i8, i8 } %15, i8 %remainder, 1 - store { i8, i8 } %16, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %16 = insertvalue { i8, i8 } %15, i8 %remainder, 1, !dbg !15 + store { i8, i8 } %16, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %17 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %17, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } } - %19 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 1 - %20 = extractvalue { i8, i8 } %19, 0 - %21 = extractvalue { i8, i8 } %19, 1 - %22 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 2 - %tag4 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %20, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %22, 1 - %23 = select i1 %tag4, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !15 + %17 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %result3, 1, !dbg !15 + %18 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %17, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %19 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 1, !dbg !15 + %20 = extractvalue { i8, i8 } %19, 0, !dbg !15 + %21 = extractvalue { i8, i8 } %19, 1, !dbg !15 + %22 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 2, !dbg !15 + %tag4 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %20, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %22, 1, !dbg !15 + %23 = select i1 %tag4, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant, !dbg !15 ret { i1, { i32, ptr }, i8 } %23 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_u_[3].snap index 9e82e63556..80c7c8c55e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idiv_checked_u_[3].snap @@ -7,25 +7,45 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - %quotient = udiv i8 %0, %1 - %remainder = urem i8 %0, %1 - %2 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %3 = insertvalue { i8, i8 } %2, i8 %remainder, 1 - %4 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %3, 1 - %5 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %4, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } } - %6 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 1 - %7 = extractvalue { i8, i8 } %6, 0 - %8 = extractvalue { i8, i8 } %6, 1 - %9 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 2 - %tag = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %7, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %9, 1 - %10 = select i1 %tag, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant + %valid_div = icmp ne i8 %1, 0, !dbg !15 + %quotient = udiv i8 %0, %1, !dbg !15 + %remainder = urem i8 %0, %1, !dbg !15 + %2 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %3 = insertvalue { i8, i8 } %2, i8 %remainder, 1, !dbg !15 + %4 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %3, 1, !dbg !15 + %5 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %4, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %6 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 1, !dbg !15 + %7 = extractvalue { i8, i8 } %6, 0, !dbg !15 + %8 = extractvalue { i8, i8 } %6, 1, !dbg !15 + %9 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 2, !dbg !15 + %tag = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %7, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %9, 1, !dbg !15 + %10 = select i1 %tag, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant, !dbg !15 ret { i1, { i32, ptr }, i8 } %10 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_s_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_s_[6].snap index 81eaf69e96..6b1a43c91d 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_s_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_s_[6].snap @@ -7,59 +7,81 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i64 %1, 0 - %is_divisor_large = icmp ugt i64 %1, 9223372036854775807 - %2 = zext i1 %is_divisor_large to i64 - %is_dividend_negative = icmp slt i64 %0, 0 - %3 = zext i1 %is_dividend_negative to i64 - %4 = shl i64 %2, 1 - %tag = or i64 %4, %3 - %quotient = sdiv i64 %0, %1 - %remainder = srem i64 %0, %1 - %result = alloca { i64, i64 }, align 8 + %valid_div = icmp ne i64 %1, 0, !dbg !17 + %is_divisor_large = icmp ugt i64 %1, 9223372036854775807, !dbg !17 + %2 = zext i1 %is_divisor_large to i64, !dbg !17 + %is_dividend_negative = icmp slt i64 %0, 0, !dbg !17 + %3 = zext i1 %is_dividend_negative to i64, !dbg !17 + %4 = shl i64 %2, 1, !dbg !17 + %tag = or i64 %4, %3, !dbg !17 + %quotient = sdiv i64 %0, %1, !dbg !17 + %remainder = srem i64 %0, %1, !dbg !17 + %result = alloca { i64, i64 }, align 8, !dbg !17 switch i64 %tag, label %non_negative_smoldiv [ i64 1, label %negative_smoldiv i64 2, label %non_negative_bigdiv i64 3, label %negative_bigdiv - ] + ], !dbg !17 negative_bigdiv: ; preds = %entry_block - %5 = add i64 %0, %1 - %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1 - store { i64, i64 } %6, ptr %result, align 4 - br label %finish + %5 = add i64 %0, %1, !dbg !17 + %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1, !dbg !17 + store { i64, i64 } %6, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %8 = insertvalue { i64, i64 } %7, i64 0, 1 - %9 = sub i64 %quotient, 1 - %10 = add i64 %1, %remainder - %11 = insertvalue { i64, i64 } poison, i64 %9, 0 - %12 = insertvalue { i64, i64 } %11, i64 %10, 1 - %is_rem_0 = icmp eq i64 %remainder, 0 - %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12 - store { i64, i64 } %13, ptr %result, align 4 - br label %finish + %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %8 = insertvalue { i64, i64 } %7, i64 0, 1, !dbg !17 + %9 = sub i64 %quotient, 1, !dbg !17 + %10 = add i64 %1, %remainder, !dbg !17 + %11 = insertvalue { i64, i64 } poison, i64 %9, 0, !dbg !17 + %12 = insertvalue { i64, i64 } %11, i64 %10, 1, !dbg !17 + %is_rem_0 = icmp eq i64 %remainder, 0, !dbg !17 + %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12, !dbg !17 + store { i64, i64 } %13, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %0, 1 - store { i64, i64 } %14, ptr %result, align 4 - br label %finish + %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %0, 1, !dbg !17 + store { i64, i64 } %14, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1 - store { i64, i64 } %16, ptr %result, align 4 - br label %finish + %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1, !dbg !17 + store { i64, i64 } %16, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i64, i64 }, ptr %result, align 4 - %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } + %result3 = load { i64, i64 }, ptr %result, align 4, !dbg !17 + %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1, !dbg !17 + %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !17 ret { i1, { i64, i64 }, { i32, ptr } } %18 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !12, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i64, i64 }, { i32, ptr } }", file: !2, size: 28, align: 8, elements: !8) +!8 = !{!9, !10, !13} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, i64 }", file: !2, size: 16, align: 8, elements: !11) +!11 = !{!12, !12} +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !14) +!14 = !{!15, !16} +!15 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!16 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!17 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_u_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_u_[6].snap index dcc9a1907a..27ac5a4b31 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_u_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_checked_u_[6].snap @@ -7,17 +7,39 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i64 %1, 0 - %quotient = udiv i64 %0, %1 - %remainder = urem i64 %0, %1 - %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1 - %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1 - %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } + %valid_div = icmp ne i64 %1, 0, !dbg !17 + %quotient = udiv i64 %0, %1, !dbg !17 + %remainder = urem i64 %0, %1, !dbg !17 + %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1, !dbg !17 + %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1, !dbg !17 + %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !17 ret { i1, { i64, i64 }, { i32, ptr } } %5 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !12, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i64, i64 }, { i32, ptr } }", file: !2, size: 28, align: 8, elements: !8) +!8 = !{!9, !10, !13} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, i64 }", file: !2, size: 16, align: 8, elements: !11) +!11 = !{!12, !12} +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !14) +!14 = !{!15, !16} +!15 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!16 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!17 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_s_[3].snap index d63511b4d7..7d576cf778 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_s_[3].snap @@ -8,73 +8,73 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !10 + br label %panic_if_0, !dbg !10 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !10 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !10 + call void @abort(), !dbg !10 + br label %exit, !dbg !10 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %1, 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %0, 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %0, %1 - %remainder = srem i8 %0, %1 - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %1, 127, !dbg !10 + %3 = zext i1 %is_divisor_large to i8, !dbg !10 + %is_dividend_negative = icmp slt i8 %0, 0, !dbg !10 + %4 = zext i1 %is_dividend_negative to i8, !dbg !10 + %5 = shl i8 %3, 1, !dbg !10 + %tag = or i8 %5, %4, !dbg !10 + %quotient = sdiv i8 %0, %1, !dbg !10 + %remainder = srem i8 %0, %1, !dbg !10 + %result = alloca { i8, i8 }, align 8, !dbg !10 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !10 negative_bigdiv: ; preds = %exit - %6 = add i8 %0, %1 - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %0, %1, !dbg !10 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !10 + store { i8, i8 } %7, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %1, %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !10 + %10 = sub i8 %quotient, 1, !dbg !10 + %11 = add i8 %1, %remainder, !dbg !10 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !10 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !10 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !10 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !10 + store { i8, i8 } %14, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1, !dbg !10 + store { i8, i8 } %15, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !10 + store { i8, i8 } %17, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !10 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !10 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !10 %mrv = insertvalue { i8, i8 } poison, i8 %18, 0 %mrv8 = insertvalue { i8, i8 } %mrv, i8 %19, 1 ret { i8, i8 } %mrv8 @@ -83,3 +83,18 @@ finish: ; preds = %negative_bigdiv, %n declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i8, i8 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_u_[3].snap index 9e80e8273c..9411b5fcb3 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_idivmod_u_[3].snap @@ -8,31 +8,31 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !10 + br label %panic_if_0, !dbg !10 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !10 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !10 + call void @abort(), !dbg !10 + br label %exit, !dbg !10 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %0, %1 - %remainder = urem i8 %0, %1 - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 + %quotient = udiv i8 %0, %1, !dbg !10 + %remainder = urem i8 %0, %1, !dbg !10 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !10 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !10 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !10 %mrv = insertvalue { i8, i8 } poison, i8 %5, 0 %mrv7 = insertvalue { i8, i8 } %mrv, i8 %6, 1 ret { i8, i8 } %mrv7 @@ -41,3 +41,18 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i8, i8 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_s_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_s_[6].snap index 54bb09aaec..492843bb5e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_s_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_s_[6].snap @@ -7,67 +7,87 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i64 %1, 0 - %is_divisor_large = icmp ugt i64 %1, 9223372036854775807 - %2 = zext i1 %is_divisor_large to i64 - %is_dividend_negative = icmp slt i64 %0, 0 - %3 = zext i1 %is_dividend_negative to i64 - %4 = shl i64 %2, 1 - %tag = or i64 %4, %3 - %quotient = sdiv i64 %0, %1 - %remainder = srem i64 %0, %1 - %result = alloca { i64, i64 }, align 8 + %valid_div = icmp ne i64 %1, 0, !dbg !15 + %is_divisor_large = icmp ugt i64 %1, 9223372036854775807, !dbg !15 + %2 = zext i1 %is_divisor_large to i64, !dbg !15 + %is_dividend_negative = icmp slt i64 %0, 0, !dbg !15 + %3 = zext i1 %is_dividend_negative to i64, !dbg !15 + %4 = shl i64 %2, 1, !dbg !15 + %tag = or i64 %4, %3, !dbg !15 + %quotient = sdiv i64 %0, %1, !dbg !15 + %remainder = srem i64 %0, %1, !dbg !15 + %result = alloca { i64, i64 }, align 8, !dbg !15 switch i64 %tag, label %non_negative_smoldiv [ i64 1, label %negative_smoldiv i64 2, label %non_negative_bigdiv i64 3, label %negative_bigdiv - ] + ], !dbg !15 negative_bigdiv: ; preds = %entry_block - %5 = add i64 %0, %1 - %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1 - store { i64, i64 } %6, ptr %result, align 4 - br label %finish + %5 = add i64 %0, %1, !dbg !15 + %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1, !dbg !15 + store { i64, i64 } %6, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %8 = insertvalue { i64, i64 } %7, i64 0, 1 - %9 = sub i64 %quotient, 1 - %10 = add i64 %1, %remainder - %11 = insertvalue { i64, i64 } poison, i64 %9, 0 - %12 = insertvalue { i64, i64 } %11, i64 %10, 1 - %is_rem_0 = icmp eq i64 %remainder, 0 - %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12 - store { i64, i64 } %13, ptr %result, align 4 - br label %finish + %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %8 = insertvalue { i64, i64 } %7, i64 0, 1, !dbg !15 + %9 = sub i64 %quotient, 1, !dbg !15 + %10 = add i64 %1, %remainder, !dbg !15 + %11 = insertvalue { i64, i64 } poison, i64 %9, 0, !dbg !15 + %12 = insertvalue { i64, i64 } %11, i64 %10, 1, !dbg !15 + %is_rem_0 = icmp eq i64 %remainder, 0, !dbg !15 + %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12, !dbg !15 + store { i64, i64 } %13, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %0, 1 - store { i64, i64 } %14, ptr %result, align 4 - br label %finish + %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %0, 1, !dbg !15 + store { i64, i64 } %14, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1 - store { i64, i64 } %16, ptr %result, align 4 - br label %finish + %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1, !dbg !15 + store { i64, i64 } %16, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i64, i64 }, ptr %result, align 4 - %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - %19 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 1 - %20 = extractvalue { i64, i64 } %19, 0 - %21 = extractvalue { i64, i64 } %19, 1 - %22 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 2 - %tag4 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %21, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %22, 1 - %23 = select i1 %tag4, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant + %result3 = load { i64, i64 }, ptr %result, align 4, !dbg !15 + %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1, !dbg !15 + %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %19 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 1, !dbg !15 + %20 = extractvalue { i64, i64 } %19, 0, !dbg !15 + %21 = extractvalue { i64, i64 } %19, 1, !dbg !15 + %22 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 2, !dbg !15 + %tag4 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %21, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %22, 1, !dbg !15 + %23 = select i1 %tag4, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant, !dbg !15 ret { i1, { i32, ptr }, i64 } %23 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_u_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_u_[6].snap index 9a5dad9b61..36e301b617 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_u_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_imod_checked_u_[6].snap @@ -7,25 +7,45 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i64 %1, 0 - %quotient = udiv i64 %0, %1 - %remainder = urem i64 %0, %1 - %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1 - %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1 - %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - %6 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 1 - %7 = extractvalue { i64, i64 } %6, 0 - %8 = extractvalue { i64, i64 } %6, 1 - %9 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 2 - %tag = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %8, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %9, 1 - %10 = select i1 %tag, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant + %valid_div = icmp ne i64 %1, 0, !dbg !15 + %quotient = udiv i64 %0, %1, !dbg !15 + %remainder = urem i64 %0, %1, !dbg !15 + %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1, !dbg !15 + %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1, !dbg !15 + %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %6 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 1, !dbg !15 + %7 = extractvalue { i64, i64 } %6, 0, !dbg !15 + %8 = extractvalue { i64, i64 } %6, 1, !dbg !15 + %9 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 2, !dbg !15 + %tag = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %8, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %9, 1, !dbg !15 + %10 = select i1 %tag, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant, !dbg !15 ret { i1, { i32, ptr }, i64 } %10 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_ineg_[2].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_ineg_[2].snap index 9508fbe7bc..132858b778 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_ineg_[2].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_ineg_[2].snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = sub i8 0, %0 + %1 = sub i8 0, %0, !dbg !8 ret i8 %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_is_to_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_is_to_u_[3].snap index 84eb417801..cd6e63abf4 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_is_to_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_is_to_u_[3].snap @@ -8,23 +8,23 @@ source_filename = "test_context" @0 = private unnamed_addr constant [33 x i8] c"is_to_u called on negative value\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %bounds_check = icmp sge i8 %0, 0 - br label %panic_if_0 + %bounds_check = icmp sge i8 %0, 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %bounds_check, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic ret i8 %0 @@ -33,3 +33,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_iu_to_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_iu_to_s_[3].snap index 8ca96178e5..2ddeaed4cc 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_iu_to_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@llvm21_iu_to_s_[3].snap @@ -8,23 +8,23 @@ source_filename = "test_context" @0 = private unnamed_addr constant [31 x i8] c"iu_to_s argument out of bounds\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %bounds_check = icmp ule i8 %0, 127 - br label %panic_if_0 + %bounds_check = icmp ule i8 %0, 127, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %bounds_check, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic ret i8 %0 @@ -33,3 +33,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_s_[3].snap index b947a83eec..95eaadd6ea 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_s_[3].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i8 }, align 8 %"2_0" = alloca i8, align 1 @@ -20,66 +20,86 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - %is_divisor_large = icmp ugt i8 %"2_12", 127 - %2 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %"2_01", 0 - %3 = zext i1 %is_dividend_negative to i8 - %4 = shl i8 %2, 1 - %tag = or i8 %4, %3 - %quotient = sdiv i8 %"2_01", %"2_12" - %remainder = srem i8 %"2_01", %"2_12" - %result = alloca { i8, i8 }, align 8 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !15 + %is_divisor_large = icmp ugt i8 %"2_12", 127, !dbg !15 + %2 = zext i1 %is_divisor_large to i8, !dbg !15 + %is_dividend_negative = icmp slt i8 %"2_01", 0, !dbg !15 + %3 = zext i1 %is_dividend_negative to i8, !dbg !15 + %4 = shl i8 %2, 1, !dbg !15 + %tag = or i8 %4, %3, !dbg !15 + %quotient = sdiv i8 %"2_01", %"2_12", !dbg !15 + %remainder = srem i8 %"2_01", %"2_12", !dbg !15 + %result = alloca { i8, i8 }, align 8, !dbg !15 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !15 negative_bigdiv: ; preds = %entry_block - %5 = add i8 %"2_01", %"2_12" - %6 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %5, 1 - store { i8, i8 } %6, ptr %result, align 1 - br label %finish + %5 = add i8 %"2_01", %"2_12", !dbg !15 + %6 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %5, 1, !dbg !15 + store { i8, i8 } %6, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %8 = insertvalue { i8, i8 } %7, i8 0, 1 - %9 = sub i8 %quotient, 1 - %10 = add i8 %"2_12", %remainder - %11 = insertvalue { i8, i8 } poison, i8 %9, 0 - %12 = insertvalue { i8, i8 } %11, i8 %10, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %13 = select i1 %is_rem_0, { i8, i8 } %8, { i8, i8 } %12 - store { i8, i8 } %13, ptr %result, align 1 - br label %finish + %7 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %8 = insertvalue { i8, i8 } %7, i8 0, 1, !dbg !15 + %9 = sub i8 %quotient, 1, !dbg !15 + %10 = add i8 %"2_12", %remainder, !dbg !15 + %11 = insertvalue { i8, i8 } poison, i8 %9, 0, !dbg !15 + %12 = insertvalue { i8, i8 } %11, i8 %10, 1, !dbg !15 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !15 + %13 = select i1 %is_rem_0, { i8, i8 } %8, { i8, i8 } %12, !dbg !15 + store { i8, i8 } %13, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %14 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1, !dbg !15 + store { i8, i8 } %14, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %16 = insertvalue { i8, i8 } %15, i8 %remainder, 1 - store { i8, i8 } %16, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %16 = insertvalue { i8, i8 } %15, i8 %remainder, 1, !dbg !15 + store { i8, i8 } %16, ptr %result, align 1, !dbg !15 + br label %finish, !dbg !15 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %17 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %17, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } } - %19 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 1 - %20 = extractvalue { i8, i8 } %19, 0 - %21 = extractvalue { i8, i8 } %19, 1 - %22 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 2 - %tag4 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %20, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %22, 1 - %23 = select i1 %tag4, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant - store { i1, { i32, ptr }, i8 } %23, ptr %"4_0", align 8 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !15 + %17 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %result3, 1, !dbg !15 + %18 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %17, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %19 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 1, !dbg !15 + %20 = extractvalue { i8, i8 } %19, 0, !dbg !15 + %21 = extractvalue { i8, i8 } %19, 1, !dbg !15 + %22 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 2, !dbg !15 + %tag4 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %18, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %20, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %22, 1, !dbg !15 + %23 = select i1 %tag4, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant, !dbg !15 + store { i1, { i32, ptr }, i8 } %23, ptr %"4_0", align 8, !dbg !15 %"4_05" = load { i1, { i32, ptr }, i8 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i8 } %"4_05", ptr %"0", align 8 %"06" = load { i1, { i32, ptr }, i8 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i8 } %"06" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_u_[3].snap index 5eba5848f1..8c866f566e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idiv_checked_u_[3].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i8 }, align 8 %"2_0" = alloca i8, align 1 @@ -20,24 +20,44 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - %quotient = udiv i8 %"2_01", %"2_12" - %remainder = urem i8 %"2_01", %"2_12" - %2 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %3 = insertvalue { i8, i8 } %2, i8 %remainder, 1 - %4 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %3, 1 - %5 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %4, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } } - %6 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 1 - %7 = extractvalue { i8, i8 } %6, 0 - %8 = extractvalue { i8, i8 } %6, 1 - %9 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 2 - %tag = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %7, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %9, 1 - %10 = select i1 %tag, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant - store { i1, { i32, ptr }, i8 } %10, ptr %"4_0", align 8 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !15 + %quotient = udiv i8 %"2_01", %"2_12", !dbg !15 + %remainder = urem i8 %"2_01", %"2_12", !dbg !15 + %2 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !15 + %3 = insertvalue { i8, i8 } %2, i8 %remainder, 1, !dbg !15 + %4 = insertvalue { i1, { i8, i8 }, { i32, ptr } } { i1 true, { i8, i8 } poison, { i32, ptr } poison }, { i8, i8 } %3, 1, !dbg !15 + %5 = select i1 %valid_div, { i1, { i8, i8 }, { i32, ptr } } %4, { i1, { i8, i8 }, { i32, ptr } } { i1 false, { i8, i8 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %6 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 1, !dbg !15 + %7 = extractvalue { i8, i8 } %6, 0, !dbg !15 + %8 = extractvalue { i8, i8 } %6, 1, !dbg !15 + %9 = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 2, !dbg !15 + %tag = extractvalue { i1, { i8, i8 }, { i32, ptr } } %5, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %7, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } poison, i8 poison }, { i32, ptr } %9, 1, !dbg !15 + %10 = select i1 %tag, { i1, { i32, ptr }, i8 } %data_variant, { i1, { i32, ptr }, i8 } %err_variant, !dbg !15 + store { i1, { i32, ptr }, i8 } %10, ptr %"4_0", align 8, !dbg !15 %"4_03" = load { i1, { i32, ptr }, i8 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i8 } %"4_03", ptr %"0", align 8 %"04" = load { i1, { i32, ptr }, i8 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i8 } %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_s_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_s_[6].snap index 7bae0889b1..6c71a67fc8 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_s_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_s_[6].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i64, i64 }, { i32, ptr } }, align 8 %"2_0" = alloca i64, align 8 @@ -20,58 +20,80 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load i64, ptr %"2_0", align 4 %"2_12" = load i64, ptr %"2_1", align 4 - %valid_div = icmp ne i64 %"2_12", 0 - %is_divisor_large = icmp ugt i64 %"2_12", 9223372036854775807 - %2 = zext i1 %is_divisor_large to i64 - %is_dividend_negative = icmp slt i64 %"2_01", 0 - %3 = zext i1 %is_dividend_negative to i64 - %4 = shl i64 %2, 1 - %tag = or i64 %4, %3 - %quotient = sdiv i64 %"2_01", %"2_12" - %remainder = srem i64 %"2_01", %"2_12" - %result = alloca { i64, i64 }, align 8 + %valid_div = icmp ne i64 %"2_12", 0, !dbg !17 + %is_divisor_large = icmp ugt i64 %"2_12", 9223372036854775807, !dbg !17 + %2 = zext i1 %is_divisor_large to i64, !dbg !17 + %is_dividend_negative = icmp slt i64 %"2_01", 0, !dbg !17 + %3 = zext i1 %is_dividend_negative to i64, !dbg !17 + %4 = shl i64 %2, 1, !dbg !17 + %tag = or i64 %4, %3, !dbg !17 + %quotient = sdiv i64 %"2_01", %"2_12", !dbg !17 + %remainder = srem i64 %"2_01", %"2_12", !dbg !17 + %result = alloca { i64, i64 }, align 8, !dbg !17 switch i64 %tag, label %non_negative_smoldiv [ i64 1, label %negative_smoldiv i64 2, label %non_negative_bigdiv i64 3, label %negative_bigdiv - ] + ], !dbg !17 negative_bigdiv: ; preds = %entry_block - %5 = add i64 %"2_01", %"2_12" - %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1 - store { i64, i64 } %6, ptr %result, align 4 - br label %finish + %5 = add i64 %"2_01", %"2_12", !dbg !17 + %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1, !dbg !17 + store { i64, i64 } %6, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %8 = insertvalue { i64, i64 } %7, i64 0, 1 - %9 = sub i64 %quotient, 1 - %10 = add i64 %"2_12", %remainder - %11 = insertvalue { i64, i64 } poison, i64 %9, 0 - %12 = insertvalue { i64, i64 } %11, i64 %10, 1 - %is_rem_0 = icmp eq i64 %remainder, 0 - %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12 - store { i64, i64 } %13, ptr %result, align 4 - br label %finish + %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %8 = insertvalue { i64, i64 } %7, i64 0, 1, !dbg !17 + %9 = sub i64 %quotient, 1, !dbg !17 + %10 = add i64 %"2_12", %remainder, !dbg !17 + %11 = insertvalue { i64, i64 } poison, i64 %9, 0, !dbg !17 + %12 = insertvalue { i64, i64 } %11, i64 %10, 1, !dbg !17 + %is_rem_0 = icmp eq i64 %remainder, 0, !dbg !17 + %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12, !dbg !17 + store { i64, i64 } %13, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %"2_01", 1 - store { i64, i64 } %14, ptr %result, align 4 - br label %finish + %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %"2_01", 1, !dbg !17 + store { i64, i64 } %14, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1 - store { i64, i64 } %16, ptr %result, align 4 - br label %finish + %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1, !dbg !17 + store { i64, i64 } %16, ptr %result, align 4, !dbg !17 + br label %finish, !dbg !17 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i64, i64 }, ptr %result, align 4 - %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - store { i1, { i64, i64 }, { i32, ptr } } %18, ptr %"4_0", align 8 + %result3 = load { i64, i64 }, ptr %result, align 4, !dbg !17 + %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1, !dbg !17 + %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !17 + store { i1, { i64, i64 }, { i32, ptr } } %18, ptr %"4_0", align 8, !dbg !17 %"4_04" = load { i1, { i64, i64 }, { i32, ptr } }, ptr %"4_0", align 8 store { i1, { i64, i64 }, { i32, ptr } } %"4_04", ptr %"0", align 8 %"05" = load { i1, { i64, i64 }, { i32, ptr } }, ptr %"0", align 8 ret { i1, { i64, i64 }, { i32, ptr } } %"05" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !12, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i64, i64 }, { i32, ptr } }", file: !2, size: 28, align: 8, elements: !8) +!8 = !{!9, !10, !13} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, i64 }", file: !2, size: 16, align: 8, elements: !11) +!11 = !{!12, !12} +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !14) +!14 = !{!15, !16} +!15 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!16 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!17 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_u_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_u_[6].snap index b1704b8f66..155886fc9b 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_u_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_checked_u_[6].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i64, i64 }, { i32, ptr } } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i64, i64 }, { i32, ptr } }, align 8 %"2_0" = alloca i64, align 8 @@ -20,16 +20,38 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load i64, ptr %"2_0", align 4 %"2_12" = load i64, ptr %"2_1", align 4 - %valid_div = icmp ne i64 %"2_12", 0 - %quotient = udiv i64 %"2_01", %"2_12" - %remainder = urem i64 %"2_01", %"2_12" - %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1 - %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1 - %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - store { i1, { i64, i64 }, { i32, ptr } } %5, ptr %"4_0", align 8 + %valid_div = icmp ne i64 %"2_12", 0, !dbg !17 + %quotient = udiv i64 %"2_01", %"2_12", !dbg !17 + %remainder = urem i64 %"2_01", %"2_12", !dbg !17 + %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !17 + %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1, !dbg !17 + %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1, !dbg !17 + %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !17 + store { i1, { i64, i64 }, { i32, ptr } } %5, ptr %"4_0", align 8, !dbg !17 %"4_03" = load { i1, { i64, i64 }, { i32, ptr } }, ptr %"4_0", align 8 store { i1, { i64, i64 }, { i32, ptr } } %"4_03", ptr %"0", align 8 %"04" = load { i1, { i64, i64 }, { i32, ptr } }, ptr %"0", align 8 ret { i1, { i64, i64 }, { i32, ptr } } %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !12, !12} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i64, i64 }, { i32, ptr } }", file: !2, size: 28, align: 8, elements: !8) +!8 = !{!9, !10, !13} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, i64 }", file: !2, size: 16, align: 8, elements: !11) +!11 = !{!12, !12} +!12 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!13 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !14) +!14 = !{!15, !16} +!15 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!16 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!17 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_s_[3].snap index a6bbe44cec..3a2c6ab61e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_s_[3].snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"1" = alloca i8, align 1 @@ -23,70 +23,70 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !10 + br label %panic_if_0, !dbg !10 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !10 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !10 + call void @abort(), !dbg !10 + br label %exit, !dbg !10 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %"2_12", 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %"2_01", 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %"2_01", %"2_12" - %remainder = srem i8 %"2_01", %"2_12" - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %"2_12", 127, !dbg !10 + %3 = zext i1 %is_divisor_large to i8, !dbg !10 + %is_dividend_negative = icmp slt i8 %"2_01", 0, !dbg !10 + %4 = zext i1 %is_dividend_negative to i8, !dbg !10 + %5 = shl i8 %3, 1, !dbg !10 + %tag = or i8 %5, %4, !dbg !10 + %quotient = sdiv i8 %"2_01", %"2_12", !dbg !10 + %remainder = srem i8 %"2_01", %"2_12", !dbg !10 + %result = alloca { i8, i8 }, align 8, !dbg !10 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !10 negative_bigdiv: ; preds = %exit - %6 = add i8 %"2_01", %"2_12" - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %"2_01", %"2_12", !dbg !10 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !10 + store { i8, i8 } %7, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %"2_12", %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !10 + %10 = sub i8 %quotient, 1, !dbg !10 + %11 = add i8 %"2_12", %remainder, !dbg !10 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !10 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !10 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !10 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !10 + store { i8, i8 } %14, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1, !dbg !10 + store { i8, i8 } %15, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !10 + store { i8, i8 } %17, ptr %result, align 1, !dbg !10 + br label %finish, !dbg !10 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 - store i8 %18, ptr %"4_0", align 1 - store i8 %19, ptr %"4_1", align 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !10 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !10 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !10 + store i8 %18, ptr %"4_0", align 1, !dbg !10 + store i8 %19, ptr %"4_1", align 1, !dbg !10 %"4_04" = load i8, ptr %"4_0", align 1 %"4_15" = load i8, ptr %"4_1", align 1 store i8 %"4_04", ptr %"0", align 1 @@ -101,3 +101,18 @@ finish: ; preds = %negative_bigdiv, %n declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i8, i8 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_u_[3].snap index d28db895df..48ce8dd8a8 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_idivmod_u_[3].snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) { +define internal { i8, i8 } @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"1" = alloca i8, align 1 @@ -23,28 +23,28 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !10 + br label %panic_if_0, !dbg !10 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !10 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !10 + call void @abort(), !dbg !10 + br label %exit, !dbg !10 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %"2_01", %"2_12" - %remainder = urem i8 %"2_01", %"2_12" - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 - store i8 %5, ptr %"4_0", align 1 - store i8 %6, ptr %"4_1", align 1 + %quotient = udiv i8 %"2_01", %"2_12", !dbg !10 + %remainder = urem i8 %"2_01", %"2_12", !dbg !10 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !10 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !10 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !10 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !10 + store i8 %5, ptr %"4_0", align 1, !dbg !10 + store i8 %6, ptr %"4_1", align 1, !dbg !10 %"4_03" = load i8, ptr %"4_0", align 1 %"4_14" = load i8, ptr %"4_1", align 1 store i8 %"4_03", ptr %"0", align 1 @@ -59,3 +59,18 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i8, i8 }", file: !2, size: 2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_s_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_s_[6].snap index a42d02564b..456f66acc8 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_s_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_s_[6].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i64 }, align 8 %"2_0" = alloca i64, align 8 @@ -20,66 +20,86 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load i64, ptr %"2_0", align 4 %"2_12" = load i64, ptr %"2_1", align 4 - %valid_div = icmp ne i64 %"2_12", 0 - %is_divisor_large = icmp ugt i64 %"2_12", 9223372036854775807 - %2 = zext i1 %is_divisor_large to i64 - %is_dividend_negative = icmp slt i64 %"2_01", 0 - %3 = zext i1 %is_dividend_negative to i64 - %4 = shl i64 %2, 1 - %tag = or i64 %4, %3 - %quotient = sdiv i64 %"2_01", %"2_12" - %remainder = srem i64 %"2_01", %"2_12" - %result = alloca { i64, i64 }, align 8 + %valid_div = icmp ne i64 %"2_12", 0, !dbg !15 + %is_divisor_large = icmp ugt i64 %"2_12", 9223372036854775807, !dbg !15 + %2 = zext i1 %is_divisor_large to i64, !dbg !15 + %is_dividend_negative = icmp slt i64 %"2_01", 0, !dbg !15 + %3 = zext i1 %is_dividend_negative to i64, !dbg !15 + %4 = shl i64 %2, 1, !dbg !15 + %tag = or i64 %4, %3, !dbg !15 + %quotient = sdiv i64 %"2_01", %"2_12", !dbg !15 + %remainder = srem i64 %"2_01", %"2_12", !dbg !15 + %result = alloca { i64, i64 }, align 8, !dbg !15 switch i64 %tag, label %non_negative_smoldiv [ i64 1, label %negative_smoldiv i64 2, label %non_negative_bigdiv i64 3, label %negative_bigdiv - ] + ], !dbg !15 negative_bigdiv: ; preds = %entry_block - %5 = add i64 %"2_01", %"2_12" - %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1 - store { i64, i64 } %6, ptr %result, align 4 - br label %finish + %5 = add i64 %"2_01", %"2_12", !dbg !15 + %6 = insertvalue { i64, i64 } { i64 -1, i64 poison }, i64 %5, 1, !dbg !15 + store { i64, i64 } %6, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 negative_smoldiv: ; preds = %entry_block - %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %8 = insertvalue { i64, i64 } %7, i64 0, 1 - %9 = sub i64 %quotient, 1 - %10 = add i64 %"2_12", %remainder - %11 = insertvalue { i64, i64 } poison, i64 %9, 0 - %12 = insertvalue { i64, i64 } %11, i64 %10, 1 - %is_rem_0 = icmp eq i64 %remainder, 0 - %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12 - store { i64, i64 } %13, ptr %result, align 4 - br label %finish + %7 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %8 = insertvalue { i64, i64 } %7, i64 0, 1, !dbg !15 + %9 = sub i64 %quotient, 1, !dbg !15 + %10 = add i64 %"2_12", %remainder, !dbg !15 + %11 = insertvalue { i64, i64 } poison, i64 %9, 0, !dbg !15 + %12 = insertvalue { i64, i64 } %11, i64 %10, 1, !dbg !15 + %is_rem_0 = icmp eq i64 %remainder, 0, !dbg !15 + %13 = select i1 %is_rem_0, { i64, i64 } %8, { i64, i64 } %12, !dbg !15 + store { i64, i64 } %13, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 non_negative_bigdiv: ; preds = %entry_block - %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %"2_01", 1 - store { i64, i64 } %14, ptr %result, align 4 - br label %finish + %14 = insertvalue { i64, i64 } { i64 0, i64 poison }, i64 %"2_01", 1, !dbg !15 + store { i64, i64 } %14, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 non_negative_smoldiv: ; preds = %entry_block - %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1 - store { i64, i64 } %16, ptr %result, align 4 - br label %finish + %15 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %16 = insertvalue { i64, i64 } %15, i64 %remainder, 1, !dbg !15 + store { i64, i64 } %16, ptr %result, align 4, !dbg !15 + br label %finish, !dbg !15 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i64, i64 }, ptr %result, align 4 - %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1 - %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - %19 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 1 - %20 = extractvalue { i64, i64 } %19, 0 - %21 = extractvalue { i64, i64 } %19, 1 - %22 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 2 - %tag4 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %21, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %22, 1 - %23 = select i1 %tag4, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant - store { i1, { i32, ptr }, i64 } %23, ptr %"4_0", align 8 + %result3 = load { i64, i64 }, ptr %result, align 4, !dbg !15 + %17 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %result3, 1, !dbg !15 + %18 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %17, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %19 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 1, !dbg !15 + %20 = extractvalue { i64, i64 } %19, 0, !dbg !15 + %21 = extractvalue { i64, i64 } %19, 1, !dbg !15 + %22 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 2, !dbg !15 + %tag4 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %18, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %21, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %22, 1, !dbg !15 + %23 = select i1 %tag4, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant, !dbg !15 + store { i1, { i32, ptr }, i64 } %23, ptr %"4_0", align 8, !dbg !15 %"4_05" = load { i1, { i32, ptr }, i64 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i64 } %"4_05", ptr %"0", align 8 %"06" = load { i1, { i32, ptr }, i64 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i64 } %"06" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_u_[6].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_u_[6].snap index d2f03bfb91..0c286c55af 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_u_[6].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_imod_checked_u_[6].snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 -define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) { +define internal { i1, { i32, ptr }, i64 } @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i64 }, align 8 %"2_0" = alloca i64, align 8 @@ -20,24 +20,44 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load i64, ptr %"2_0", align 4 %"2_12" = load i64, ptr %"2_1", align 4 - %valid_div = icmp ne i64 %"2_12", 0 - %quotient = udiv i64 %"2_01", %"2_12" - %remainder = urem i64 %"2_01", %"2_12" - %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0 - %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1 - %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1 - %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } } - %6 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 1 - %7 = extractvalue { i64, i64 } %6, 0 - %8 = extractvalue { i64, i64 } %6, 1 - %9 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 2 - %tag = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 0 - %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %8, 2 - %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %9, 1 - %10 = select i1 %tag, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant - store { i1, { i32, ptr }, i64 } %10, ptr %"4_0", align 8 + %valid_div = icmp ne i64 %"2_12", 0, !dbg !15 + %quotient = udiv i64 %"2_01", %"2_12", !dbg !15 + %remainder = urem i64 %"2_01", %"2_12", !dbg !15 + %2 = insertvalue { i64, i64 } poison, i64 %quotient, 0, !dbg !15 + %3 = insertvalue { i64, i64 } %2, i64 %remainder, 1, !dbg !15 + %4 = insertvalue { i1, { i64, i64 }, { i32, ptr } } { i1 true, { i64, i64 } poison, { i32, ptr } poison }, { i64, i64 } %3, 1, !dbg !15 + %5 = select i1 %valid_div, { i1, { i64, i64 }, { i32, ptr } } %4, { i1, { i64, i64 }, { i32, ptr } } { i1 false, { i64, i64 } poison, { i32, ptr } { i32 2, ptr @0 } }, !dbg !15 + %6 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 1, !dbg !15 + %7 = extractvalue { i64, i64 } %6, 0, !dbg !15 + %8 = extractvalue { i64, i64 } %6, 1, !dbg !15 + %9 = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 2, !dbg !15 + %tag = extractvalue { i1, { i64, i64 }, { i32, ptr } } %5, 0, !dbg !15 + %data_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 true, { i32, ptr } poison, i64 poison }, i64 %8, 2, !dbg !15 + %err_variant = insertvalue { i1, { i32, ptr }, i64 } { i1 false, { i32, ptr } poison, i64 poison }, { i32, ptr } %9, 1, !dbg !15 + %10 = select i1 %tag, { i1, { i32, ptr }, i64 } %data_variant, { i1, { i32, ptr }, i64 } %err_variant, !dbg !15 + store { i1, { i32, ptr }, i64 } %10, ptr %"4_0", align 8, !dbg !15 %"4_03" = load { i1, { i32, ptr }, i64 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i64 } %"4_03", ptr %"0", align 8 %"04" = load { i1, { i32, ptr }, i64 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i64 } %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i64 }", file: !2, size: 20, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_ineg_[2].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_ineg_[2].snap index 4a75c2c3d6..a3e3bd1cb5 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_ineg_[2].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_ineg_[2].snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -15,10 +15,23 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %1 = sub i8 0, %"2_01" - store i8 %1, ptr %"4_0", align 1 + %1 = sub i8 0, %"2_01", !dbg !8 + store i8 %1, ptr %"4_0", align 1, !dbg !8 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 ret i8 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_is_to_u_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_is_to_u_[3].snap index e395605cd1..d164dbeeab 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_is_to_u_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_is_to_u_[3].snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [33 x i8] c"is_to_u called on negative value\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -18,21 +18,21 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %bounds_check = icmp sge i8 %"2_01", 0 - br label %panic_if_0 + %bounds_check = icmp sge i8 %"2_01", 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %bounds_check, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - store i8 %"2_01", ptr %"4_0", align 1 + store i8 %"2_01", ptr %"4_0", align 1, !dbg !8 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 @@ -42,3 +42,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_iu_to_s_[3].snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_iu_to_s_[3].snap index 742b46c51d..686d819860 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_iu_to_s_[3].snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__emission@pre-mem2reg@llvm21_iu_to_s_[3].snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [31 x i8] c"iu_to_s argument out of bounds\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -18,21 +18,21 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %bounds_check = icmp ule i8 %"2_01", 127 - br label %panic_if_0 + %bounds_check = icmp ule i8 %"2_01", 127, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %bounds_check, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %1 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - store i8 %"2_01", ptr %"4_0", align 1 + store i8 %"2_01", ptr %"4_0", align 1, !dbg !8 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 @@ -42,3 +42,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@llvm21.snap index dd9ea300cb..a64e27c199 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = add i8 %0, %1 + %2 = add i8 %0, %1, !dbg !8 ret i8 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@pre-mem2reg@llvm21.snap index f8d213d223..512d93489a 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iadd@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %2 = add i8 %"2_01", %"2_12" - store i8 %2, ptr %"4_0", align 1 + %2 = add i8 %"2_01", %"2_12", !dbg !8 + store i8 %2, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i8, ptr %"4_0", align 1 store i8 %"4_03", ptr %"0", align 1 %"04" = load i8, ptr %"0", align 1 ret i8 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@llvm21.snap index cb80dfdc42..d1f3c8d476 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@llvm21.snap @@ -8,76 +8,89 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %1, 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %0, 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %0, %1 - %remainder = srem i8 %0, %1 - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %1, 127, !dbg !8 + %3 = zext i1 %is_divisor_large to i8, !dbg !8 + %is_dividend_negative = icmp slt i8 %0, 0, !dbg !8 + %4 = zext i1 %is_dividend_negative to i8, !dbg !8 + %5 = shl i8 %3, 1, !dbg !8 + %tag = or i8 %5, %4, !dbg !8 + %quotient = sdiv i8 %0, %1, !dbg !8 + %remainder = srem i8 %0, %1, !dbg !8 + %result = alloca { i8, i8 }, align 8, !dbg !8 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !8 negative_bigdiv: ; preds = %exit - %6 = add i8 %0, %1 - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %0, %1, !dbg !8 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !8 + store { i8, i8 } %7, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %1, %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !8 + %10 = sub i8 %quotient, 1, !dbg !8 + %11 = add i8 %1, %remainder, !dbg !8 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !8 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !8 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !8 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !8 + store { i8, i8 } %14, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1, !dbg !8 + store { i8, i8 } %15, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !8 + store { i8, i8 } %17, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !8 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !8 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !8 ret i8 %18 } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@pre-mem2reg@llvm21.snap index 7df541a10c..ff70a3f0dd 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_s@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -21,69 +21,69 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %"2_12", 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %"2_01", 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %"2_01", %"2_12" - %remainder = srem i8 %"2_01", %"2_12" - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %"2_12", 127, !dbg !8 + %3 = zext i1 %is_divisor_large to i8, !dbg !8 + %is_dividend_negative = icmp slt i8 %"2_01", 0, !dbg !8 + %4 = zext i1 %is_dividend_negative to i8, !dbg !8 + %5 = shl i8 %3, 1, !dbg !8 + %tag = or i8 %5, %4, !dbg !8 + %quotient = sdiv i8 %"2_01", %"2_12", !dbg !8 + %remainder = srem i8 %"2_01", %"2_12", !dbg !8 + %result = alloca { i8, i8 }, align 8, !dbg !8 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !8 negative_bigdiv: ; preds = %exit - %6 = add i8 %"2_01", %"2_12" - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %"2_01", %"2_12", !dbg !8 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !8 + store { i8, i8 } %7, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %"2_12", %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !8 + %10 = sub i8 %quotient, 1, !dbg !8 + %11 = add i8 %"2_12", %remainder, !dbg !8 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !8 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !8 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !8 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !8 + store { i8, i8 } %14, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1, !dbg !8 + store { i8, i8 } %15, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !8 + store { i8, i8 } %17, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 - store i8 %18, ptr %"4_0", align 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !8 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !8 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !8 + store i8 %18, ptr %"4_0", align 1, !dbg !8 %"4_04" = load i8, ptr %"4_0", align 1 store i8 %"4_04", ptr %"0", align 1 %"05" = load i8, ptr %"0", align 1 @@ -93,3 +93,16 @@ finish: ; preds = %negative_bigdiv, %n declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@llvm21.snap index e956df57cc..8b849b64a7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@llvm21.snap @@ -8,34 +8,47 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %0, %1 - %remainder = urem i8 %0, %1 - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 + %quotient = udiv i8 %0, %1, !dbg !8 + %remainder = urem i8 %0, %1, !dbg !8 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !8 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !8 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !8 ret i8 %5 } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@pre-mem2reg@llvm21.snap index adacf028b9..f45901beb5 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__idiv_u@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -21,27 +21,27 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %"2_01", %"2_12" - %remainder = urem i8 %"2_01", %"2_12" - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 - store i8 %5, ptr %"4_0", align 1 + %quotient = udiv i8 %"2_01", %"2_12", !dbg !8 + %remainder = urem i8 %"2_01", %"2_12", !dbg !8 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !8 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !8 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !8 + store i8 %5, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i8, ptr %"4_0", align 1 store i8 %"4_03", ptr %"0", align 1 %"04" = load i8, ptr %"0", align 1 @@ -51,3 +51,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@llvm21.snap index c7eac64f19..6e2b8aba5f 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0, i8 %1) { +define internal i1 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = icmp eq i8 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = icmp eq i8 %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@pre-mem2reg@llvm21.snap index a12c5fcec6..80cec686fa 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ieq@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0, i8 %1) { +define internal i1 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i8, align 1 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %2 = icmp eq i8 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = icmp eq i8 %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@llvm21.snap index 4d3a25a81d..5e4174f388 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@llvm21.snap @@ -5,12 +5,26 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0, i8 %1) { +define internal i1 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = icmp slt i8 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = icmp slt i8 %0, %1, !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@pre-mem2reg@llvm21.snap index bad6a894fb..1597596083 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ilt_s@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i8 %0, i8 %1) { +define internal i1 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i8, align 1 @@ -18,11 +18,25 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %2 = icmp slt i8 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = icmp slt i8 %"2_01", %"2_12", !dbg !9 + %3 = select i1 %2, i1 true, i1 false, !dbg !9 + store i1 %3, ptr %"4_0", align 1, !dbg !9 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8, !8} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@llvm21.snap index 25c62f20af..f37ebff2ac 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@llvm21.snap @@ -8,76 +8,89 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %1, 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %0, 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %0, %1 - %remainder = srem i8 %0, %1 - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %1, 127, !dbg !8 + %3 = zext i1 %is_divisor_large to i8, !dbg !8 + %is_dividend_negative = icmp slt i8 %0, 0, !dbg !8 + %4 = zext i1 %is_dividend_negative to i8, !dbg !8 + %5 = shl i8 %3, 1, !dbg !8 + %tag = or i8 %5, %4, !dbg !8 + %quotient = sdiv i8 %0, %1, !dbg !8 + %remainder = srem i8 %0, %1, !dbg !8 + %result = alloca { i8, i8 }, align 8, !dbg !8 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !8 negative_bigdiv: ; preds = %exit - %6 = add i8 %0, %1 - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %0, %1, !dbg !8 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !8 + store { i8, i8 } %7, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %1, %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !8 + %10 = sub i8 %quotient, 1, !dbg !8 + %11 = add i8 %1, %remainder, !dbg !8 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !8 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !8 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !8 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !8 + store { i8, i8 } %14, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %0, 1, !dbg !8 + store { i8, i8 } %15, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !8 + store { i8, i8 } %17, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !8 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !8 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !8 ret i8 %19 } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@pre-mem2reg@llvm21.snap index bff5f16fe3..5245c443b9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_s@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -21,69 +21,69 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %is_divisor_large = icmp ugt i8 %"2_12", 127 - %3 = zext i1 %is_divisor_large to i8 - %is_dividend_negative = icmp slt i8 %"2_01", 0 - %4 = zext i1 %is_dividend_negative to i8 - %5 = shl i8 %3, 1 - %tag = or i8 %5, %4 - %quotient = sdiv i8 %"2_01", %"2_12" - %remainder = srem i8 %"2_01", %"2_12" - %result = alloca { i8, i8 }, align 8 + %is_divisor_large = icmp ugt i8 %"2_12", 127, !dbg !8 + %3 = zext i1 %is_divisor_large to i8, !dbg !8 + %is_dividend_negative = icmp slt i8 %"2_01", 0, !dbg !8 + %4 = zext i1 %is_dividend_negative to i8, !dbg !8 + %5 = shl i8 %3, 1, !dbg !8 + %tag = or i8 %5, %4, !dbg !8 + %quotient = sdiv i8 %"2_01", %"2_12", !dbg !8 + %remainder = srem i8 %"2_01", %"2_12", !dbg !8 + %result = alloca { i8, i8 }, align 8, !dbg !8 switch i8 %tag, label %non_negative_smoldiv [ i8 1, label %negative_smoldiv i8 2, label %non_negative_bigdiv i8 3, label %negative_bigdiv - ] + ], !dbg !8 negative_bigdiv: ; preds = %exit - %6 = add i8 %"2_01", %"2_12" - %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1 - store { i8, i8 } %7, ptr %result, align 1 - br label %finish + %6 = add i8 %"2_01", %"2_12", !dbg !8 + %7 = insertvalue { i8, i8 } { i8 -1, i8 poison }, i8 %6, 1, !dbg !8 + store { i8, i8 } %7, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 negative_smoldiv: ; preds = %exit - %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %9 = insertvalue { i8, i8 } %8, i8 0, 1 - %10 = sub i8 %quotient, 1 - %11 = add i8 %"2_12", %remainder - %12 = insertvalue { i8, i8 } poison, i8 %10, 0 - %13 = insertvalue { i8, i8 } %12, i8 %11, 1 - %is_rem_0 = icmp eq i8 %remainder, 0 - %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13 - store { i8, i8 } %14, ptr %result, align 1 - br label %finish + %8 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %9 = insertvalue { i8, i8 } %8, i8 0, 1, !dbg !8 + %10 = sub i8 %quotient, 1, !dbg !8 + %11 = add i8 %"2_12", %remainder, !dbg !8 + %12 = insertvalue { i8, i8 } poison, i8 %10, 0, !dbg !8 + %13 = insertvalue { i8, i8 } %12, i8 %11, 1, !dbg !8 + %is_rem_0 = icmp eq i8 %remainder, 0, !dbg !8 + %14 = select i1 %is_rem_0, { i8, i8 } %9, { i8, i8 } %13, !dbg !8 + store { i8, i8 } %14, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_bigdiv: ; preds = %exit - %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1 - store { i8, i8 } %15, ptr %result, align 1 - br label %finish + %15 = insertvalue { i8, i8 } { i8 0, i8 poison }, i8 %"2_01", 1, !dbg !8 + store { i8, i8 } %15, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 non_negative_smoldiv: ; preds = %exit - %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1 - store { i8, i8 } %17, ptr %result, align 1 - br label %finish + %16 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %17 = insertvalue { i8, i8 } %16, i8 %remainder, 1, !dbg !8 + store { i8, i8 } %17, ptr %result, align 1, !dbg !8 + br label %finish, !dbg !8 finish: ; preds = %negative_bigdiv, %non_negative_bigdiv, %negative_smoldiv, %non_negative_smoldiv - %result3 = load { i8, i8 }, ptr %result, align 1 - %18 = extractvalue { i8, i8 } %result3, 0 - %19 = extractvalue { i8, i8 } %result3, 1 - store i8 %19, ptr %"4_0", align 1 + %result3 = load { i8, i8 }, ptr %result, align 1, !dbg !8 + %18 = extractvalue { i8, i8 } %result3, 0, !dbg !8 + %19 = extractvalue { i8, i8 } %result3, 1, !dbg !8 + store i8 %19, ptr %"4_0", align 1, !dbg !8 %"4_04" = load i8, ptr %"4_0", align 1 store i8 %"4_04", ptr %"0", align 1 %"05" = load i8, ptr %"0", align 1 @@ -93,3 +93,16 @@ finish: ; preds = %negative_bigdiv, %n declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@llvm21.snap index fbcfd5cdb4..c8e00ca95e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@llvm21.snap @@ -8,34 +8,47 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %valid_div = icmp ne i8 %1, 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %1, 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %0, %1 - %remainder = urem i8 %0, %1 - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 + %quotient = udiv i8 %0, %1, !dbg !8 + %remainder = urem i8 %0, %1, !dbg !8 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !8 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !8 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !8 ret i8 %6 } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@pre-mem2reg@llvm21.snap index 05c8ce332c..6f85254847 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__imod_u@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [24 x i8] c"Attempted division by 0\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -21,27 +21,27 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %valid_div = icmp ne i8 %"2_12", 0 - br label %panic_if_0 + %valid_div = icmp ne i8 %"2_12", 0, !dbg !8 + br label %panic_if_0, !dbg !8 panic_if_0: ; preds = %entry_block switch i1 %valid_div, label %panic [ i1 true, label %exit - ] + ], !dbg !8 panic: ; preds = %panic_if_0 - %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0) - call void @abort() - br label %exit + %2 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 2, ptr @0), !dbg !8 + call void @abort(), !dbg !8 + br label %exit, !dbg !8 exit: ; preds = %panic_if_0, %panic - %quotient = udiv i8 %"2_01", %"2_12" - %remainder = urem i8 %"2_01", %"2_12" - %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0 - %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1 - %5 = extractvalue { i8, i8 } %4, 0 - %6 = extractvalue { i8, i8 } %4, 1 - store i8 %6, ptr %"4_0", align 1 + %quotient = udiv i8 %"2_01", %"2_12", !dbg !8 + %remainder = urem i8 %"2_01", %"2_12", !dbg !8 + %3 = insertvalue { i8, i8 } poison, i8 %quotient, 0, !dbg !8 + %4 = insertvalue { i8, i8 } %3, i8 %remainder, 1, !dbg !8 + %5 = extractvalue { i8, i8 } %4, 0, !dbg !8 + %6 = extractvalue { i8, i8 } %4, 1, !dbg !8 + store i8 %6, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i8, ptr %"4_0", align 1 store i8 %"4_03", ptr %"0", align 1 %"04" = load i8, ptr %"0", align 1 @@ -51,3 +51,16 @@ exit: ; preds = %panic_if_0, %panic declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@llvm21.snap index 87e36f9475..0a89af8f18 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@llvm21.snap @@ -7,16 +7,36 @@ source_filename = "test_context" @0 = private unnamed_addr constant [25 x i8] c"Can't narrow into bounds\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %upper_bounds_check = icmp sgt i8 %0, 7 - %lower_bounds_check = icmp slt i8 %0, -8 - %outside_range = or i1 %upper_bounds_check, %lower_bounds_check - %inbounds = xor i1 %outside_range, true - %1 = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %0, 2 - %2 = select i1 %inbounds, { i1, { i32, ptr }, i8 } %1, { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i8 poison } + %upper_bounds_check = icmp sgt i8 %0, 7, !dbg !15 + %lower_bounds_check = icmp slt i8 %0, -8, !dbg !15 + %outside_range = or i1 %upper_bounds_check, %lower_bounds_check, !dbg !15 + %inbounds = xor i1 %outside_range, true, !dbg !15 + %1 = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %0, 2, !dbg !15 + %2 = select i1 %inbounds, { i1, { i32, ptr }, i8 } %1, { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i8 poison }, !dbg !15 ret { i1, { i32, ptr }, i8 } %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@pre-mem2reg@llvm21.snap index 621b904ed4..0bb775770b 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_s_3_2@pre-mem2reg@llvm21.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [25 x i8] c"Can't narrow into bounds\00", align 1 -define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0) { +define internal { i1, { i32, ptr }, i8 } @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i8 }, align 8 %"2_0" = alloca i8, align 1 @@ -17,15 +17,35 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %upper_bounds_check = icmp sgt i8 %"2_01", 7 - %lower_bounds_check = icmp slt i8 %"2_01", -8 - %outside_range = or i1 %upper_bounds_check, %lower_bounds_check - %inbounds = xor i1 %outside_range, true - %1 = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %"2_01", 2 - %2 = select i1 %inbounds, { i1, { i32, ptr }, i8 } %1, { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i8 poison } - store { i1, { i32, ptr }, i8 } %2, ptr %"4_0", align 8 + %upper_bounds_check = icmp sgt i8 %"2_01", 7, !dbg !15 + %lower_bounds_check = icmp slt i8 %"2_01", -8, !dbg !15 + %outside_range = or i1 %upper_bounds_check, %lower_bounds_check, !dbg !15 + %inbounds = xor i1 %outside_range, true, !dbg !15 + %1 = insertvalue { i1, { i32, ptr }, i8 } { i1 true, { i32, ptr } poison, i8 poison }, i8 %"2_01", 2, !dbg !15 + %2 = select i1 %inbounds, { i1, { i32, ptr }, i8 } %1, { i1, { i32, ptr }, i8 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i8 poison }, !dbg !15 + store { i1, { i32, ptr }, i8 } %2, ptr %"4_0", align 8, !dbg !15 %"4_02" = load { i1, { i32, ptr }, i8 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i8 } %"4_02", ptr %"0", align 8 %"03" = load { i1, { i32, ptr }, i8 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i8 } %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !14} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i8 }", file: !2, size: 13, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!15 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@llvm21.snap index 49f59571c4..e171c56748 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@llvm21.snap @@ -7,15 +7,36 @@ source_filename = "test_context" @0 = private unnamed_addr constant [25 x i8] c"Can't narrow into bounds\00", align 1 -define internal { i1, { i32, ptr }, i16 } @_hl.main.1(i64 %0) { +define internal { i1, { i32, ptr }, i16 } @_hl.main.1(i64 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %upper_bounds_check = icmp ugt i64 %0, 65535 - %inbounds = xor i1 %upper_bounds_check, true - %1 = trunc i64 %0 to i16 - %2 = insertvalue { i1, { i32, ptr }, i16 } { i1 true, { i32, ptr } poison, i16 poison }, i16 %1, 2 - %3 = select i1 %inbounds, { i1, { i32, ptr }, i16 } %2, { i1, { i32, ptr }, i16 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i16 poison } + %upper_bounds_check = icmp ugt i64 %0, 65535, !dbg !16 + %inbounds = xor i1 %upper_bounds_check, true, !dbg !16 + %1 = trunc i64 %0 to i16, !dbg !16 + %2 = insertvalue { i1, { i32, ptr }, i16 } { i1 true, { i32, ptr } poison, i16 poison }, i16 %1, 2, !dbg !16 + %3 = select i1 %inbounds, { i1, { i32, ptr }, i16 } %2, { i1, { i32, ptr }, i16 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i16 poison }, !dbg !16 ret { i1, { i32, ptr }, i16 } %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !15} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i16 }", file: !2, size: 14, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!15 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!16 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@pre-mem2reg@llvm21.snap index 1685c7427c..caba15ad75 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__inarrow_u_6_4@pre-mem2reg@llvm21.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [25 x i8] c"Can't narrow into bounds\00", align 1 -define internal { i1, { i32, ptr }, i16 } @_hl.main.1(i64 %0) { +define internal { i1, { i32, ptr }, i16 } @_hl.main.1(i64 %0) !dbg !3 { alloca_block: %"0" = alloca { i1, { i32, ptr }, i16 }, align 8 %"2_0" = alloca i64, align 8 @@ -17,14 +17,35 @@ alloca_block: entry_block: ; preds = %alloca_block store i64 %0, ptr %"2_0", align 4 %"2_01" = load i64, ptr %"2_0", align 4 - %upper_bounds_check = icmp ugt i64 %"2_01", 65535 - %inbounds = xor i1 %upper_bounds_check, true - %1 = trunc i64 %"2_01" to i16 - %2 = insertvalue { i1, { i32, ptr }, i16 } { i1 true, { i32, ptr } poison, i16 poison }, i16 %1, 2 - %3 = select i1 %inbounds, { i1, { i32, ptr }, i16 } %2, { i1, { i32, ptr }, i16 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i16 poison } - store { i1, { i32, ptr }, i16 } %3, ptr %"4_0", align 8 + %upper_bounds_check = icmp ugt i64 %"2_01", 65535, !dbg !16 + %inbounds = xor i1 %upper_bounds_check, true, !dbg !16 + %1 = trunc i64 %"2_01" to i16, !dbg !16 + %2 = insertvalue { i1, { i32, ptr }, i16 } { i1 true, { i32, ptr } poison, i16 poison }, i16 %1, 2, !dbg !16 + %3 = select i1 %inbounds, { i1, { i32, ptr }, i16 } %2, { i1, { i32, ptr }, i16 } { i1 false, { i32, ptr } { i32 2, ptr @0 }, i16 poison }, !dbg !16 + store { i1, { i32, ptr }, i16 } %3, ptr %"4_0", align 8, !dbg !16 %"4_02" = load { i1, { i32, ptr }, i16 }, ptr %"4_0", align 8 store { i1, { i32, ptr }, i16 } %"4_02", ptr %"0", align 8 %"03" = load { i1, { i32, ptr }, i16 }, ptr %"0", align 8 ret { i1, { i32, ptr }, i16 } %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !15} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, { i32, ptr }, i16 }", file: !2, size: 14, align: 8, elements: !8) +!8 = !{!9, !10, !14} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !11) +!11 = !{!12, !13} +!12 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!14 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!15 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!16 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@llvm21.snap index 625e5358f0..073721d552 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@llvm21.snap @@ -5,37 +5,50 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %acc_ptr = alloca i8, align 1 - %exp_ptr = alloca i8, align 1 - store i8 %0, ptr %acc_ptr, align 1 - store i8 %1, ptr %exp_ptr, align 1 - br label %pow + %acc_ptr = alloca i8, align 1, !dbg !8 + %exp_ptr = alloca i8, align 1, !dbg !8 + store i8 %0, ptr %acc_ptr, align 1, !dbg !8 + store i8 %1, ptr %exp_ptr, align 1, !dbg !8 + br label %pow, !dbg !8 pow: ; preds = %pow_body, %entry_block - %acc = load i8, ptr %acc_ptr, align 1 - %exp = load i8, ptr %exp_ptr, align 1 + %acc = load i8, ptr %acc_ptr, align 1, !dbg !8 + %exp = load i8, ptr %exp_ptr, align 1, !dbg !8 switch i8 %exp, label %pow_body [ i8 1, label %done i8 0, label %power_of_zero - ] + ], !dbg !8 power_of_zero: ; preds = %pow - store i8 1, ptr %acc_ptr, align 1 - br label %done + store i8 1, ptr %acc_ptr, align 1, !dbg !8 + br label %done, !dbg !8 pow_body: ; preds = %pow - %new_acc = mul i8 %acc, %0 - %new_exp = sub i8 %exp, 1 - store i8 %new_acc, ptr %acc_ptr, align 1 - store i8 %new_exp, ptr %exp_ptr, align 1 - br label %pow + %new_acc = mul i8 %acc, %0, !dbg !8 + %new_exp = sub i8 %exp, 1, !dbg !8 + store i8 %new_acc, ptr %acc_ptr, align 1, !dbg !8 + store i8 %new_exp, ptr %exp_ptr, align 1, !dbg !8 + br label %pow, !dbg !8 done: ; preds = %pow, %power_of_zero - %result = load i8, ptr %acc_ptr, align 1 + %result = load i8, ptr %acc_ptr, align 1, !dbg !8 ret i8 %result } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@pre-mem2reg@llvm21.snap index 6eae492e1e..01532c8367 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__ipow@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0, i8 %1) { +define internal i8 @_hl.main.1(i8 %0, i8 %1) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -18,36 +18,49 @@ entry_block: ; preds = %alloca_block store i8 %1, ptr %"2_1", align 1 %"2_01" = load i8, ptr %"2_0", align 1 %"2_12" = load i8, ptr %"2_1", align 1 - %acc_ptr = alloca i8, align 1 - %exp_ptr = alloca i8, align 1 - store i8 %"2_01", ptr %acc_ptr, align 1 - store i8 %"2_12", ptr %exp_ptr, align 1 - br label %pow + %acc_ptr = alloca i8, align 1, !dbg !8 + %exp_ptr = alloca i8, align 1, !dbg !8 + store i8 %"2_01", ptr %acc_ptr, align 1, !dbg !8 + store i8 %"2_12", ptr %exp_ptr, align 1, !dbg !8 + br label %pow, !dbg !8 pow: ; preds = %pow_body, %entry_block - %acc = load i8, ptr %acc_ptr, align 1 - %exp = load i8, ptr %exp_ptr, align 1 + %acc = load i8, ptr %acc_ptr, align 1, !dbg !8 + %exp = load i8, ptr %exp_ptr, align 1, !dbg !8 switch i8 %exp, label %pow_body [ i8 1, label %done i8 0, label %power_of_zero - ] + ], !dbg !8 power_of_zero: ; preds = %pow - store i8 1, ptr %acc_ptr, align 1 - br label %done + store i8 1, ptr %acc_ptr, align 1, !dbg !8 + br label %done, !dbg !8 pow_body: ; preds = %pow - %new_acc = mul i8 %acc, %"2_01" - %new_exp = sub i8 %exp, 1 - store i8 %new_acc, ptr %acc_ptr, align 1 - store i8 %new_exp, ptr %exp_ptr, align 1 - br label %pow + %new_acc = mul i8 %acc, %"2_01", !dbg !8 + %new_exp = sub i8 %exp, 1, !dbg !8 + store i8 %new_acc, ptr %acc_ptr, align 1, !dbg !8 + store i8 %new_exp, ptr %exp_ptr, align 1, !dbg !8 + br label %pow, !dbg !8 done: ; preds = %pow, %power_of_zero - %result = load i8, ptr %acc_ptr, align 1 - store i8 %result, ptr %"4_0", align 1 + %result = load i8, ptr %acc_ptr, align 1, !dbg !8 + store i8 %result, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i8, ptr %"4_0", align 1 store i8 %"4_03", ptr %"0", align 1 %"04" = load i8, ptr %"0", align 1 ret i8 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@llvm21.snap index 12f2a8bac3..65dcdda286 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@llvm21.snap @@ -5,11 +5,24 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i64 %0, i64 %1) { +define internal i64 @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = sub i64 %0, %1 + %2 = sub i64 %0, %1, !dbg !8 ret i64 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@pre-mem2reg@llvm21.snap index de5d976791..15cbc35dea 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__isub@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i64 %0, i64 %1) { +define internal i64 @_hl.main.1(i64 %0, i64 %1) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca i64, align 8 @@ -18,10 +18,23 @@ entry_block: ; preds = %alloca_block store i64 %1, ptr %"2_1", align 4 %"2_01" = load i64, ptr %"2_0", align 4 %"2_12" = load i64, ptr %"2_1", align 4 - %2 = sub i64 %"2_01", %"2_12" - store i64 %2, ptr %"4_0", align 4 + %2 = sub i64 %"2_01", %"2_12", !dbg !8 + store i64 %2, ptr %"4_0", align 4, !dbg !8 %"4_03" = load i64, ptr %"4_0", align 4 store i64 %"4_03", ptr %"0", align 4 %"04" = load i64, ptr %"0", align 4 ret i64 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@llvm21.snap index d5b6562cf1..73556091d9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@llvm21.snap @@ -5,11 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i8 %0) { +define internal i64 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = sext i8 %0 to i64 + %1 = sext i8 %0 to i64, !dbg !9 ret i64 %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@pre-mem2reg@llvm21.snap index 210ade7c30..094510d8fd 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_1_6@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i8 %0) { +define internal i64 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca i8, align 1 @@ -15,10 +15,24 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %1 = sext i8 %"2_01" to i64 - store i64 %1, ptr %"4_0", align 4 + %1 = sext i8 %"2_01" to i64, !dbg !9 + store i64 %1, ptr %"4_0", align 4, !dbg !9 %"4_02" = load i64, ptr %"4_0", align 4 store i64 %"4_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@llvm21.snap index 3591588f27..6fad8f7cd9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i8 %0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@pre-mem2reg@llvm21.snap index 8bb2d94ffa..dbc7f87312 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_s_2_3@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -15,9 +15,22 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - store i8 %"2_01", ptr %"4_0", align 1 + store i8 %"2_01", ptr %"4_0", align 1, !dbg !8 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 ret i8 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@llvm21.snap index 15b53b3304..8a46eefd53 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@llvm21.snap @@ -5,11 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i8 %0) { +define internal i64 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = zext i8 %0 to i64 + %1 = zext i8 %0 to i64, !dbg !9 ret i64 %1 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@pre-mem2reg@llvm21.snap index b4d4642d46..1490f0eb11 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_1_6@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i8 %0) { +define internal i64 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca i8, align 1 @@ -15,10 +15,24 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - %1 = zext i8 %"2_01" to i64 - store i64 %1, ptr %"4_0", align 4 + %1 = zext i8 %"2_01" to i64, !dbg !9 + store i64 %1, ptr %"4_0", align 4, !dbg !9 %"4_02" = load i64, ptr %"4_0", align 4 store i64 %"4_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !8} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!9 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@llvm21.snap index 3591588f27..6fad8f7cd9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i8 %0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@pre-mem2reg@llvm21.snap index 8bb2d94ffa..dbc7f87312 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__int__test__iwiden_u_2_3@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i8 @_hl.main.1(i8 %0) { +define internal i8 @_hl.main.1(i8 %0) !dbg !3 { alloca_block: %"0" = alloca i8, align 1 %"2_0" = alloca i8, align 1 @@ -15,9 +15,22 @@ alloca_block: entry_block: ; preds = %alloca_block store i8 %0, ptr %"2_0", align 1 %"2_01" = load i8, ptr %"2_0", align 1 - store i8 %"2_01", ptr %"4_0", align 1 + store i8 %"2_01", ptr %"4_0", align 1, !dbg !8 %"4_02" = load i8, ptr %"4_0", align 1 store i8 %"4_02", ptr %"0", align 1 %"03" = load i8, ptr %"0", align 1 ret i8 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i8", size: 8, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@llvm21.snap index 0d77291438..399d4df5de 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@llvm21.snap @@ -5,12 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = and i1 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = and i1 %0, %1, !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@pre-mem2reg@llvm21.snap index 8563eff353..10bc668ded 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__and@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i1, align 1 @@ -18,11 +18,24 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"2_1", align 1 %"2_01" = load i1, ptr %"2_0", align 1 %"2_12" = load i1, ptr %"2_1", align 1 - %2 = and i1 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = and i1 %"2_01", %"2_12", !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 + store i1 %3, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@llvm21.snap index 03398c682b..1ce27bcd06 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@llvm21.snap @@ -5,12 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = icmp eq i1 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = icmp eq i1 %0, %1, !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@pre-mem2reg@llvm21.snap index c75a7a3455..690308e5f2 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__eq@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i1, align 1 @@ -18,11 +18,24 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"2_1", align 1 %"2_01" = load i1, ptr %"2_0", align 1 %"2_12" = load i1, ptr %"2_1", align 1 - %2 = icmp eq i1 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = icmp eq i1 %"2_01", %"2_12", !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 + store i1 %3, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@llvm21.snap index 82de26a045..99e3a3fe9b 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@llvm21.snap @@ -5,12 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0) { +define internal i1 @_hl.main.1(i1 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = xor i1 %0, true - %2 = select i1 %1, i1 true, i1 false + %1 = xor i1 %0, true, !dbg !8 + %2 = select i1 %1, i1 true, i1 false, !dbg !8 ret i1 %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@pre-mem2reg@llvm21.snap index ed8ea79ee8..335bd38aaf 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__not@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0) { +define internal i1 @_hl.main.1(i1 %0) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i1, align 1 @@ -15,11 +15,24 @@ alloca_block: entry_block: ; preds = %alloca_block store i1 %0, ptr %"2_0", align 1 %"2_01" = load i1, ptr %"2_0", align 1 - %1 = xor i1 %"2_01", true - %2 = select i1 %1, i1 true, i1 false - store i1 %2, ptr %"4_0", align 1 + %1 = xor i1 %"2_01", true, !dbg !8 + %2 = select i1 %1, i1 true, i1 false, !dbg !8 + store i1 %2, ptr %"4_0", align 1, !dbg !8 %"4_02" = load i1, ptr %"4_0", align 1 store i1 %"4_02", ptr %"0", align 1 %"03" = load i1, ptr %"0", align 1 ret i1 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@llvm21.snap index 6c51219d86..52df684e34 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@llvm21.snap @@ -5,12 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = or i1 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = or i1 %0, %1, !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@pre-mem2reg@llvm21.snap index f46e6c5ca5..572bdec94c 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__or@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i1, align 1 @@ -18,11 +18,24 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"2_1", align 1 %"2_01" = load i1, ptr %"2_0", align 1 %"2_12" = load i1, ptr %"2_1", align 1 - %2 = or i1 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = or i1 %"2_01", %"2_12", !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 + store i1 %3, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@llvm21.snap index 4dadce2c22..07050aea37 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@llvm21.snap @@ -5,12 +5,25 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = xor i1 %0, %1 - %3 = select i1 %2, i1 true, i1 false + %2 = xor i1 %0, %1, !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 ret i1 %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@pre-mem2reg@llvm21.snap index b2e894f51b..60c834cfc2 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__logic__test__xor@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i1 @_hl.main.1(i1 %0, i1 %1) { +define internal i1 @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"2_0" = alloca i1, align 1 @@ -18,11 +18,24 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"2_1", align 1 %"2_01" = load i1, ptr %"2_0", align 1 %"2_12" = load i1, ptr %"2_1", align 1 - %2 = xor i1 %"2_01", %"2_12" - %3 = select i1 %2, i1 true, i1 false - store i1 %3, ptr %"4_0", align 1 + %2 = xor i1 %"2_01", %"2_12", !dbg !8 + %3 = select i1 %2, i1 true, i1 false, !dbg !8 + store i1 %3, ptr %"4_0", align 1, !dbg !8 %"4_03" = load i1, ptr %"4_0", align 1 store i1 %"4_03", ptr %"0", align 1 %"04" = load i1, ptr %"0", align 1 ret i1 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7, !7} +!7 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@llvm21.snap index 8eac00117f..2fe55650b6 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i64 42 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@pre-mem2reg@llvm21.snap index 7a197b8845..a3bca146e9 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_barrier@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 @@ -17,10 +17,23 @@ entry_block: ; preds = %alloca_block store i64 42, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"5_02" = load i64, ptr %"5_0", align 4 - store i64 %"5_01", ptr %"6_0", align 4 - store i64 %"5_02", ptr %"6_1", align 4 + store i64 %"5_01", ptr %"6_0", align 4, !dbg !8 + store i64 %"5_02", ptr %"6_1", align 4, !dbg !8 %"6_03" = load i64, ptr %"6_0", align 4 store i64 %"6_03", ptr %"0", align 4 %"04" = load i64, ptr %"0", align 4 ret i64 %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@llvm21.snap index 6dd7367ea3..8f526545df 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @sym2 = external global { i1, i64, i2 } @sym1 = external constant i64 -define internal { i64, { i1, i64, i2 } } @_hl.main.1() { +define internal { i64, { i1, i64, i2 } } @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block @@ -19,3 +19,21 @@ entry_block: ; preds = %alloca_block %mrv5 = insertvalue { i64, { i1, i64, i2 } } %mrv, { i1, i64, i2 } %sym2, 1 ret { i64, { i1, i64, i2 } } %mrv5 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, { i1, i64, i2 } }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i64, i2 }", file: !2, size: 8, align: 8, elements: !11) +!11 = !{!12, !9, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@pre-mem2reg@llvm21.snap index 9460e53efc..26b3ae1cf3 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_external_symbol@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @sym2 = external global { i1, i64, i2 } @sym1 = external constant i64 -define internal { i64, { i1, i64, i2 } } @_hl.main.1() { +define internal { i64, { i1, i64, i2 } } @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"1" = alloca { i1, i64, i2 }, align 8 @@ -31,3 +31,21 @@ entry_block: ; preds = %alloca_block %mrv5 = insertvalue { i64, { i1, i64, i2 } } %mrv, { i1, i64, i2 } %"14", 1 ret { i64, { i1, i64, i2 } } %mrv5 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i64, { i1, i64, i2 } }", file: !2, size: 16, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!10 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i64, i2 }", file: !2, size: 8, align: 8, elements: !11) +!11 = !{!12, !9, !13} +!12 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!13 = !DIBasicType(name: "i2", size: 2, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@llvm21.snap index e24f616b49..9f03abd3a3 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i64 17 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@pre-mem2reg@llvm21.snap index 25173cebaa..025e9a35fc 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_const_usize@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"5_0" = alloca i64, align 8 @@ -18,3 +18,15 @@ entry_block: ; preds = %alloca_block %"02" = load i64, ptr %"0", align 4 ret i64 %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/pIlPNzlVLClAphFGIyrhvZsHeD/UnyeIVwAutKJHaZEPSZw/XPeycUvnuj/xZKP/CTcNfsTEGLo") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@llvm21.snap index 9a841aaef9..1d1d1c2269 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@llvm21.snap @@ -8,15 +8,15 @@ source_filename = "test_context" @0 = private unnamed_addr constant [5 x i8] c"EXIT\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) { +define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 0 - %3 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 1 - %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3) - call void @abort() + %2 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 0, !dbg !10 + %3 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 1, !dbg !10 + %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3), !dbg !10 + call void @abort(), !dbg !10 %mrv = insertvalue { i16, i16 } poison, i16 0, 0 %mrv8 = insertvalue { i16, i16 } %mrv, i16 0, 1 ret { i16, i16 } %mrv8 @@ -25,3 +25,18 @@ entry_block: ; preds = %alloca_block declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i16, i16 }", file: !2, size: 4, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@pre-mem2reg@llvm21.snap index 6d121717eb..dcb844f419 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_exit@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [5 x i8] c"EXIT\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) { +define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) !dbg !3 { alloca_block: %"0" = alloca i16, align 2 %"1" = alloca i16, align 2 @@ -26,12 +26,12 @@ entry_block: ; preds = %alloca_block %"5_01" = load { i32, ptr }, ptr %"5_0", align 8 %"2_02" = load i16, ptr %"2_0", align 2 %"2_13" = load i16, ptr %"2_1", align 2 - %2 = extractvalue { i32, ptr } %"5_01", 0 - %3 = extractvalue { i32, ptr } %"5_01", 1 - %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3) - call void @abort() - store i16 0, ptr %"6_0", align 2 - store i16 0, ptr %"6_1", align 2 + %2 = extractvalue { i32, ptr } %"5_01", 0, !dbg !10 + %3 = extractvalue { i32, ptr } %"5_01", 1, !dbg !10 + %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3), !dbg !10 + call void @abort(), !dbg !10 + store i16 0, ptr %"6_0", align 2, !dbg !10 + store i16 0, ptr %"6_1", align 2, !dbg !10 %"6_04" = load i16, ptr %"6_0", align 2 %"6_15" = load i16, ptr %"6_1", align 2 store i16 %"6_04", ptr %"0", align 2 @@ -46,3 +46,18 @@ entry_block: ; preds = %alloca_block declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i16, i16 }", file: !2, size: 4, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@llvm21.snap index 8eac00117f..2fe55650b6 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i64 42 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@pre-mem2reg@llvm21.snap index 026150fc8e..48c0397618 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_load_nat@pre-mem2reg@llvm21.snap @@ -5,16 +5,29 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1() { +define internal i64 @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"4_0" = alloca i64, align 8 br label %entry_block entry_block: ; preds = %alloca_block - store i64 42, ptr %"4_0", align 4 + store i64 42, ptr %"4_0", align 4, !dbg !8 %"4_01" = load i64, ptr %"4_0", align 4 store i64 %"4_01", ptr %"0", align 4 %"02" = load i64, ptr %"0", align 4 ret i64 %"02" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@llvm21.snap index 4083171dde..151eb496b7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@llvm21.snap @@ -7,13 +7,29 @@ source_filename = "test_context" @0 = private unnamed_addr constant [7 x i8] c"Error!\00", align 1 -define internal { i32, ptr } @_hl.main.1() { +define internal { i32, ptr } @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = trunc i64 100 to i32 - %1 = insertvalue { i32, ptr } undef, i32 %0, 0 - %2 = insertvalue { i32, ptr } %1, ptr @0, 1 + %0 = trunc i64 100 to i32, !dbg !11 + %1 = insertvalue { i32, ptr } undef, i32 %0, 0, !dbg !11 + %2 = insertvalue { i32, ptr } %1, ptr @0, 1, !dbg !11 ret { i32, ptr } %2 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!11 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@pre-mem2reg@llvm21.snap index 0c7de17073..4004651bb0 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error@pre-mem2reg@llvm21.snap @@ -7,7 +7,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [7 x i8] c"Error!\00", align 1 -define internal { i32, ptr } @_hl.main.1() { +define internal { i32, ptr } @_hl.main.1() !dbg !3 { alloca_block: %"0" = alloca { i32, ptr }, align 8 %"7_0" = alloca ptr, align 8 @@ -20,12 +20,28 @@ entry_block: ; preds = %alloca_block store i64 100, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load ptr, ptr %"7_0", align 8 - %0 = trunc i64 %"5_01" to i32 - %1 = insertvalue { i32, ptr } undef, i32 %0, 0 - %2 = insertvalue { i32, ptr } %1, ptr %"7_02", 1 - store { i32, ptr } %2, ptr %"8_0", align 8 + %0 = trunc i64 %"5_01" to i32, !dbg !11 + %1 = insertvalue { i32, ptr } undef, i32 %0, 0, !dbg !11 + %2 = insertvalue { i32, ptr } %1, ptr %"7_02", 1, !dbg !11 + store { i32, ptr } %2, ptr %"8_0", align 8, !dbg !11 %"8_03" = load { i32, ptr }, ptr %"8_0", align 8 store { i32, ptr } %"8_03", ptr %"0", align 8 %"04" = load { i32, ptr }, ptr %"0", align 8 ret { i32, ptr } %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i32, ptr }", file: !2, size: 12, align: 8, elements: !8) +!8 = !{!9, !10} +!9 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_unsigned) +!10 = !DIBasicType(name: "ptr", size: 64, encoding: DW_ATE_address) +!11 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@llvm21.snap index 8511a688a8..605c0d6013 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@llvm21.snap @@ -8,21 +8,34 @@ source_filename = "test_context" @0 = private unnamed_addr constant [7 x i8] c"Error!\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = trunc i64 100 to i32 - %1 = insertvalue { i32, ptr } undef, i32 %0, 0 - %2 = insertvalue { i32, ptr } %1, ptr @0, 1 - %3 = extractvalue { i32, ptr } %2, 0 - %4 = extractvalue { i32, ptr } %2, 1 - %5 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %3, ptr %4) - call void @abort() + %0 = trunc i64 100 to i32, !dbg !7 + %1 = insertvalue { i32, ptr } undef, i32 %0, 0, !dbg !7 + %2 = insertvalue { i32, ptr } %1, ptr @0, 1, !dbg !7 + %3 = extractvalue { i32, ptr } %2, 0, !dbg !8 + %4 = extractvalue { i32, ptr } %2, 1, !dbg !8 + %5 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %3, ptr %4), !dbg !8 + call void @abort(), !dbg !8 ret void } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/NzlVLClAph/GIyr/vZsHeDgUnyeIVwAutKJH/ZEPSZwPXPeycUvnu/GxZKPRCTcNfsTEGLoPGCKH") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@pre-mem2reg@llvm21.snap index e2ad8c161b..747f12664d 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_error_and_panic@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [7 x i8] c"Error!\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"7_0" = alloca ptr, align 8 %"5_0" = alloca i64, align 8 @@ -20,18 +20,31 @@ entry_block: ; preds = %alloca_block store i64 100, ptr %"5_0", align 4 %"5_01" = load i64, ptr %"5_0", align 4 %"7_02" = load ptr, ptr %"7_0", align 8 - %0 = trunc i64 %"5_01" to i32 - %1 = insertvalue { i32, ptr } undef, i32 %0, 0 - %2 = insertvalue { i32, ptr } %1, ptr %"7_02", 1 - store { i32, ptr } %2, ptr %"8_0", align 8 + %0 = trunc i64 %"5_01" to i32, !dbg !7 + %1 = insertvalue { i32, ptr } undef, i32 %0, 0, !dbg !7 + %2 = insertvalue { i32, ptr } %1, ptr %"7_02", 1, !dbg !7 + store { i32, ptr } %2, ptr %"8_0", align 8, !dbg !7 %"8_03" = load { i32, ptr }, ptr %"8_0", align 8 - %3 = extractvalue { i32, ptr } %"8_03", 0 - %4 = extractvalue { i32, ptr } %"8_03", 1 - %5 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %3, ptr %4) - call void @abort() + %3 = extractvalue { i32, ptr } %"8_03", 0, !dbg !8 + %4 = extractvalue { i32, ptr } %"8_03", 1, !dbg !8 + %5 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %3, ptr %4), !dbg !8 + call void @abort(), !dbg !8 ret void } declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/NzlVLClAph/GIyr/vZsHeDgUnyeIVwAutKJH/ZEPSZwPXPeycUvnu/GxZKPRCTcNfsTEGLoPGCKH") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) +!8 = !DILocation(line: 5388, column: 404, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@llvm21.snap index c88d66ca70..97cd220915 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@llvm21.snap @@ -5,12 +5,27 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1(i1 %0, i1 %1) { +define internal { i1, i1 } @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = insertvalue { i1, i1 } poison, i1 %0, 0 - %3 = insertvalue { i1, i1 } %2, i1 %1, 1 + %2 = insertvalue { i1, i1 } poison, i1 %0, 0, !dbg !10 + %3 = insertvalue { i1, i1 } %2, i1 %1, 1, !dbg !10 ret { i1, i1 } %3 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@pre-mem2reg@llvm21.snap index bcc7c9d7b6..f48aeac740 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_make_tuple@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1(i1 %0, i1 %1) { +define internal { i1, i1 } @_hl.main.1(i1 %0, i1 %1) !dbg !3 { alloca_block: %"0" = alloca { i1, i1 }, align 8 %"2_0" = alloca i1, align 1 @@ -18,11 +18,26 @@ entry_block: ; preds = %alloca_block store i1 %1, ptr %"2_1", align 1 %"2_01" = load i1, ptr %"2_0", align 1 %"2_12" = load i1, ptr %"2_1", align 1 - %2 = insertvalue { i1, i1 } poison, i1 %"2_01", 0 - %3 = insertvalue { i1, i1 } %2, i1 %"2_12", 1 - store { i1, i1 } %3, ptr %"4_0", align 1 + %2 = insertvalue { i1, i1 } poison, i1 %"2_01", 0, !dbg !10 + %3 = insertvalue { i1, i1 } %2, i1 %"2_12", 1, !dbg !10 + store { i1, i1 } %3, ptr %"4_0", align 1, !dbg !10 %"4_03" = load { i1, i1 }, ptr %"4_0", align 1 store { i1, i1 } %"4_03", ptr %"0", align 1 %"04" = load { i1, i1 }, ptr %"0", align 1 ret { i1, i1 } %"04" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@llvm21.snap index 6bf9adcc7b..ea972b21b7 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@llvm21.snap @@ -5,10 +5,22 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i64 %0) { +define internal i64 @_hl.main.1(i64 %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block ret i64 %0 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@pre-mem2reg@llvm21.snap index c194755bd8..dd1b53bb33 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_noop@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal i64 @_hl.main.1(i64 %0) { +define internal i64 @_hl.main.1(i64 %0) !dbg !3 { alloca_block: %"0" = alloca i64, align 8 %"2_0" = alloca i64, align 8 @@ -15,9 +15,22 @@ alloca_block: entry_block: ; preds = %alloca_block store i64 %0, ptr %"2_0", align 4 %"2_01" = load i64, ptr %"2_0", align 4 - store i64 %"2_01", ptr %"4_0", align 4 + store i64 %"2_01", ptr %"4_0", align 4, !dbg !8 %"4_02" = load i64, ptr %"4_0", align 4 store i64 %"4_02", ptr %"0", align 4 %"03" = load i64, ptr %"0", align 4 ret i64 %"03" } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DIBasicType(name: "i64", size: 64, encoding: DW_ATE_unsigned) +!8 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@llvm21.snap index b1f1291bf8..474ba4433e 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@llvm21.snap @@ -8,15 +8,15 @@ source_filename = "test_context" @0 = private unnamed_addr constant [6 x i8] c"PANIC\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) { +define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %2 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 0 - %3 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 1 - %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3) - call void @abort() + %2 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 0, !dbg !10 + %3 = extractvalue { i32, ptr } { i32 42, ptr @0 }, 1, !dbg !10 + %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3), !dbg !10 + call void @abort(), !dbg !10 %mrv = insertvalue { i16, i16 } poison, i16 0, 0 %mrv8 = insertvalue { i16, i16 } %mrv, i16 0, 1 ret { i16, i16 } %mrv8 @@ -25,3 +25,18 @@ entry_block: ; preds = %alloca_block declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i16, i16 }", file: !2, size: 4, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@pre-mem2reg@llvm21.snap index 27a37af50c..43add76529 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_panic@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [6 x i8] c"PANIC\00", align 1 @prelude.panic_template = private unnamed_addr constant [34 x i8] c"Program panicked (signal %i): %s\0A\00", align 1 -define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) { +define internal { i16, i16 } @_hl.main.1(i16 %0, i16 %1) !dbg !3 { alloca_block: %"0" = alloca i16, align 2 %"1" = alloca i16, align 2 @@ -26,12 +26,12 @@ entry_block: ; preds = %alloca_block %"5_01" = load { i32, ptr }, ptr %"5_0", align 8 %"2_02" = load i16, ptr %"2_0", align 2 %"2_13" = load i16, ptr %"2_1", align 2 - %2 = extractvalue { i32, ptr } %"5_01", 0 - %3 = extractvalue { i32, ptr } %"5_01", 1 - %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3) - call void @abort() - store i16 0, ptr %"6_0", align 2 - store i16 0, ptr %"6_1", align 2 + %2 = extractvalue { i32, ptr } %"5_01", 0, !dbg !10 + %3 = extractvalue { i32, ptr } %"5_01", 1, !dbg !10 + %4 = call i32 (ptr, ...) @printf(ptr @prelude.panic_template, i32 %2, ptr %3), !dbg !10 + call void @abort(), !dbg !10 + store i16 0, ptr %"6_0", align 2, !dbg !10 + store i16 0, ptr %"6_1", align 2, !dbg !10 %"6_04" = load i16, ptr %"6_0", align 2 %"6_15" = load i16, ptr %"6_1", align 2 store i16 %"6_04", ptr %"0", align 2 @@ -46,3 +46,18 @@ entry_block: ; preds = %alloca_block declare i32 @printf(ptr, ...) declare void @abort() + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !9, !9} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i16, i16 }", file: !2, size: 4, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i16", size: 16, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@llvm21.snap index 3d2b09da46..923f1bc879 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@llvm21.snap @@ -8,13 +8,25 @@ source_filename = "test_context" @0 = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1 @prelude.print_template = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %0 = call i32 (ptr, ...) @printf(ptr @prelude.print_template, ptr @0) + %0 = call i32 (ptr, ...) @printf(ptr @prelude.print_template, ptr @0), !dbg !7 ret void } declare i32 @printf(ptr, ...) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@pre-mem2reg@llvm21.snap index ff0d3d2aa7..bac9367ed8 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_print@pre-mem2reg@llvm21.snap @@ -8,7 +8,7 @@ source_filename = "test_context" @0 = private unnamed_addr constant [14 x i8] c"Hello, world!\00", align 1 @prelude.print_template = private unnamed_addr constant [4 x i8] c"%s\0A\00", align 1 -define internal void @_hl.main.1() { +define internal void @_hl.main.1() !dbg !3 { alloca_block: %"5_0" = alloca ptr, align 8 br label %entry_block @@ -16,8 +16,20 @@ alloca_block: entry_block: ; preds = %alloca_block store ptr @0, ptr %"5_0", align 8 %"5_01" = load ptr, ptr %"5_0", align 8 - %0 = call i32 (ptr, ...) @printf(ptr @prelude.print_template, ptr %"5_01") + %0 = call i32 (ptr, ...) @printf(ptr @prelude.print_template, ptr %"5_01"), !dbg !7 ret void } declare i32 @printf(ptr, ...) + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{null} +!7 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@llvm21.snap index 6415649c7c..60a55f1423 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@llvm21.snap @@ -5,14 +5,29 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1({ i1, i1 } %0) { +define internal { i1, i1 } @_hl.main.1({ i1, i1 } %0) !dbg !3 { alloca_block: br label %entry_block entry_block: ; preds = %alloca_block - %1 = extractvalue { i1, i1 } %0, 0 - %2 = extractvalue { i1, i1 } %0, 1 + %1 = extractvalue { i1, i1 } %0, 0, !dbg !10 + %2 = extractvalue { i1, i1 } %0, 1, !dbg !10 %mrv = insertvalue { i1, i1 } poison, i1 %1, 0 %mrv6 = insertvalue { i1, i1 } %mrv, i1 %2, 1 ret { i1, i1 } %mrv6 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@pre-mem2reg@llvm21.snap b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@pre-mem2reg@llvm21.snap index 0169d9733f..cd2645edeb 100644 --- a/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@pre-mem2reg@llvm21.snap +++ b/hugr-llvm/src/extension/snapshots/hugr_llvm__extension__prelude__test__prelude_unpack_tuple@pre-mem2reg@llvm21.snap @@ -5,7 +5,7 @@ expression: mod_str ; ModuleID = 'test_context' source_filename = "test_context" -define internal { i1, i1 } @_hl.main.1({ i1, i1 } %0) { +define internal { i1, i1 } @_hl.main.1({ i1, i1 } %0) !dbg !3 { alloca_block: %"0" = alloca i1, align 1 %"1" = alloca i1, align 1 @@ -17,10 +17,10 @@ alloca_block: entry_block: ; preds = %alloca_block store { i1, i1 } %0, ptr %"2_0", align 1 %"2_01" = load { i1, i1 }, ptr %"2_0", align 1 - %1 = extractvalue { i1, i1 } %"2_01", 0 - %2 = extractvalue { i1, i1 } %"2_01", 1 - store i1 %1, ptr %"4_0", align 1 - store i1 %2, ptr %"4_1", align 1 + %1 = extractvalue { i1, i1 } %"2_01", 0, !dbg !10 + %2 = extractvalue { i1, i1 } %"2_01", 1, !dbg !10 + store i1 %1, ptr %"4_0", align 1, !dbg !10 + store i1 %2, ptr %"4_1", align 1, !dbg !10 %"4_02" = load i1, ptr %"4_0", align 1 %"4_13" = load i1, ptr %"4_1", align 1 store i1 %"4_02", ptr %"0", align 1 @@ -31,3 +31,18 @@ entry_block: ; preds = %alloca_block %mrv6 = insertvalue { i1, i1 } %mrv, i1 %"15", 1 ret { i1, i1 } %mrv6 } + +!llvm.module.flags = !{!0} +!llvm.dbg.cu = !{!1} + +!0 = !{i32 2, !"Debug Info Version", i32 3} +!1 = distinct !DICompileUnit(language: DW_LANG_Python, file: !2, producer: "hugr_llvm_test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug) +!2 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "/lPNzlV/ClAphFG/yrhvZs/eDgUn/eIVwAutKJHaZEPSZwPXPeycUvnujGxZ") +!3 = distinct !DISubprogram(name: "_hl.main.1", linkageName: "_hl.main.1", scope: null, file: !4, line: 25254, type: !5, scopeLine: 25255, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1) +!4 = !DIFile(filename: "/cmJrSnVYeXFf/zCkHdtWCCnkJhPKiWSKICgZuRNRvR/mbrfVq.gpy.py", directory: "") +!5 = !DISubroutineType(types: !6) +!6 = !{!7, !7} +!7 = !DICompositeType(tag: DW_TAG_structure_type, name: "{ i1, i1 }", file: !2, align: 8, elements: !8) +!8 = !{!9, !9} +!9 = !DIBasicType(name: "i1", size: 1, encoding: DW_ATE_unsigned) +!10 = !DILocation(line: 27062, column: 402, scope: !3) diff --git a/hugr-llvm/src/test.rs b/hugr-llvm/src/test.rs index b4583deb13..ed8d1f9d92 100644 --- a/hugr-llvm/src/test.rs +++ b/hugr-llvm/src/test.rs @@ -15,7 +15,9 @@ use rstest::fixture; use crate::{ custom::{CodegenExtsBuilder, CodegenExtsMap}, - emit::{EmitHugr, EmitModuleContext, Namer, test::Emission}, + emit::{ + EmitHugr, EmitModuleContext, Namer, debug_info::test::add_random_debug_info, test::Emission, + }, types::{TypeConverter, TypingSession}, utils::fat::FatExt as _, }; @@ -169,8 +171,11 @@ impl TestContext { /// by `entry_point` in the inner module. /// /// That function must take no arguments and return FFI-compatible type `T`. - pub fn exec_hugr(&self, hugr: THugrView, entry_point: impl AsRef) -> T { - let emission = Emission::emit_hugr(hugr.fat_root().unwrap(), self.get_emit_hugr()).unwrap(); + pub fn exec_hugr(&self, mut hugr: THugrView, entry_point: impl AsRef) -> T { + // We add random debug info to all test HUGRs for coverage. + add_random_debug_info(&mut hugr); + let emission = + Emission::emit_hugr(hugr.fat_root().unwrap(), self.get_emit_hugr(), true).unwrap(); emission.verify().unwrap(); emission.jit_exec::(entry_point).unwrap() @@ -226,8 +231,11 @@ impl TestContext { /// /// For this to work, [`Emission::exec_panicking`] must be used together with the /// [`crate::emit::test::PanicTestPreludeCodegen`]. - pub fn exec_hugr_panicking(&self, hugr: THugrView, entry_point: impl AsRef) -> String { - let emission = Emission::emit_hugr(hugr.fat_root().unwrap(), self.get_emit_hugr()).unwrap(); + pub fn exec_hugr_panicking(&self, mut hugr: THugrView, entry_point: impl AsRef) -> String { + // We add random debug info to all test HUGRs for coverage. + add_random_debug_info(&mut hugr); + let emission = + Emission::emit_hugr(hugr.fat_root().unwrap(), self.get_emit_hugr(), true).unwrap(); emission.verify().unwrap(); emission.exec_panicking(entry_point).unwrap() diff --git a/hugr-persistent/src/trait_impls.rs b/hugr-persistent/src/trait_impls.rs index a82b744900..c516fba382 100644 --- a/hugr-persistent/src/trait_impls.rs +++ b/hugr-persistent/src/trait_impls.rs @@ -296,6 +296,9 @@ impl HugrView for PersistentHugr { .collect(); NodeLabel::Custom(labels) } + NodeLabel::MetadataValues { print_keys } => NodeLabel::MetadataValues { + print_keys: print_keys.clone(), + }, }; // Map config accordingly diff --git a/hugr-py/rust/metadata.rs b/hugr-py/rust/metadata.rs index 771eaa54de..001c284860 100644 --- a/hugr-py/rust/metadata.rs +++ b/hugr-py/rust/metadata.rs @@ -23,7 +23,6 @@ pub mod metadata { #[pymodule_export] const HUGR_USED_EXTENSIONS: &str = hugr_core::metadata::HugrUsedExtensions::KEY; - // TODO: Get from rust implementation once it exists. #[pymodule_export] - const HUGR_DEBUG_INFO: &str = "core.debug_info"; + const HUGR_DEBUG_INFO: &str = hugr_core::metadata::DEBUGINFO_META_KEY; }