diff --git a/Cargo.lock b/Cargo.lock index 2dea6b2af6f..c4f0e6aa9ea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3023,6 +3023,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" [[package]] name = "section_mangler" version = "0.0.1" +dependencies = [ + "nom", +] [[package]] name = "security-framework" diff --git a/compiler/plc_ast/src/ast.rs b/compiler/plc_ast/src/ast.rs index 83a218d5ecd..7aa3a0a546c 100644 --- a/compiler/plc_ast/src/ast.rs +++ b/compiler/plc_ast/src/ast.rs @@ -600,7 +600,6 @@ pub enum AstStatement { DefaultValue(DefaultValue), // Literals Literal(AstLiteral), - CastStatement(CastStatement), MultipliedStatement(MultipliedStatement), // Expressions ReferenceExpr(ReferenceExpr), @@ -735,9 +734,6 @@ impl Debug for AstNode { } AstStatement::ContinueStatement(..) => f.debug_struct("ContinueStatement").finish(), AstStatement::ExitStatement(..) => f.debug_struct("ExitStatement").finish(), - AstStatement::CastStatement(CastStatement { target, type_name }) => { - f.debug_struct("CastStatement").field("type_name", type_name).field("target", target).finish() - } AstStatement::ReferenceExpr(ReferenceExpr { access, base }) => { f.debug_struct("ReferenceExpr").field("kind", access).field("base", base).finish() } diff --git a/compiler/plc_ast/src/lib.rs b/compiler/plc_ast/src/lib.rs index 7e7d78a7dee..33febadee02 100644 --- a/compiler/plc_ast/src/lib.rs +++ b/compiler/plc_ast/src/lib.rs @@ -7,3 +7,4 @@ pub mod control_statements; pub mod literals; mod pre_processor; pub mod provider; +pub mod visitor; diff --git a/compiler/plc_ast/src/visitor.rs b/compiler/plc_ast/src/visitor.rs new file mode 100644 index 00000000000..0aab9108ea9 --- /dev/null +++ b/compiler/plc_ast/src/visitor.rs @@ -0,0 +1,714 @@ +//! This module defines the `AstVisitor` trait and its associated macros. +//! The `AstVisitor` trait provides a set of methods for traversing and visiting ASTs + +use crate::ast::AstNode; +use crate::ast::*; +use crate::control_statements::{AstControlStatement, ConditionalBlock, ReturnStatement}; +use crate::literals::AstLiteral; + +/// Macro that calls the visitor's `visit` method for every AstNode in the passed iterator `iter`. +macro_rules! visit_all_nodes { + ($visitor:expr, $iter:expr) => { + for node in $iter { + $visitor.visit(node); + } + }; +} + +/// Macro that calls the visitor's `visit` method for every AstNode in the passed sequence of nodes. +macro_rules! visit_nodes { + ($visitor:expr, $($node:expr),*) => { + $( + $visitor.visit($node); + )* + }; +} + +/// The `Walker` implements the traversal of the AST nodes and Ast-related objects (e.g. CompilationUnit). +/// The `walk` method is called on the object to visit its children. +/// If the object passed to a `AstVisitor`'s `visit` method implements the `Walker` trait, +/// a call to the it's walk function continues the visiting process on its children. +/// +/// Spliting the traversal logic into a separate trait allows to call the default traversal logic +/// from the visitor while overriding the visitor's `visit` method for specific nodes. +/// +/// # Example +/// ``` +/// use plc_ast::ast::AstNode; +/// use plc_ast::visitor::Walker; +/// use plc_ast::visitor::AstVisitor; +/// +/// struct MyAssignment { +/// left: AstNode, +/// right: AstNode, +/// } +/// +/// impl Walker for MyAssignment { +/// fn walk(&self, visitor: &mut V) +/// where +/// V: AstVisitor, +/// { +/// visitor.visit(&self.right); +/// visitor.visit(&self.left); +/// } +/// } +/// ``` +/// +pub trait Walker { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor; +} + +/// The `AstVisitor` trait provides a set of methods for visiting different types of AST nodes. +/// Implementors can individually override the methods they are interested in. When overriding a method, +/// make sure to call `walk` on the visited statement to visit its children. DO NOT call walk on +/// the node itself to avoid a recursion (last parameter). Implementors may also decide to not call +/// the statement's `walk` method to avoid visiting the children of the statement. +/// +/// The visitor offers strongly typed `visit_X` functions for every node type. The function's signature +/// is `fn visit_X(&mut self, stmt: &X, node: &AstNode)`. The `stmt` parameter is the unwrapped, typed +/// node and the `node` parameter is the `AstNode` wrapping the stmt. The `AstNode` node offers access to location +/// information and the AstId. Note that some nodes are not wrapped in an `AstNode` node (e.g. `CompilationUnit`) +/// and therefore only the strongly typed node is passed to the `visit_X` function. +/// +/// # Example +/// ``` +/// use plc_ast::{ +/// ast::{Assignment, AstNode}, +/// visitor::{AstVisitor, Walker}, +/// }; +/// +/// struct AssignmentCounter { +/// count: usize, +/// } +/// +/// impl AstVisitor for AssignmentCounter { +/// fn visit_assignment(&mut self, stmt: &Assignment, _node: &AstNode) { +/// self.count += 1; +/// // visit child nodes +/// stmt.walk(self); +/// } +/// +/// fn visit_output_assignment(&mut self, stmt: &Assignment, _node: &AstNode) { +/// self.count += 1; +/// // visit child nodes +/// stmt.walk(self); +/// } +/// } +/// ``` +pub trait AstVisitor: Sized { + /// Visits this `AstNode`. The default implementation calls the `walk` method on the node + /// and will eventually call the strongly typed `visit` method for the node (e.g. visit_assignment + /// if the node is an `AstStatement::Assignment`). + /// # Arguments + /// * `node` - The `AstNode` node to visit. + fn visit(&mut self, node: &AstNode) { + node.walk(self) + } + + /// Visits a `CompilationUnit` node. + /// Make sure to call `walk` on the `CompilationUnit` node to visit its children. + /// # Arguments + /// * `unit` - The unwraped, typed `CompilationUnit` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_compilation_unit(&mut self, unit: &CompilationUnit) { + unit.walk(self) + } + + /// Visits an `Implementation` node. + /// Make sure to call `walk` on the `Implementation` node to visit its children. + /// # Arguments + /// * `implementation` - The unwraped, typed `Implementation` node to visit. + fn visit_implementation(&mut self, implementation: &Implementation) { + implementation.walk(self); + } + + /// Visits a `DataTypeDeclaration` node. + /// Make sure to call `walk` on the `VariableBlock` node to visit its children. + /// # Arguments + /// * `block` - The unwraped, typed `VariableBlock` node to visit. + fn visit_variable_block(&mut self, block: &VariableBlock) { + block.walk(self) + } + + /// Visits a `Variable` node. + /// Make sure to call `walk` on the `Variable` node to visit its children. + /// # Arguments + /// * `variable` - The unwraped, typed `Variable` node to visit. + fn visit_variable(&mut self, variable: &Variable) { + variable.walk(self); + } + + /// Visits an enum element `AstNode` node. + /// Make sure to call `walk` on the `AstNode` node to visit its children. + /// # Arguments + /// * `element` - The unwraped, typed `AstNode` node to visit. + fn visit_enum_element(&mut self, element: &AstNode) { + element.walk(self); + } + + /// Visits a `DataTypeDeclaration` node. + /// Make sure to call `walk` on the `DataTypeDeclaration` node to visit its children. + /// # Arguments + /// * `data_type_declaration` - The unwraped, typed `DataTypeDeclaration` node to visit. + fn visit_data_type_declaration(&mut self, data_type_declaration: &DataTypeDeclaration) { + data_type_declaration.walk(self); + } + + /// Visits a `UserTypeDeclaration` node. + /// Make sure to call `walk` on the `UserTypeDeclaration` node to visit its children. + /// # Arguments + /// * `user_type` - The unwraped, typed `UserTypeDeclaration` node to visit. + fn visit_user_type_declaration(&mut self, user_type: &UserTypeDeclaration) { + user_type.walk(self); + } + + /// Visits a `UserTypeDeclaration` node. + /// Make sure to call `walk` on the `DataType` node to visit its children. + /// # Arguments + /// * `data_type` - The unwraped, typed `DataType` node to visit. + fn visit_data_type(&mut self, data_type: &DataType) { + data_type.walk(self); + } + + /// Visits a `Pou` node. + /// Make sure to call `walk` on the `Pou` node to visit its children. + /// # Arguments + /// * `pou` - The unwraped, typed `Pou` node to visit. + fn visit_pou(&mut self, pou: &Pou) { + pou.walk(self); + } + + /// Visits an `EmptyStatement` node. + /// # Arguments + /// * `stmt` - The unwraped, typed `EmptyStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_empty_statement(&mut self, _stmt: &EmptyStatement, _node: &AstNode) {} + + /// Visits a `DefaultValue` node. + /// # Arguments + /// * `stmt` - The unwraped, typed `DefaultValue` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_default_value(&mut self, _stmt: &DefaultValue, _node: &AstNode) {} + + /// Visits an `AstLiteral` node. + /// Make sure to call `walk` on the `AstLiteral` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `AstLiteral` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_literal(&mut self, stmt: &AstLiteral, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `MultipliedStatement` node. + /// Make sure to call `walk` on the `MultipliedStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `MultipliedStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_multiplied_statement(&mut self, stmt: &MultipliedStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `ReferenceExpr` node. + /// Make sure to call `walk` on the `ReferenceExpr` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `ReferenceExpr` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_reference_expr(&mut self, stmt: &ReferenceExpr, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits an `Identifier` node. + /// Make sure to call `walk` on the `Identifier` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `Identifier` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_identifier(&mut self, _stmt: &str, _node: &AstNode) {} + + /// Visits a `DirectAccess` node. + /// Make sure to call `walk` on the `DirectAccess` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `DirectAccess` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_direct_access(&mut self, stmt: &DirectAccess, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `HardwareAccess` node. + /// Make sure to call `walk` on the `HardwareAccess` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `HardwareAccess` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_hardware_access(&mut self, stmt: &HardwareAccess, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `BinaryExpression` node. + /// Make sure to call `walk` on the `BinaryExpression` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `BinaryExpression` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_binary_expression(&mut self, stmt: &BinaryExpression, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `UnaryExpression` node. + /// Make sure to call `walk` on the `UnaryExpression` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `UnaryExpression` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_unary_expression(&mut self, stmt: &UnaryExpression, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits an `ExpressionList` node. + /// Make sure to call `walk` on the `Vec` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `ExpressionList` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_expression_list(&mut self, stmt: &Vec, _node: &AstNode) { + visit_all_nodes!(self, stmt); + } + + /// Visits a `ParenExpression` node. + /// Make sure to call `walk` on the inner `AstNode` node to visit its children. + /// # Arguments + /// * `inner` - The unwraped, typed inner `AstNode` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_paren_expression(&mut self, inner: &AstNode, _node: &AstNode) { + inner.walk(self) + } + + /// Visits a `RangeStatement` node. + /// Make sure to call `walk` on the `RangeStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `RangeStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_range_statement(&mut self, stmt: &RangeStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `VlaRangeStatement` node. + /// # Arguments + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_vla_range_statement(&mut self, _node: &AstNode) {} + + /// Visits an `Assignment` node. + /// Make sure to call `walk` on the `Assignment` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `Assignment` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_assignment(&mut self, stmt: &Assignment, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits an `OutputAssignment` node. + /// Make sure to call `walk` on the `Assignment` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `Assignment` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_output_assignment(&mut self, stmt: &Assignment, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `CallStatement` node. + /// Make sure to call `walk` on the `CallStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `CallStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_call_statement(&mut self, stmt: &CallStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits an `AstControlStatement` node. + /// Make sure to call `walk` on the `AstControlStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `AstControlStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_control_statement(&mut self, stmt: &AstControlStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `CaseCondition` node. + /// Make sure to call `walk` on the child-`AstNode` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `CaseCondition` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_case_condition(&mut self, child: &AstNode, _node: &AstNode) { + child.walk(self) + } + + /// Visits an `ExitStatement` node. + /// # Arguments + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_exit_statement(&mut self, _node: &AstNode) {} + + /// Visits a `ContinueStatement` node. + /// # Arguments + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_continue_statement(&mut self, _node: &AstNode) {} + + /// Visits a `ReturnStatement` node. + /// Make sure to call `walk` on the `ReturnStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `ReturnStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_return_statement(&mut self, stmt: &ReturnStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `JumpStatement` node. + /// Make sure to call `walk` on the `JumpStatement` node to visit its children. + /// # Arguments + /// * `stmt` - The unwraped, typed `JumpStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_jump_statement(&mut self, stmt: &JumpStatement, _node: &AstNode) { + stmt.walk(self) + } + + /// Visits a `LabelStatement` node. + /// # Arguments + /// * `stmt` - The unwraped, typed `LabelStatement` node to visit. + /// * `node` - The wrapped `AstNode` node to visit. Offers access to location information and AstId + fn visit_label_statement(&mut self, _stmt: &LabelStatement, _node: &AstNode) {} +} + +/// Helper method that walks through a slice of `ConditionalBlock` and applies the visitor's `walk` method to each node. +fn walk_conditional_blocks(visitor: &mut V, blocks: &[ConditionalBlock]) +where + V: AstVisitor, +{ + for b in blocks { + visit_nodes!(visitor, &b.condition); + visit_all_nodes!(visitor, &b.body); + } +} + +impl Walker for AstLiteral { + fn walk(&self, _visitor: &mut V) + where + V: AstVisitor, + { + // do nothing + } +} + +impl Walker for MultipliedStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visitor.visit(&self.element) + } +} + +impl Walker for ReferenceExpr { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + if let Some(base) = &self.base { + visitor.visit(base); + } + + match &self.access { + ReferenceAccess::Member(t) | ReferenceAccess::Index(t) | ReferenceAccess::Cast(t) => { + visitor.visit(t) + } + _ => {} + } + } +} + +impl Walker for DirectAccess { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.index); + } +} + +impl Walker for HardwareAccess { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_all_nodes!(visitor, &self.address); + } +} + +impl Walker for BinaryExpression { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.left, &self.right); + } +} + +impl Walker for UnaryExpression { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.value); + } +} + +impl Walker for Assignment { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.left, &self.right); + } +} + +impl Walker for RangeStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.start, &self.end); + } +} + +impl Walker for CallStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.operator); + if let Some(params) = &self.parameters { + visit_nodes!(visitor, params); + } + } +} + +impl Walker for AstControlStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + match self { + AstControlStatement::If(stmt) => { + walk_conditional_blocks(visitor, &stmt.blocks); + visit_all_nodes!(visitor, &stmt.else_block); + } + AstControlStatement::WhileLoop(stmt) | AstControlStatement::RepeatLoop(stmt) => { + visit_nodes!(visitor, &stmt.condition); + visit_all_nodes!(visitor, &stmt.body); + } + AstControlStatement::ForLoop(stmt) => { + visit_nodes!(visitor, &stmt.counter, &stmt.start, &stmt.end); + visit_all_nodes!(visitor, &stmt.by_step); + visit_all_nodes!(visitor, &stmt.body); + } + AstControlStatement::Case(stmt) => { + visit_nodes!(visitor, &stmt.selector); + walk_conditional_blocks(visitor, &stmt.case_blocks); + visit_all_nodes!(visitor, &stmt.else_block); + } + } + } +} + +impl Walker for ReturnStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_all_nodes!(visitor, &self.condition); + } +} + +impl Walker for JumpStatement { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_nodes!(visitor, &self.condition, &self.target); + } +} + +impl Walker for AstNode { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + let node = self; + match &self.stmt { + AstStatement::EmptyStatement(stmt) => visitor.visit_empty_statement(stmt, node), + AstStatement::DefaultValue(stmt) => visitor.visit_default_value(stmt, node), + AstStatement::Literal(stmt) => visitor.visit_literal(stmt, node), + AstStatement::MultipliedStatement(stmt) => visitor.visit_multiplied_statement(stmt, node), + AstStatement::ReferenceExpr(stmt) => visitor.visit_reference_expr(stmt, node), + AstStatement::Identifier(stmt) => visitor.visit_identifier(stmt, node), + AstStatement::DirectAccess(stmt) => visitor.visit_direct_access(stmt, node), + AstStatement::HardwareAccess(stmt) => visitor.visit_hardware_access(stmt, node), + AstStatement::BinaryExpression(stmt) => visitor.visit_binary_expression(stmt, node), + AstStatement::UnaryExpression(stmt) => visitor.visit_unary_expression(stmt, node), + AstStatement::ExpressionList(stmt) => visitor.visit_expression_list(stmt, node), + AstStatement::ParenExpression(stmt) => visitor.visit_paren_expression(stmt, node), + AstStatement::RangeStatement(stmt) => visitor.visit_range_statement(stmt, node), + AstStatement::VlaRangeStatement => visitor.visit_vla_range_statement(node), + AstStatement::Assignment(stmt) => visitor.visit_assignment(stmt, node), + AstStatement::OutputAssignment(stmt) => visitor.visit_output_assignment(stmt, node), + AstStatement::CallStatement(stmt) => visitor.visit_call_statement(stmt, node), + AstStatement::ControlStatement(stmt) => visitor.visit_control_statement(stmt, node), + AstStatement::CaseCondition(stmt) => visitor.visit_case_condition(stmt, node), + AstStatement::ExitStatement(_stmt) => visitor.visit_exit_statement(node), + AstStatement::ContinueStatement(_stmt) => visitor.visit_continue_statement(node), + AstStatement::ReturnStatement(stmt) => visitor.visit_return_statement(stmt, node), + AstStatement::JumpStatement(stmt) => visitor.visit_jump_statement(stmt, node), + AstStatement::LabelStatement(stmt) => visitor.visit_label_statement(stmt, node), + } + } +} + +impl Walker for CompilationUnit { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + for block in &self.global_vars { + visitor.visit_variable_block(block); + } + + for user_type in &self.user_types { + visitor.visit_user_type_declaration(user_type); + } + + for pou in &self.units { + visitor.visit_pou(pou); + } + + for i in &self.implementations { + visitor.visit_implementation(i); + } + } +} + +impl Walker for UserTypeDeclaration { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visitor.visit_data_type(&self.data_type); + visit_all_nodes!(visitor, &self.initializer); + } +} + +impl Walker for VariableBlock { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + for v in self.variables.iter() { + visitor.visit_variable(v); + } + } +} + +impl Walker for Variable { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + visit_all_nodes!(visitor, &self.address); + visitor.visit_data_type_declaration(&self.data_type_declaration); + visit_all_nodes!(visitor, &self.initializer); + } +} + +impl Walker for DataType { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + match self { + DataType::StructType { variables, .. } => { + for v in variables.iter() { + visitor.visit_variable(v); + } + } + DataType::EnumType { elements, .. } => { + for ele in flatten_expression_list(elements) { + visitor.visit_enum_element(ele); + } + } + DataType::SubRangeType { bounds, .. } => { + visit_all_nodes!(visitor, bounds); + } + DataType::ArrayType { bounds, referenced_type, .. } => { + visitor.visit(bounds); + visitor.visit_data_type_declaration(referenced_type); + } + DataType::PointerType { referenced_type, .. } => { + visitor.visit_data_type_declaration(referenced_type); + } + DataType::StringType { size, .. } => { + visit_all_nodes!(visitor, size); + } + DataType::VarArgs { referenced_type, .. } => { + if let Some(data_type_declaration) = referenced_type { + visitor.visit_data_type_declaration(data_type_declaration); + } + } + DataType::GenericType { .. } => { + //no further visits + } + } + } +} + +impl Walker for DataTypeDeclaration { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + if let DataTypeDeclaration::DataTypeDefinition { data_type, .. } = self { + visitor.visit_data_type(data_type); + } + } +} + +impl Walker for Option +where + T: Walker, +{ + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + if let Some(node) = self { + node.walk(visitor); + } + } +} + +impl Walker for Pou { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + for block in &self.variable_blocks { + visitor.visit_variable_block(block); + } + + self.return_type.as_ref().inspect(|rt| visitor.visit_data_type_declaration(rt)); + } +} + +impl Walker for Implementation { + fn walk(&self, visitor: &mut V) + where + V: AstVisitor, + { + for n in &self.statements { + visitor.visit(n); + } + } +} diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_function_call.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_function_call.snap index 3436f9b653a..4574b771023 100644 --- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_function_call.snap +++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_function_call.snap @@ -5,7 +5,7 @@ expression: "results.join(\"\\n\")" ; ModuleID = 'main.st' source_filename = "main.st" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 store i16 0, i16* %main, align 2 @@ -14,9 +14,9 @@ entry: ret i16 %main_ret } -declare i16 @external() section "fn-external:i16" +declare i16 @external() section "fn-$RUSTY$external:i16" ; ModuleID = 'external.st' source_filename = "external.st" -declare i16 @external() section "fn-external:i16" +declare i16 @external() section "fn-$RUSTY$external:i16" diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_global_var.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_global_var.snap index 275c650b64f..cc8effcdc07 100644 --- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_global_var.snap +++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__external_files__external_file_global_var.snap @@ -5,10 +5,10 @@ expression: "results.join(\"\\n\")" ; ModuleID = 'main.st' source_filename = "main.st" -@x = external global i16 -@y = external global i16 +@x = external global i16, section "var-$RUSTY$x:i16" +@y = external global i16, section "var-$RUSTY$y:i16" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 store i16 0, i16* %main, align 2 @@ -19,12 +19,12 @@ entry: ret i16 %main_ret } -declare i16 @external() section "fn-external:i16" +declare i16 @external() section "fn-$RUSTY$external:i16" ; ModuleID = 'external.st' source_filename = "external.st" -@x = external global i16 -@y = external global i16 +@x = external global i16, section "var-$RUSTY$x:i16" +@y = external global i16, section "var-$RUSTY$y:i16" -declare i16 @external() section "fn-external:i16" +declare i16 @external() section "fn-$RUSTY$external:i16" diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap index d66f8c80d55..4deafcb8310 100644 --- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap +++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_in_different_locations_with_debug_info.snap @@ -7,9 +7,9 @@ source_filename = "app/file1.st" %mainProg = type {} -@mainProg_instance = external global %mainProg, !dbg !0 +@mainProg_instance = external global %mainProg, section "var-$RUSTY$mainProg_instance:r0", !dbg !0 -define i16 @main() section "fn-main:i16" !dbg !10 { +define i16 @main() section "fn-$RUSTY$main:i16" !dbg !10 { entry: %main = alloca i16, align 2, !dbg !14 call void @llvm.dbg.declare(metadata i16* %main, metadata !15, metadata !DIExpression()), !dbg !17 @@ -19,7 +19,7 @@ entry: ret i16 %main_ret, !dbg !14 } -declare !dbg !18 void @mainProg(%mainProg*) section "fn-mainProg:v" +declare !dbg !18 void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v" ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn declare void @llvm.dbg.declare(metadata, metadata, metadata) #0 @@ -54,9 +54,9 @@ source_filename = "lib/file2.st" %mainProg = type {} -@mainProg_instance = global %mainProg zeroinitializer, !dbg !0 +@mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r0", !dbg !0 -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" !dbg !10 { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" !dbg !10 { entry: call void @llvm.dbg.declare(metadata %mainProg* %0, metadata !13, metadata !DIExpression()), !dbg !14 ret void, !dbg !14 diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap index 10ea84d0cd1..a8623288bf2 100644 --- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap +++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_files_with_debug_info.snap @@ -7,9 +7,9 @@ source_filename = "file1.st" %mainProg = type {} -@mainProg_instance = external global %mainProg, !dbg !0 +@mainProg_instance = external global %mainProg, section "var-$RUSTY$mainProg_instance:r0", !dbg !0 -define i16 @main() section "fn-main:i16" !dbg !10 { +define i16 @main() section "fn-$RUSTY$main:i16" !dbg !10 { entry: %main = alloca i16, align 2, !dbg !14 call void @llvm.dbg.declare(metadata i16* %main, metadata !15, metadata !DIExpression()), !dbg !17 @@ -19,7 +19,7 @@ entry: ret i16 %main_ret, !dbg !14 } -declare !dbg !18 void @mainProg(%mainProg*) section "fn-mainProg:v" +declare !dbg !18 void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v" ; Function Attrs: nofree nosync nounwind readnone speculatable willreturn declare void @llvm.dbg.declare(metadata, metadata, metadata) #0 @@ -54,9 +54,9 @@ source_filename = "file2.st" %mainProg = type {} -@mainProg_instance = global %mainProg zeroinitializer, !dbg !0 +@mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r0", !dbg !0 -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" !dbg !10 { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" !dbg !10 { entry: call void @llvm.dbg.declare(metadata %mainProg* %0, metadata !13, metadata !DIExpression()), !dbg !14 ret void, !dbg !14 diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap index 9d922834778..e2f0569d084 100644 --- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap +++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__multi_files__multiple_source_files_generated.snap @@ -7,9 +7,9 @@ source_filename = "external_file1.st" %mainProg = type {} -@mainProg_instance = external global %mainProg +@mainProg_instance = external global %mainProg, section "var-$RUSTY$mainProg_instance:r0" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 store i16 0, i16* %main, align 2 @@ -18,16 +18,16 @@ entry: ret i16 %main_ret } -declare void @mainProg(%mainProg*) section "fn-mainProg:v" +declare void @mainProg(%mainProg*) section "fn-$RUSTY$mainProg:v" ; ModuleID = 'external_file2.st' source_filename = "external_file2.st" %mainProg = type {} -@mainProg_instance = global %mainProg zeroinitializer +@mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r0" -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" { entry: ret void } diff --git a/compiler/section_mangler/Cargo.toml b/compiler/section_mangler/Cargo.toml index f3386a21e01..f0cfaf92a4a 100644 --- a/compiler/section_mangler/Cargo.toml +++ b/compiler/section_mangler/Cargo.toml @@ -4,3 +4,4 @@ version = "0.0.1" edition = "2021" [dependencies] +nom = "7.1" diff --git a/compiler/section_mangler/src/lib.rs b/compiler/section_mangler/src/lib.rs index 4e00658c692..d7b6b565ce3 100644 --- a/compiler/section_mangler/src/lib.rs +++ b/compiler/section_mangler/src/lib.rs @@ -44,20 +44,25 @@ use std::fmt; +mod parser; + /// The main builder type of this crate. Use it to create mangling contexts, in /// order to encode and decode binary type information. // TODO: Add example code for using this builder +#[derive(Debug, PartialEq, Clone)] pub enum SectionMangler { Function(FunctionMangler), Variable(VariableMangler), } +#[derive(Debug, PartialEq, Clone)] pub struct FunctionMangler { name: String, parameters: Vec, return_type: Option, } +#[derive(Debug, PartialEq, Clone)] pub struct VariableMangler { name: String, ty: Type, @@ -72,6 +77,13 @@ impl SectionMangler { SectionMangler::Variable(VariableMangler { name: name.into(), ty }) } + pub fn name(&self) -> &str { + match self { + SectionMangler::Function(FunctionMangler { name, .. }) + | SectionMangler::Variable(VariableMangler { name, .. }) => name, + } + } + pub fn with_parameter(self, param: FunctionArgument) -> SectionMangler { match self { SectionMangler::Function(f) => { @@ -84,9 +96,11 @@ impl SectionMangler { } } - pub fn with_return_type(self, return_type: Option) -> SectionMangler { + pub fn with_return_type(self, return_type: Type) -> SectionMangler { match self { - SectionMangler::Function(f) => SectionMangler::Function(FunctionMangler { return_type, ..f }), + SectionMangler::Function(f) => { + SectionMangler::Function(FunctionMangler { return_type: Some(return_type), ..f }) + } SectionMangler::Variable(_) => unreachable!("global variables do not have a return type."), } } @@ -111,6 +125,7 @@ impl SectionMangler { // NOTE: This is called `variable_linkage` in the `MemberInfo` struct. /// We have to encode this because if it changes, the function needs to be reloaded - this is an ABI breakage +#[derive(Debug, PartialEq, Clone)] pub enum FunctionArgument { ByValue(Type), ByRef(Type), @@ -127,6 +142,7 @@ impl fmt::Display for FunctionArgument { } // TODO: Do we have to encode this? Does that affect ABI? Probably +#[derive(Debug, PartialEq, Clone)] pub enum StringEncoding { // TODO: Should we encode this differently? this could cause problems compared to encoding unsigned types /// Encoded as `8u` @@ -146,6 +162,7 @@ impl fmt::Display for StringEncoding { // This maps directly to the [`DataTypeInformation`] enum in RuSTy - we simply remove some fields and add the ability to encode/decode serialize/deserialize // TODO: Do we have to handle Generic? +#[derive(Debug, PartialEq, Clone)] pub enum Type { /// Encoded as `v` Void, @@ -158,7 +175,9 @@ pub enum Type { semantic_size: Option, }, /// Encoded as `f` - Float { size: u32 }, + Float { + size: u32, + }, /// Encoded as `s` String { size: usize, // FIXME: Is that okay? will all the constant expressions be folded at that point? Can we have TypeSize::Undetermined still? @@ -170,23 +189,12 @@ pub enum Type { // TODO: Is changing the `auto_deref` mode an ABI break? // auto_deref: bool, }, - - // --- UNIMPLEMENTED - - // FIXME: Do we need any info here? How are structs codegened? Struct { - // name: TypeId, - // members: Vec, - // source: StructSource, + members: Vec, }, - - // FIXME: Same here Enum { - // name: TypeId, - // referenced_type: TypeId, - // // TODO: Would it make sense to store `VariableIndexEntry`s similar to how the `Struct` variant does? - // // This would allow us to pattern match in the index `find_member` method - // elements: Vec, + referenced_type: Box, + elements: usize, }, Array { inner: Box, @@ -224,10 +232,17 @@ impl fmt::Display for Type { Type::Float { size } => write!(f, "f{size}"), Type::String { size, encoding } => write!(f, "s{encoding}{size}",), Type::Pointer { inner } => write!(f, "p{}", inner), + Type::Struct { members } => { + write!( + f, + "r{}{}", + members.len(), + members.iter().fold(String::new(), |acc, m| format!("{acc}{m}")) + ) + } + Type::Enum { referenced_type, elements } => write!(f, "e{elements}{referenced_type}"), + Type::Array { inner } => write!(f, "a{inner}"), // -- Unimplemented - Type::Struct {} => todo!(), - Type::Enum {} => todo!(), - Type::Array { .. } => todo!(), Type::SubRange {} => todo!(), Type::Alias {} => todo!(), Type::Generic {} => todo!(), @@ -235,6 +250,8 @@ impl fmt::Display for Type { } } +pub const PREFIX: &str = "$RUSTY$"; + // TODO: How to encode variadics? fn mangle_function(FunctionMangler { name, parameters, return_type }: FunctionMangler) -> String { let mangled = parameters @@ -242,9 +259,9 @@ fn mangle_function(FunctionMangler { name, parameters, return_type }: FunctionMa /* FIXME: Is that correct? */ .fold(return_type.unwrap_or(Type::Void).to_string(), |mangled, arg| format!("{mangled}[{arg}]")); - format!("{name}:{mangled}") + format!("{PREFIX}{name}:{mangled}") } fn mangle_variable(VariableMangler { name, ty }: VariableMangler) -> String { - format!("{name}:{ty}") + format!("{PREFIX}{name}:{ty}") } diff --git a/compiler/section_mangler/src/parser.rs b/compiler/section_mangler/src/parser.rs new file mode 100644 index 00000000000..74f3e5baa21 --- /dev/null +++ b/compiler/section_mangler/src/parser.rs @@ -0,0 +1,231 @@ +use crate::{FunctionArgument, SectionMangler, Type}; + +use std::str; + +use nom::branch::alt; +use nom::bytes::complete::{tag, take_until1}; +use nom::character::complete::{char, digit1}; +use nom::combinator::map_res; +use nom::multi::{many0, many_m_n}; +use nom::sequence::delimited; +use nom::{IResult, Parser}; + +type ParseResult<'i, O> = IResult<&'i str, O>; + +enum Prefix { + Fn, + Var, +} + +fn parse_prefix(input: &str) -> ParseResult { + let fn_prefix = tag("fn").map(|_| Prefix::Fn); + let var_prefix = tag("var").map(|_| Prefix::Var); + + let (input, _) = tag(crate::PREFIX)(input)?; + let (input, prefix) = alt((fn_prefix, var_prefix))(input)?; + + Ok((input, prefix)) +} + +fn parse_entity_name(input: &str) -> ParseResult<&str> { + delimited(char('-'), take_until1(":"), char(':'))(input) +} + +fn type_void(input: &str) -> ParseResult { + char('v').map(|_| Type::Void).parse(input) +} + +fn number(input: &str) -> ParseResult { + map_res(digit1, str::parse)(input) +} + +fn type_integer(input: &str) -> ParseResult { + fn parse_signedness(input: &str) -> ParseResult { + let signed = char('i').map(|_| true); + let unsigned = char('u').map(|_| false); + + alt((signed, unsigned))(input) + } + + parse_signedness + .and(number::) + .map(|(signed, size)| Type::Integer { signed, size, semantic_size: None }) + .parse(input) +} + +fn type_float(input: &str) -> ParseResult { + char('f').and(number::).map(|(_, size)| Type::Float { size }).parse(input) +} + +fn type_pointer(input: &str) -> ParseResult { + char('p').and(parse_type).map(|(_, inner)| Type::Pointer { inner: Box::new(inner) }).parse(input) +} + +fn type_struct(input: &str) -> ParseResult { + let (input, (_, n)) = char('r').and(number::).parse(input)?; + + many_m_n(n, n, parse_type).map(|members| Type::Struct { members }).parse(input) +} + +fn type_enum(input: &str) -> ParseResult { + char('e') + .and(number::) + .and(parse_type) + .map(|((_, elements), ty)| Type::Enum { referenced_type: Box::new(ty), elements }) + .parse(input) +} + +fn parse_type(input: &str) -> ParseResult { + alt((type_void, type_integer, type_float, type_pointer, type_struct, type_enum))(input) +} + +fn parse_var_content<'i>(input: &'i str, name: &str) -> ParseResult<'i, SectionMangler> { + let (input, ty) = parse_type(input)?; + + Ok((input, SectionMangler::variable(name, ty))) +} + +fn parse_fn_content<'i>(input: &'i str, name: &str) -> ParseResult<'i, SectionMangler> { + let (input, return_type) = parse_type(input)?; + let (input, parameters) = delimited(char('['), many0(parse_type), char(']'))(input)?; + + // TODO: Do not always encode parameters as ByValue + let mangler = parameters + .into_iter() + .fold(SectionMangler::function(name).with_return_type(return_type), |mangler, param| { + mangler.with_parameter(FunctionArgument::ByValue(param)) + }); + + // TODO: Would it be better for the function to encode the number of arguments it has? + // or just parse what is in between `[]` like we do currently? + + Ok((input, mangler)) +} + +// We don't need to handle any kind of errors, because an invalid mangled string can only be +// caused by a programming error or a mismatch in versions +impl From<&str> for SectionMangler { + fn from(input: &str) -> SectionMangler { + let (input, prefix) = parse_prefix(input).unwrap(); + let (input, name) = parse_entity_name(input).unwrap(); + + match prefix { + Prefix::Var => parse_var_content(input, name).unwrap().1, + Prefix::Fn => parse_fn_content(input, name).unwrap().1, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn parse_prefix_valid() { + assert!(parse_prefix("$RUSTY$fn").is_ok()); + assert!(parse_prefix("$RUSTY$var").is_ok()); + + assert!(parse_prefix("$RUSTY$random").is_err()); + assert!(parse_prefix("fn").is_err()); + assert!(parse_prefix("var").is_err()); + + assert!(parse_prefix("").is_err()); + assert!(parse_prefix("a random prefix").is_err()); + } + + #[test] + fn parse_name_valid() { + assert_eq!(parse_entity_name("-foo:").unwrap().1, "foo"); + + // empty name + assert!(parse_entity_name("-:").is_err()); + } + + #[test] + fn parse_integer() { + assert!(type_integer("i15").is_ok()); + assert!(type_integer("u49").is_ok()); + assert!(type_integer("i0").is_ok()); + + assert!(type_integer("i").is_err()); + assert!(type_integer("b49").is_err()); + } + + #[test] + fn parse_void() { + assert!(type_void("v").is_ok()); + + assert!(type_void("i15").is_err()); + } + + #[test] + fn parse_float() { + assert!(type_float("f15").is_ok()); + assert!(type_float("f2560").is_ok()); + + assert!(type_float("f").is_err()); + assert!(type_float("i0").is_err()); + } + + #[test] + fn parse_ptr() { + assert!(type_pointer("pf15").is_ok()); + assert!(type_pointer("pv").is_ok()); + assert!(type_pointer("pi45").is_ok()); + assert!(type_pointer("pppppppi45").is_ok()); + + assert!(type_pointer("p").is_err()); + assert!(type_pointer("i0").is_err()); + } + + #[test] + fn parse_struct() { + assert!(type_struct("r1u8").is_ok()); + assert!(type_struct("r1r2u8u49").is_ok()); + assert!(type_struct("r5pu8r1u8u32u32pv").is_ok()); + + // these are fine - we parse a struct which is valid, but we have remaining input. + // this needs to be handled by the toplevel parse function + assert!(type_struct("r0u8u8").is_ok()); + assert!(type_struct("r1u8u8").is_ok()); + + // invalid number of elements + assert!(type_struct("r15u8").is_err()); + assert!(type_struct("r1").is_err()); + assert!(type_struct("r2r1u8").is_err()); + } + + #[test] + fn parse_enum() { + assert!(type_enum("e15u8").is_ok()); + assert!(type_enum("e12pv").is_ok()); + + assert!(type_enum("e1").is_err()); + assert!(type_enum("eu8").is_err()); + } + + #[test] + fn parse_variable() { + let _ = SectionMangler::from("$RUSTY$var-name:u8"); + } + + #[test] + fn parse_function() { + let _ = SectionMangler::from("$RUSTY$fn-foo:u8[]"); + let _ = SectionMangler::from("$RUSTY$fn-foo:v[]"); + let _ = SectionMangler::from("$RUSTY$fn-foo:v[pvu8]"); + let _ = SectionMangler::from("$RUSTY$fn-foo:e156u394[pvu8r1e12u8]"); + } + + #[test] + #[should_panic] + fn parse_function_invalid_no_return_type() { + let _ = SectionMangler::from("$RUSTY$fn-no_return_type:[]"); + } + + #[test] + #[should_panic] + fn parse_function_invalid_no_arguments() { + let _ = SectionMangler::from("$RUSTY$fn-no_arguments:u16u8"); + } +} diff --git a/src/builtins.rs b/src/builtins.rs index 4deca18bb17..de6de63e59e 100644 --- a/src/builtins.rs +++ b/src/builtins.rs @@ -846,20 +846,6 @@ fn generate_variable_length_array_bound_function<'ink>( let offset = if is_lower { (value - 1) as u64 * 2 } else { (value - 1) as u64 * 2 + 1 }; llvm.i32_type().const_int(offset, false) } - AstStatement::CastStatement(data) => { - let ExpressionValue::RValue(value) = generator.generate_expression_value(&data.target)? else { - unreachable!() - }; - - if !value.is_int_value() { - return Err(Diagnostic::codegen_error( - format!("Expected INT value, found {}", value.get_type()), - location, - )); - }; - - value.into_int_value() - } // e.g. LOWER_BOUND(arr, idx + 3) _ => { let expression_value = generator.generate_expression(params[1])?; diff --git a/src/codegen/generators/expression_generator.rs b/src/codegen/generators/expression_generator.rs index 404526afd6e..5db678157f7 100644 --- a/src/codegen/generators/expression_generator.rs +++ b/src/codegen/generators/expression_generator.rs @@ -1751,7 +1751,6 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> { } // if there is just one assignment, this may be an struct-initialization (TODO this is not very elegant :-/ ) AstStatement::Assignment { .. } => self.generate_literal_struct(literal_statement), - AstStatement::CastStatement(data) => self.generate_expression_value(&data.target), _ => Err(cannot_generate_literal()), } } diff --git a/src/codegen/generators/pou_generator.rs b/src/codegen/generators/pou_generator.rs index e23af09f0e6..a9c2d01caff 100644 --- a/src/codegen/generators/pou_generator.rs +++ b/src/codegen/generators/pou_generator.rs @@ -153,17 +153,16 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { PouGenerator { llvm, index, annotations, llvm_index } } - fn mangle_function(&self, implementation: &ImplementationIndexEntry) -> String { + fn mangle_function(&self, implementation: &ImplementationIndexEntry) -> Result { let ctx = SectionMangler::function(implementation.get_call_name()); let params = self.index.get_declared_parameters(implementation.get_call_name()); - let ctx = params.into_iter().fold(ctx, |ctx, param| { - // FIXME: Can we unwrap here? + let ctx = params.into_iter().try_fold(ctx, |ctx, param| -> Result { let ty = section_names::mangle_type( self.index, - self.index.get_effective_type_by_name(¶m.data_type_name).unwrap(), - ); + self.index.get_effective_type_by_name(¶m.data_type_name)?, + )?; let parameter = match param.argument_type { // TODO: We need to handle the `VariableType` enum as well - this describes the mode of // argument passing, e.g. inout @@ -171,15 +170,20 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { index::ArgumentType::ByRef(_) => FunctionArgument::ByRef(ty), }; - ctx.with_parameter(parameter) - }); + Ok(ctx.with_parameter(parameter)) + })?; let return_ty = self .index .find_return_type(implementation.get_type_name()) .map(|ty| section_names::mangle_type(self.index, ty)); - ctx.with_return_type(return_ty).mangle() + let ctx = match return_ty { + Some(rty) => ctx.with_return_type(rty?), + None => ctx, + }; + + Ok(ctx.mangle()) } /// generates an empty llvm function for the given implementation, including all parameters and the return type @@ -281,7 +285,7 @@ impl<'ink, 'cg> PouGenerator<'ink, 'cg> { let curr_f = module.add_function(implementation.get_call_name(), function_declaration, None); - let section_name = self.mangle_function(implementation); + let section_name = self.mangle_function(implementation)?; curr_f.set_section(Some(§ion_name)); let pou_name = implementation.get_call_name(); diff --git a/src/codegen/generators/section_names.rs b/src/codegen/generators/section_names.rs index a6a03c83802..15e4b480643 100644 --- a/src/codegen/generators/section_names.rs +++ b/src/codegen/generators/section_names.rs @@ -1,14 +1,17 @@ use crate::index::Index; use crate::typesystem::{self, DataTypeInformation, StringEncoding, TypeSize}; +use plc_diagnostics::diagnostics::Diagnostic; use section_mangler::{StringEncoding as SectionStringEncoding, Type}; -pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> section_mangler::Type { +pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> Result { + let access_inner = |ty_name| mangle_type(index, index.get_effective_type_by_name(ty_name)?); + // TODO: This is a bit ugly because we keep dereferencing references to Copy types like // bool, u32, etc, because `DataTypeInformation::Pointer` keeps a `String` which is not // Copy. the alternative is for section_mangle::Type to keep references everywhere, and // have a lifetime generic parameter, e.g. `section_mangler::Type<'a>` - which is also // annoying. - match ty.get_type_information() { + let mangled = match ty.get_type_information() { DataTypeInformation::Void => Type::Void, DataTypeInformation::Integer { signed, size, semantic_size, .. } => { Type::Integer { signed: *signed, size: *size, semantic_size: *semantic_size } @@ -22,12 +25,40 @@ pub fn mangle_type(index: &Index, ty: &typesystem::DataType) -> section_mangler: Type::String { size: *size as usize, encoding } } - DataTypeInformation::Pointer { inner_type_name, .. } => Type::Pointer { - inner: Box::new(mangle_type(index, index.get_effective_type_by_name(inner_type_name).unwrap())), + DataTypeInformation::Pointer { inner_type_name, .. } => { + Type::Pointer { inner: Box::new(access_inner(inner_type_name)?) } + } + DataTypeInformation::Enum { referenced_type, variants, .. } => { + Type::Enum { referenced_type: Box::new(access_inner(referenced_type)?), elements: variants.len() } + } + DataTypeInformation::Struct { members, .. } => Type::Struct { + members: members.iter().try_fold(Vec::new(), |mut acc, m| -> Result, Diagnostic> { + let inner = access_inner(m.get_type_name())?; + + acc.push(inner); + + Ok(acc) + })?, }, - // FIXME: For now, encode all unknown types as "void" since this is not required for + DataTypeInformation::Array { inner_type_name, .. } => { + Type::Array { inner: Box::new(access_inner(inner_type_name)?) } + } + // FIXME: Is that correct? + // For code generation, the actual range does not matter - it is not a breaking change + // if a variable's range changes, at least not for codegen, since the underlying type will stay + // the same. Therefore, only encode it as its underlying type. + DataTypeInformation::SubRange { referenced_type, .. } + // Similarly, we do not care about the alias - only the type which is being codegen'd + | DataTypeInformation::Alias { referenced_type, .. } => access_inner(referenced_type)?, + DataTypeInformation::Generic { .. } => { + // FIXME: Is that correct? + unreachable!("generic types should not exist at codegen") + } + // FIXME: For now, encode all unknown types as "void" since this is not required for // execution. Not doing so (and doing an `unreachable!()` for example) obviously causes // failures, because complex types are already implemented in the compiler. _ => Type::Void, - } + }; + + Ok(mangled) } diff --git a/src/codegen/generators/variable_generator.rs b/src/codegen/generators/variable_generator.rs index 55a8194b056..08b99db2fb4 100644 --- a/src/codegen/generators/variable_generator.rs +++ b/src/codegen/generators/variable_generator.rs @@ -15,6 +15,7 @@ use super::{ data_type_generator::get_default_for, expression_generator::ExpressionCodeGenerator, llvm::{GlobalValueExt, Llvm}, + section_names, }; use crate::codegen::debug::DebugBuilderEnum; use crate::index::FxIndexSet; @@ -170,6 +171,17 @@ impl<'ctx, 'b> VariableGenerator<'ctx, 'b> { } } + let section = section_mangler::SectionMangler::variable( + global_variable.get_name(), + section_names::mangle_type( + self.global_index, + self.global_index.get_effective_type_by_name(global_variable.get_type_name())?, + )?, + ) + .mangle(); + + global_ir_variable.set_section(Some(§ion)); + Ok(global_ir_variable) } } diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__aggregate_return_value_variable_in_function.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__aggregate_return_value_variable_in_function.snap index 81635ebc497..3ce6a9f94b4 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__aggregate_return_value_variable_in_function.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__aggregate_return_value_variable_in_function.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" -define void @myFunc([81 x i8]* %0) section "fn-myFunc:s8u81" !dbg !4 { +define void @myFunc([81 x i8]* %0) section "fn-$RUSTY$myFunc:s8u81" !dbg !4 { entry: %myFunc = alloca [81 x i8]*, align 8, !dbg !8 store [81 x i8]* %0, [81 x i8]** %myFunc, align 8, !dbg !8 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__array_size_correctly_set_in_dwarf_info.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__array_size_correctly_set_in_dwarf_info.snap index ebcd7d42a67..1c24e9fc491 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__array_size_correctly_set_in_dwarf_info.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__array_size_correctly_set_in_dwarf_info.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @foo() section "fn-foo:i32" !dbg !4 { +define i32 @foo() section "fn-$RUSTY$foo:i32" !dbg !4 { entry: %foo = alloca i32, align 4, !dbg !8 %a = alloca [64 x i32], align 4, !dbg !8 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__assignment_statement_have_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__assignment_statement_have_location.snap index ca675c06467..31e1606764c 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__assignment_statement_have_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__assignment_statement_have_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__case_conditions_location_marked.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__case_conditions_location_marked.snap index 3714952f229..eaba11dbb2f 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__case_conditions_location_marked.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__case_conditions_location_marked.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__exit_statement_have_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__exit_statement_have_location.snap index 53c07e43d14..77f390e60e0 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__exit_statement_have_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__exit_statement_have_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap index fe0182cfa99..4cc815874e5 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__external_impl_is_not_added_as_external_subroutine.snap @@ -8,14 +8,14 @@ source_filename = "main" %myPrg = type {} %myFb = type {} -@myPrg_instance = external global %myPrg, !dbg !0 -@__myFb__init = unnamed_addr constant %myFb zeroinitializer, !dbg !5 +@myPrg_instance = external global %myPrg, section "var-$RUSTY$myPrg_instance:r0", !dbg !0 +@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-$RUSTY$__myFb__init:r0", !dbg !5 -declare i32 @myFunc() section "fn-myFunc:i32" +declare i32 @myFunc() section "fn-$RUSTY$myFunc:i32" -declare void @myPrg(%myPrg*) section "fn-myPrg:v" +declare void @myPrg(%myPrg*) section "fn-$RUSTY$myPrg:v" -declare void @myFb(%myFb*) section "fn-myFb:v" +declare void @myFb(%myFb*) section "fn-$RUSTY$myFb:v" !llvm.module.flags = !{!8, !9} !llvm.dbg.cu = !{!10} diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__for_conditions_location_marked.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__for_conditions_location_marked.snap index 25ab7b4faf0..113f95b2ce8 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__for_conditions_location_marked.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__for_conditions_location_marked.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_have_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_have_location.snap index 63a0d1ca3e6..3ca5c86ad44 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_have_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_have_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_in_expressions_have_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_in_expressions_have_location.snap index 44e6a5e1d9a..ecd3a71e1dd 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_in_expressions_have_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__function_calls_in_expressions_have_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__if_conditions_location_marked.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__if_conditions_location_marked.snap index 659d180e98a..a9cd134c7dd 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__if_conditions_location_marked.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__if_conditions_location_marked.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap index e5933b7ee3f..4031d2368c0 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__implementation_added_as_subroutine.snap @@ -8,10 +8,10 @@ source_filename = "main" %myPrg = type {} %myFb = type {} -@myPrg_instance = global %myPrg zeroinitializer, !dbg !0 -@__myFb__init = unnamed_addr constant %myFb zeroinitializer, !dbg !5 +@myPrg_instance = global %myPrg zeroinitializer, section "var-$RUSTY$myPrg_instance:r0", !dbg !0 +@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-$RUSTY$__myFb__init:r0", !dbg !5 -define i32 @myFunc() section "fn-myFunc:i32" !dbg !12 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !12 { entry: %myFunc = alloca i32, align 4, !dbg !15 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !16, metadata !DIExpression()), !dbg !18 @@ -20,13 +20,13 @@ entry: ret i32 %myFunc_ret, !dbg !15 } -define void @myPrg(%myPrg* %0) section "fn-myPrg:v" !dbg !19 { +define void @myPrg(%myPrg* %0) section "fn-$RUSTY$myPrg:v" !dbg !19 { entry: call void @llvm.dbg.declare(metadata %myPrg* %0, metadata !20, metadata !DIExpression()), !dbg !21 ret void, !dbg !21 } -define void @myFb(%myFb* %0) section "fn-myFb:v" !dbg !22 { +define void @myFb(%myFb* %0) section "fn-$RUSTY$myFb:v" !dbg !22 { entry: call void @llvm.dbg.declare(metadata %myFb* %0, metadata !23, metadata !DIExpression()), !dbg !24 ret void, !dbg !24 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__nested_function_calls_get_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__nested_function_calls_get_location.snap index 96f7356258a..acecf314cd4 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__nested_function_calls_get_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__nested_function_calls_get_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc(i32 %0) section "fn-myFunc:i32[i32]" !dbg !4 { +define i32 @myFunc(i32 %0) section "fn-$RUSTY$myFunc:i32[i32]" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !9 %x = alloca i32, align 4, !dbg !9 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_callable_expressions_have_no_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_callable_expressions_have_no_location.snap index f43862598fa..7c33e7e21b8 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_callable_expressions_have_no_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_callable_expressions_have_no_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap index 99bd0a7cf7b..d1f406fd7bc 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__non_function_pous_have_struct_as_param.snap @@ -8,10 +8,10 @@ source_filename = "main" %myProg = type { i32 } %fb = type { i32 } -@myProg_instance = global %myProg zeroinitializer, !dbg !0 -@__fb__init = unnamed_addr constant %fb zeroinitializer, !dbg !7 +@myProg_instance = global %myProg zeroinitializer, section "var-$RUSTY$myProg_instance:r1i32", !dbg !0 +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r1i32", !dbg !7 -define void @myProg(%myProg* %0) section "fn-myProg:v[i32]" !dbg !16 { +define void @myProg(%myProg* %0) section "fn-$RUSTY$myProg:v[i32]" !dbg !16 { entry: call void @llvm.dbg.declare(metadata %myProg* %0, metadata !20, metadata !DIExpression()), !dbg !21 %x = getelementptr inbounds %myProg, %myProg* %0, i32 0, i32 0, !dbg !21 @@ -21,7 +21,7 @@ entry: ret void, !dbg !21 } -define void @fb(%fb* %0) section "fn-fb:v[i32]" !dbg !22 { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v[i32]" !dbg !22 { entry: call void @llvm.dbg.declare(metadata %fb* %0, metadata !23, metadata !DIExpression()), !dbg !24 %x = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0, !dbg !24 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__repeat_conditions_location_marked.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__repeat_conditions_location_marked.snap index c3f649b11a1..bd34efaee8e 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__repeat_conditions_location_marked.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__repeat_conditions_location_marked.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__return_statement_have_location.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__return_statement_have_location.snap index 5c789271297..d8bd529d703 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__return_statement_have_location.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__return_statement_have_location.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__string_size_correctly_set_in_dwarf_info.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__string_size_correctly_set_in_dwarf_info.snap index fd039416b45..f7bc5dbd465 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__string_size_correctly_set_in_dwarf_info.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__string_size_correctly_set_in_dwarf_info.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@a = global [65 x i8] zeroinitializer, !dbg !0 +@a = global [65 x i8] zeroinitializer, section "var-$RUSTY$a:s8u65", !dbg !0 !llvm.module.flags = !{!7, !8} !llvm.dbg.cu = !{!9} diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap index 09aeddba2fd..41c3cd88b7d 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_and_vartemp_variables_in_pous_added_as_local.snap @@ -8,10 +8,10 @@ source_filename = "main" %myPrg = type {} %myFb = type {} -@myPrg_instance = global %myPrg zeroinitializer, !dbg !0 -@__myFb__init = unnamed_addr constant %myFb zeroinitializer, !dbg !9 +@myPrg_instance = global %myPrg zeroinitializer, section "var-$RUSTY$myPrg_instance:r3i32i32i32", !dbg !0 +@__myFb__init = unnamed_addr constant %myFb zeroinitializer, section "var-$RUSTY$__myFb__init:r3i32i32i32", !dbg !9 -define i32 @myFunc() section "fn-myFunc:i32" !dbg !20 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !20 { entry: %myFunc = alloca i32, align 4, !dbg !24 %a = alloca i32, align 4, !dbg !24 @@ -29,7 +29,7 @@ entry: ret i32 %myFunc_ret, !dbg !24 } -define void @myPrg(%myPrg* %0) section "fn-myPrg:v" !dbg !33 { +define void @myPrg(%myPrg* %0) section "fn-$RUSTY$myPrg:v" !dbg !33 { entry: call void @llvm.dbg.declare(metadata %myPrg* %0, metadata !34, metadata !DIExpression()), !dbg !35 %a = alloca i32, align 4, !dbg !35 @@ -44,7 +44,7 @@ entry: ret void, !dbg !35 } -define void @myFb(%myFb* %0) section "fn-myFb:v" !dbg !42 { +define void @myFb(%myFb* %0) section "fn-$RUSTY$myFb:v" !dbg !42 { entry: call void @llvm.dbg.declare(metadata %myFb* %0, metadata !43, metadata !DIExpression()), !dbg !44 %a = alloca i32, align 4, !dbg !44 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_in_out_inout_in_function_added_as_params.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_in_out_inout_in_function_added_as_params.snap index 497bfb673f4..ae19840b1fd 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_in_out_inout_in_function_added_as_params.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__var_in_out_inout_in_function_added_as_params.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc(i16* %0) section "fn-myFunc:i32[pi16]" !dbg !4 { +define i32 @myFunc(i16* %0) section "fn-$RUSTY$myFunc:i32[pi16]" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !10 %x = alloca i16*, align 8, !dbg !10 diff --git a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__while_conditions_location_marked.snap b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__while_conditions_location_marked.snap index eacacdaa227..be5cce04c5a 100644 --- a/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__while_conditions_location_marked.snap +++ b/src/codegen/tests/debug_tests/snapshots/rusty__codegen__tests__debug_tests__expression_debugging__while_conditions_location_marked.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @myFunc() section "fn-myFunc:i32" !dbg !4 { +define i32 @myFunc() section "fn-$RUSTY$myFunc:i32" !dbg !4 { entry: %myFunc = alloca i32, align 4, !dbg !8 call void @llvm.dbg.declare(metadata i32* %myFunc, metadata !9, metadata !DIExpression()), !dbg !11 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap index 157bfcca59b..3b4650feec0 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_declared_initializer.snap @@ -7,9 +7,9 @@ source_filename = "main" %commands = type { i8, i8 } -@__commands__init = unnamed_addr constant %commands { i8 1, i8 0 } +@__commands__init = unnamed_addr constant %commands { i8 1, i8 0 }, section "var-$RUSTY$__commands__init:r2u8u8" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %cmd1 = alloca %commands, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_default_initializer.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_default_initializer.snap index 66373e62305..2eea070ead1 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_default_initializer.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__global_constant_without_initializer_gets_default_initializer.snap @@ -7,10 +7,10 @@ source_filename = "main" %commands = type { i8, i8 } -@__commands__init = unnamed_addr constant %commands zeroinitializer +@__commands__init = unnamed_addr constant %commands zeroinitializer, section "var-$RUSTY$__commands__init:r2u8u8" @__main.myStr1__init = unnamed_addr constant [81 x i8] zeroinitializer -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %cmd1 = alloca %commands, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_constant_variables.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_constant_variables.snap index 67066f351dd..5394c610e3a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_constant_variables.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_constant_variables.snap @@ -1,28 +1,25 @@ --- source: src/codegen/tests/initialization_test/global_initializers.rs -assertion_line: 38 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@c_INT = unnamed_addr constant i16 7 -@c_3c = unnamed_addr constant i16 21 -@c_BOOL = unnamed_addr constant i8 1 -@c_not = unnamed_addr constant i8 0 -@c_str = unnamed_addr constant [11 x i8] c"Hello\00\00\00\00\00\00" -@c_wstr = unnamed_addr constant [11 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0] -@c_real = unnamed_addr constant float 0x40091EB860000000 -@c_lreal = unnamed_addr constant double 3.141500e+00 -@x = unnamed_addr constant i16 7 -@y = unnamed_addr constant i16 14 -@z = unnamed_addr constant i16 32 -@b = unnamed_addr constant i8 1 -@nb = unnamed_addr constant i8 0 -@bb = unnamed_addr constant i8 0 -@str = unnamed_addr constant [11 x i8] c"Hello\00\00\00\00\00\00" -@wstr = unnamed_addr constant [11 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0] -@r = unnamed_addr constant float 0x3FF91EB860000000 -@tau = unnamed_addr constant double 6.283000e+00 - +@c_INT = unnamed_addr constant i16 7, section "var-$RUSTY$c_INT:i16" +@c_3c = unnamed_addr constant i16 21, section "var-$RUSTY$c_3c:i16" +@c_BOOL = unnamed_addr constant i8 1, section "var-$RUSTY$c_BOOL:u8" +@c_not = unnamed_addr constant i8 0, section "var-$RUSTY$c_not:u8" +@c_str = unnamed_addr constant [11 x i8] c"Hello\00\00\00\00\00\00", section "var-$RUSTY$c_str:s8u11" +@c_wstr = unnamed_addr constant [11 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0], section "var-$RUSTY$c_wstr:s16u11" +@c_real = unnamed_addr constant float 0x40091EB860000000, section "var-$RUSTY$c_real:f32" +@c_lreal = unnamed_addr constant double 3.141500e+00, section "var-$RUSTY$c_lreal:f64" +@x = unnamed_addr constant i16 7, section "var-$RUSTY$x:i16" +@y = unnamed_addr constant i16 14, section "var-$RUSTY$y:i16" +@z = unnamed_addr constant i16 32, section "var-$RUSTY$z:i16" +@b = unnamed_addr constant i8 1, section "var-$RUSTY$b:u8" +@nb = unnamed_addr constant i8 0, section "var-$RUSTY$nb:u8" +@bb = unnamed_addr constant i8 0, section "var-$RUSTY$bb:u8" +@str = unnamed_addr constant [11 x i8] c"Hello\00\00\00\00\00\00", section "var-$RUSTY$str:s8u11" +@wstr = unnamed_addr constant [11 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0], section "var-$RUSTY$wstr:s16u11" +@r = unnamed_addr constant float 0x3FF91EB860000000, section "var-$RUSTY$r:f32" +@tau = unnamed_addr constant double 6.283000e+00, section "var-$RUSTY$tau:f64" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables.snap index 8316de11dc2..2dde3124cb6 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables.snap @@ -1,13 +1,10 @@ --- source: src/codegen/tests/initialization_test/global_initializers.rs -assertion_line: 53 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@x = global i16 7 -@y = global i8 1 -@z = global float 0x400921CAC0000000 - +@x = global i16 7, section "var-$RUSTY$x:i16" +@y = global i8 1, section "var-$RUSTY$y:u8" +@z = global float 0x400921CAC0000000, section "var-$RUSTY$z:f32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap index 6cd804ef790..72ff91eb83a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__initial_values_in_global_variables_out_of_order.snap @@ -8,17 +8,17 @@ source_filename = "main" %MyFB = type { i16 } %prg = type { %MyFB } -@x = global %MyFB { i16 77 } -@__MyFB__init = unnamed_addr constant %MyFB { i16 77 } -@prg_instance = global %prg { %MyFB { i16 77 } } +@x = global %MyFB { i16 77 }, section "var-$RUSTY$x:r1i16" +@__MyFB__init = unnamed_addr constant %MyFB { i16 77 }, section "var-$RUSTY$__MyFB__init:r1i16" +@prg_instance = global %prg { %MyFB { i16 77 } }, section "var-$RUSTY$prg_instance:r1r1i16" -define void @MyFB(%MyFB* %0) section "fn-MyFB:v" { +define void @MyFB(%MyFB* %0) section "fn-$RUSTY$MyFB:v" { entry: %x = getelementptr inbounds %MyFB, %MyFB* %0, i32 0, i32 0 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap index 3936b3ed8de..9808139ec98 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__global_initializers__uninitialized_global_array.snap @@ -1,10 +1,8 @@ --- source: src/codegen/tests/initialization_test/global_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@a = global [2 x i8] zeroinitializer - +@a = global [2 x i8] zeroinitializer, section "var-$RUSTY$a:au8" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap index f18e7a7f9fa..064fe30b88e 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__class_struct_initialized_in_function.snap @@ -8,16 +8,16 @@ source_filename = "main" %fb = type { i16 } %main = type { %fb } -@__fb__init = unnamed_addr constant %fb { i16 9 } -@main_instance = global %main { %fb { i16 9 } } +@__fb__init = unnamed_addr constant %fb { i16 9 }, section "var-$RUSTY$__fb__init:r1i16" +@main_instance = global %main { %fb { i16 9 } }, section "var-$RUSTY$main_instance:r1r1i16" -define void @fb(%fb* %0) section "fn-fb:v" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v" { entry: %a = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0 ret void } -define i32 @func(%fb* %0) section "fn-func:i32[v]" { +define i32 @func(%fb* %0) section "fn-$RUSTY$func:i32[r1i16]" { entry: %func = alloca i32, align 4 %in = alloca %fb, align 8 @@ -32,7 +32,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %fb0 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %call = call i32 @func(%fb* %fb0) diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__default_values_for_not_initialized_function_vars.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__default_values_for_not_initialized_function_vars.snap index 7a250516934..049192b1e93 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__default_values_for_not_initialized_function_vars.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__default_values_for_not_initialized_function_vars.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @func() section "fn-func:i16" { +define i16 @func() section "fn-$RUSTY$func:i16" { entry: %func = alloca i16, align 2 %int_var = alloca i16, align 2 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap index 4814d385abc..e9c5abaf628 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__enum_variants_have_precedence_over_global_variables_in_inline_assignment.snap @@ -5,13 +5,13 @@ expression: function ; ModuleID = 'main' source_filename = "main" -@x = global i32 10 -@__foo_position.x = unnamed_addr constant i32 1 -@__bar_position.x = unnamed_addr constant i32 3 -@__foo_position.y = unnamed_addr constant i32 2 -@__bar_position.y = unnamed_addr constant i32 4 +@x = global i32 10, section "var-$RUSTY$x:i32" +@__foo_position.x = unnamed_addr constant i32 1, section "var-$RUSTY$x:e2i32" +@__bar_position.x = unnamed_addr constant i32 3, section "var-$RUSTY$x:e2i32" +@__foo_position.y = unnamed_addr constant i32 2, section "var-$RUSTY$y:e2i32" +@__bar_position.y = unnamed_addr constant i32 4, section "var-$RUSTY$y:e2i32" -define i32 @foo() section "fn-foo:i32" { +define i32 @foo() section "fn-$RUSTY$foo:i32" { entry: %foo = alloca i32, align 4 %position = alloca i32, align 4 @@ -21,7 +21,7 @@ entry: ret i32 %foo_ret } -define i32 @bar() section "fn-bar:i32" { +define i32 @bar() section "fn-$RUSTY$bar:i32" { entry: %bar = alloca i32, align 4 %position = alloca i32, align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap index f4b32717b29..11945294438 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_block_struct_initialized_in_function.snap @@ -8,15 +8,15 @@ source_filename = "main" %fb = type {} %main = type { %fb } -@__fb__init = unnamed_addr constant %fb zeroinitializer -@main_instance = global %main zeroinitializer +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r0" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1r0" -define void @fb(%fb* %0) section "fn-fb:v" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v" { entry: ret void } -define i32 @func(%fb* %0) section "fn-func:i32[v]" { +define i32 @func(%fb* %0) section "fn-$RUSTY$func:i32[r0]" { entry: %func = alloca i32, align 4 %in = alloca %fb, align 8 @@ -31,7 +31,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %fb0 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %call = call i32 @func(%fb* %fb0) diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap index 8c46762849e..e51987ffe3b 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized.snap @@ -7,9 +7,9 @@ source_filename = "main" %MyStruct = type { i32, i16 } -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r2i32i16" -define i16 @foo_int() section "fn-foo_int:i16" { +define i16 @foo_int() section "fn-$RUSTY$foo_int:i16" { entry: %foo_int = alloca i16, align 2 store i16 0, i16* %foo_int, align 2 @@ -17,7 +17,7 @@ entry: ret i16 %foo_int_ret } -define void @foo_str([11 x i8]* %0) section "fn-foo_str:s8u11" { +define void @foo_str([11 x i8]* %0) section "fn-$RUSTY$foo_str:s8u11" { entry: %foo_str = alloca [11 x i8]*, align 8 store [11 x i8]* %0, [11 x i8]** %foo_str, align 8 @@ -27,7 +27,7 @@ entry: ret void } -define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" { +define void @foo_arr([10 x float]* %0) section "fn-$RUSTY$foo_arr:af32" { entry: %foo_arr = alloca [10 x float]*, align 8 store [10 x float]* %0, [10 x float]** %foo_arr, align 8 @@ -37,7 +37,7 @@ entry: ret void } -define void @foo_struct(%MyStruct* %0) section "fn-foo_struct:v" { +define void @foo_struct(%MyStruct* %0) section "fn-$RUSTY$foo_struct:r2i32i16" { entry: %foo_struct = alloca %MyStruct*, align 8 store %MyStruct* %0, %MyStruct** %foo_struct, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap index fd1ff02550b..28bcfce8cb2 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_is_initialized_with_type_initializer.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [4 x i32], [4 x i32] } -@main_instance = global %main zeroinitializer -@__myArray__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4] +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2ai32ai32" +@__myArray__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4], section "var-$RUSTY$__myArray__init:ai32" -define void @target([4 x i32]* %0) section "fn-target:v" { +define void @target([4 x i32]* %0) section "fn-$RUSTY$target:ai32" { entry: %target = alloca [4 x i32]*, align 8 store [4 x i32]* %0, [4 x i32]** %target, align 8 @@ -23,7 +23,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap index 2c289792cbe..e0f38a2099c 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_with_initializers_is_initialized.snap @@ -7,11 +7,11 @@ source_filename = "main" %MyStrct = type { i32, i32, i32 } -@__MyStr__init = unnamed_addr constant [11 x i8] c"init\00\00\00\00\00\00\00" -@__MyArr__init = unnamed_addr constant [10 x float] [float 0.000000e+00, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000, float 0x40119999A0000000, float 5.500000e+00, float 0x401A666660000000, float 0x401ECCCCC0000000, float 0x40219999A0000000, float 0x4023CCCCC0000000] -@__MyStrct__init = unnamed_addr constant %MyStrct { i32 1, i32 2, i32 3 } +@__MyStr__init = unnamed_addr constant [11 x i8] c"init\00\00\00\00\00\00\00", section "var-$RUSTY$__MyStr__init:s8u11" +@__MyArr__init = unnamed_addr constant [10 x float] [float 0.000000e+00, float 0x3FF19999A0000000, float 0x40019999A0000000, float 0x400A666660000000, float 0x40119999A0000000, float 5.500000e+00, float 0x401A666660000000, float 0x401ECCCCC0000000, float 0x40219999A0000000, float 0x4023CCCCC0000000], section "var-$RUSTY$__MyArr__init:af32" +@__MyStrct__init = unnamed_addr constant %MyStrct { i32 1, i32 2, i32 3 }, section "var-$RUSTY$__MyStrct__init:r3i32i32i32" -define i16 @foo_int() section "fn-foo_int:v" { +define i16 @foo_int() section "fn-$RUSTY$foo_int:i16" { entry: %foo_int = alloca i16, align 2 store i16 7, i16* %foo_int, align 2 @@ -19,7 +19,7 @@ entry: ret i16 %foo_int_ret } -define void @foo_str([11 x i8]* %0) section "fn-foo_str:s8u11" { +define void @foo_str([11 x i8]* %0) section "fn-$RUSTY$foo_str:s8u11" { entry: %foo_str = alloca [11 x i8]*, align 8 store [11 x i8]* %0, [11 x i8]** %foo_str, align 8 @@ -29,7 +29,7 @@ entry: ret void } -define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" { +define void @foo_arr([10 x float]* %0) section "fn-$RUSTY$foo_arr:af32" { entry: %foo_arr = alloca [10 x float]*, align 8 store [10 x float]* %0, [10 x float]** %foo_arr, align 8 @@ -39,7 +39,7 @@ entry: ret void } -define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:v" { +define void @foo_strct(%MyStrct* %0) section "fn-$RUSTY$foo_strct:r3i32i32i32" { entry: %foo_strct = alloca %MyStrct*, align 8 store %MyStrct* %0, %MyStrct** %foo_strct, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap index 13afea3c3c0..10285ac17ac 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__function_return_value_without_initializers_is_initialized.snap @@ -7,9 +7,9 @@ source_filename = "main" %MyStrct = type { i32, i32, i32 } -@__MyStrct__init = unnamed_addr constant %MyStrct zeroinitializer +@__MyStrct__init = unnamed_addr constant %MyStrct zeroinitializer, section "var-$RUSTY$__MyStrct__init:r3i32i32i32" -define i16 @foo_int() section "fn-foo_int:v" { +define i16 @foo_int() section "fn-$RUSTY$foo_int:i16" { entry: %foo_int = alloca i16, align 2 store i16 0, i16* %foo_int, align 2 @@ -17,7 +17,7 @@ entry: ret i16 %foo_int_ret } -define void @foo_str([11 x i8]* %0) section "fn-foo_str:s8u11" { +define void @foo_str([11 x i8]* %0) section "fn-$RUSTY$foo_str:s8u11" { entry: %foo_str = alloca [11 x i8]*, align 8 store [11 x i8]* %0, [11 x i8]** %foo_str, align 8 @@ -27,7 +27,7 @@ entry: ret void } -define void @foo_arr([10 x float]* %0) section "fn-foo_arr:v" { +define void @foo_arr([10 x float]* %0) section "fn-$RUSTY$foo_arr:af32" { entry: %foo_arr = alloca [10 x float]*, align 8 store [10 x float]* %0, [10 x float]** %foo_arr, align 8 @@ -37,7 +37,7 @@ entry: ret void } -define void @foo_strct(%MyStrct* %0) section "fn-foo_strct:v" { +define void @foo_strct(%MyStrct* %0) section "fn-$RUSTY$foo_strct:r3i32i32i32" { entry: %foo_strct = alloca %MyStrct*, align 8 store %MyStrct* %0, %MyStrct** %foo_strct, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_constant_values_in_pou_variables.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_constant_values_in_pou_variables.snap index ac5fadd160b..13df4890ba3 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_constant_values_in_pou_variables.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_constant_values_in_pou_variables.snap @@ -7,12 +7,12 @@ source_filename = "main" %prg = type { i16, i16 } -@MAX_LEN = unnamed_addr constant i16 99 -@MIN_LEN = unnamed_addr constant i16 10 -@LEN = unnamed_addr constant i16 20 -@prg_instance = global %prg { i16 24, i16 89 } +@MAX_LEN = unnamed_addr constant i16 99, section "var-$RUSTY$MAX_LEN:i16" +@MIN_LEN = unnamed_addr constant i16 10, section "var-$RUSTY$MIN_LEN:i16" +@LEN = unnamed_addr constant i16 20, section "var-$RUSTY$LEN:i16" +@prg_instance = global %prg { i16 24, i16 89 }, section "var-$RUSTY$prg_instance:r2i16i16" -define void @prg(%prg* %0) section "fn-prg:v[i16][i16]" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v[i16][i16]" { entry: %my_len = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %my_size = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_array_of_array_variable.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_array_of_array_variable.snap index d0331729c00..c1c90a67fad 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_array_of_array_variable.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_array_of_array_variable.snap @@ -1,10 +1,8 @@ --- source: src/codegen/tests/initialization_test/pou_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@a = global [2 x [2 x i8]] [[2 x i8] c"\01\02", [2 x i8] c"\03\04"] - +@a = global [2 x [2 x i8]] [[2 x i8] c"\01\02", [2 x i8] c"\03\04"], section "var-$RUSTY$a:aau8" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_function_block_pou.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_function_block_pou.snap index a5929eb7d34..1e8c0d7672a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_function_block_pou.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_function_block_pou.snap @@ -8,10 +8,10 @@ source_filename = "main" %FB = type { i16, i16, i8, i8, float, float } %main = type { %FB } -@__FB__init = unnamed_addr constant %FB { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } -@main_instance = global %main { %FB { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } } +@__FB__init = unnamed_addr constant %FB { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 }, section "var-$RUSTY$__FB__init:r6i16i16u8u8f32f32" +@main_instance = global %main { %FB { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } }, section "var-$RUSTY$main_instance:r1r6i16i16u8u8f32f32" -define void @FB(%FB* %0) section "fn-FB:v" { +define void @FB(%FB* %0) section "fn-$RUSTY$FB:v" { entry: %x = getelementptr inbounds %FB, %FB* %0, i32 0, i32 0 %xx = getelementptr inbounds %FB, %FB* %0, i32 0, i32 1 @@ -22,7 +22,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %fb = getelementptr inbounds %main, %main* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_program_pou.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_program_pou.snap index ff7c4eea8f6..321b004892a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_program_pou.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initial_values_in_program_pou.snap @@ -7,9 +7,9 @@ source_filename = "main" %Main = type { i16, i16, i8, i8, float, float } -@Main_instance = global %Main { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } +@Main_instance = global %Main { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 }, section "var-$RUSTY$Main_instance:r6i16i16u8u8f32f32" -define void @Main(%Main* %0) section "fn-Main:v" { +define void @Main(%Main* %0) section "fn-$RUSTY$Main:v" { entry: %x = getelementptr inbounds %Main, %Main* %0, i32 0, i32 0 %xx = getelementptr inbounds %Main, %Main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_in_function.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_in_function.snap index ef4b85fed7d..3e0e2de57e8 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_in_function.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_in_function.snap @@ -7,7 +7,7 @@ source_filename = "main" @__func.arr_var__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4] -define i16 @func() section "fn-func:i16" { +define i16 @func() section "fn-$RUSTY$func:i16" { entry: %func = alloca i16, align 2 %arr_var = alloca [4 x i32], align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_type_in_function.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_type_in_function.snap index 180d254bf34..86a8ac76602 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_type_in_function.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__initialized_array_type_in_function.snap @@ -5,9 +5,9 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@__arr__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4] +@__arr__init = unnamed_addr constant [4 x i32] [i32 1, i32 2, i32 3, i32 4], section "var-$RUSTY$__arr__init:ai32" -define i16 @func() section "fn-func:i16" { +define i16 @func() section "fn-$RUSTY$func:i16" { entry: %func = alloca i16, align 2 %arr_var = alloca [4 x i32], align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__memcpy_for_struct_initialization_in_function.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__memcpy_for_struct_initialization_in_function.snap index 966bd9624c9..8580832c54d 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__memcpy_for_struct_initialization_in_function.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__memcpy_for_struct_initialization_in_function.snap @@ -7,9 +7,9 @@ source_filename = "main" %__func_a = type { i16 } -@____func_a__init = unnamed_addr constant %__func_a zeroinitializer +@____func_a__init = unnamed_addr constant %__func_a zeroinitializer, section "var-$RUSTY$____func_a__init:r1i16" -define i16 @func() section "fn-func:i16" { +define i16 @func() section "fn-$RUSTY$func:i16" { entry: %func = alloca i16, align 2 %a = alloca %__func_a, align 8 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__no_memcpy_for_struct_initialization_in_program.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__no_memcpy_for_struct_initialization_in_program.snap index fdd64024ee7..56554b9271e 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__no_memcpy_for_struct_initialization_in_program.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__no_memcpy_for_struct_initialization_in_program.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { %__prog_a } %__prog_a = type { i16 } -@prog_instance = global %prog zeroinitializer -@____prog_a__init = unnamed_addr constant %__prog_a zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r1r1i16" +@____prog_a__init = unnamed_addr constant %__prog_a zeroinitializer, section "var-$RUSTY$____prog_a__init:r1i16" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %a = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_are_referenced_correctly.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_are_referenced_correctly.snap index f29cc3f334e..0b39ed7cff4 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_are_referenced_correctly.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_are_referenced_correctly.snap @@ -5,12 +5,12 @@ expression: function ; ModuleID = 'main' source_filename = "main" -@__foo_position.x = unnamed_addr constant i32 1 -@__bar_position.x = unnamed_addr constant i32 3 -@__foo_position.y = unnamed_addr constant i32 2 -@__bar_position.y = unnamed_addr constant i32 4 +@__foo_position.x = unnamed_addr constant i32 1, section "var-$RUSTY$x:e2i32" +@__bar_position.x = unnamed_addr constant i32 3, section "var-$RUSTY$x:e2i32" +@__foo_position.y = unnamed_addr constant i32 2, section "var-$RUSTY$y:e2i32" +@__bar_position.y = unnamed_addr constant i32 4, section "var-$RUSTY$y:e2i32" -define i32 @foo() section "fn-foo:i32" { +define i32 @foo() section "fn-$RUSTY$foo:i32" { entry: %foo = alloca i32, align 4 %position = alloca i32, align 4 @@ -20,7 +20,7 @@ entry: ret i32 %foo_ret } -define i32 @bar() section "fn-bar:i32" { +define i32 @bar() section "fn-$RUSTY$bar:i32" { entry: %bar = alloca i32, align 4 %position = alloca i32, align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_with_similar_names_are_referenced_correctly.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_with_similar_names_are_referenced_correctly.snap index 4e12913c16d..909a6194e5b 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_with_similar_names_are_referenced_correctly.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__pou_initializers__two_identical_enums_in_different_functions_with_similar_names_are_referenced_correctly.snap @@ -5,16 +5,16 @@ expression: function ; ModuleID = 'main' source_filename = "main" -@__a_position.x = unnamed_addr constant i32 1 -@__aa_position.x = unnamed_addr constant i32 2 -@__bb_position.x = unnamed_addr constant i32 3 -@__b_position.x = unnamed_addr constant i32 4 -@__a_position.y = unnamed_addr constant i32 5 -@__aa_position.y = unnamed_addr constant i32 5 -@__bb_position.y = unnamed_addr constant i32 5 -@__b_position.y = unnamed_addr constant i32 5 +@__a_position.x = unnamed_addr constant i32 1, section "var-$RUSTY$x:e2i32" +@__aa_position.x = unnamed_addr constant i32 2, section "var-$RUSTY$x:e2i32" +@__bb_position.x = unnamed_addr constant i32 3, section "var-$RUSTY$x:e2i32" +@__b_position.x = unnamed_addr constant i32 4, section "var-$RUSTY$x:e2i32" +@__a_position.y = unnamed_addr constant i32 5, section "var-$RUSTY$y:e2i32" +@__aa_position.y = unnamed_addr constant i32 5, section "var-$RUSTY$y:e2i32" +@__bb_position.y = unnamed_addr constant i32 5, section "var-$RUSTY$y:e2i32" +@__b_position.y = unnamed_addr constant i32 5, section "var-$RUSTY$y:e2i32" -define i32 @a() section "fn-a:i32" { +define i32 @a() section "fn-$RUSTY$a:i32" { entry: %a = alloca i32, align 4 %position = alloca i32, align 4 @@ -24,7 +24,7 @@ entry: ret i32 %a_ret } -define i32 @aa() section "fn-aa:i32" { +define i32 @aa() section "fn-$RUSTY$aa:i32" { entry: %aa = alloca i32, align 4 %position = alloca i32, align 4 @@ -34,7 +34,7 @@ entry: ret i32 %aa_ret } -define i32 @bb() section "fn-bb:i32" { +define i32 @bb() section "fn-$RUSTY$bb:i32" { entry: %bb = alloca i32, align 4 %position = alloca i32, align 4 @@ -44,7 +44,7 @@ entry: ret i32 %bb_ret } -define i32 @b() section "fn-b:i32" { +define i32 @b() section "fn-$RUSTY$b:i32" { entry: %b = alloca i32, align 4 %position = alloca i32, align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__alias_chain_with_lots_of_initializers.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__alias_chain_with_lots_of_initializers.snap index 02b7546bc92..fc6e1924b42 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__alias_chain_with_lots_of_initializers.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__alias_chain_with_lots_of_initializers.snap @@ -1,13 +1,11 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@x0 = global i32 1 -@x1 = global i32 1 -@x2 = global i32 2 -@x3 = global i32 3 - +@x0 = global i32 1, section "var-$RUSTY$x0:i32" +@x1 = global i32 1, section "var-$RUSTY$x1:i32" +@x2 = global i32 2, section "var-$RUSTY$x2:i32" +@x3 = global i32 3, section "var-$RUSTY$x3:i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__array_of_struct_initialization.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__array_of_struct_initialization.snap index c43b1a1b00d..bcdff271ea4 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__array_of_struct_initialization.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__array_of_struct_initialization.snap @@ -8,15 +8,15 @@ source_filename = "main" %myStruct = type { i32, i32, [2 x i32] } %main = type { [2 x %myStruct], [2 x %myStruct] } -@str = unnamed_addr constant %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] } -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer -@alias_str = unnamed_addr constant %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] } -@global_arr = unnamed_addr constant [2 x i32] [i32 30, i32 40] -@main_instance = global %main { [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }], [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }] } +@str = unnamed_addr constant %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }, section "var-$RUSTY$str:r3i32i32ai32" +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r3i32i32ai32" +@alias_str = unnamed_addr constant %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }, section "var-$RUSTY$alias_str:r3i32i32ai32" +@global_arr = unnamed_addr constant [2 x i32] [i32 30, i32 40], section "var-$RUSTY$global_arr:ai32" +@main_instance = global %main { [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }], [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }] }, section "var-$RUSTY$main_instance:r2ar3i32i32ai32ar3i32i32ai32" @__main.arr__init = unnamed_addr constant [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }] @__main.alias_arr__init = unnamed_addr constant [2 x %myStruct] [%myStruct { i32 10, i32 20, [2 x i32] [i32 30, i32 40] }, %myStruct { i32 50, i32 60, [2 x i32] [i32 70, i32 80] }] -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %arr = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %alias_arr = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__complex_initial_values_in_struct_variable_using_multiplied_statement.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__complex_initial_values_in_struct_variable_using_multiplied_statement.snap index e20ef73b71c..c2a03ab1ec6 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__complex_initial_values_in_struct_variable_using_multiplied_statement.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__complex_initial_values_in_struct_variable_using_multiplied_statement.snap @@ -8,7 +8,6 @@ source_filename = "main" %MyStruct = type { %MyPoint, [4 x i16], i32 } %MyPoint = type { i32, i32 } -@a = global %MyStruct { %MyPoint { i32 1, i32 2 }, [4 x i16] [i16 0, i16 1, i16 2, i16 3], i32 7 } -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer -@__MyPoint__init = unnamed_addr constant %MyPoint zeroinitializer - +@a = global %MyStruct { %MyPoint { i32 1, i32 2 }, [4 x i16] [i16 0, i16 1, i16 2, i16 3], i32 7 }, section "var-$RUSTY$a:r3r2i32i32ai16i32" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r3r2i32i32ai16i32" +@__MyPoint__init = unnamed_addr constant %MyPoint zeroinitializer, section "var-$RUSTY$__MyPoint__init:r2i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap index 54a43a74669..ae268a9d1b6 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap @@ -5,23 +5,23 @@ expression: res ; ModuleID = 'main' source_filename = "main" -@x = global i32 2 -@__main_var1.x1 = unnamed_addr constant i32 1 -@__main_var2.x7 = unnamed_addr constant i32 2 -@__global_x.yellow = unnamed_addr constant i32 1 -@__main_y.redy = unnamed_addr constant i32 1 -@__main_y.yellowy = unnamed_addr constant i32 2 -@__main_y.greeny = unnamed_addr constant i32 3 -@__main_var1.x2 = unnamed_addr constant i32 2 -@__main_var1.x3 = unnamed_addr constant i32 3 -@__main_var2.x5 = unnamed_addr constant i32 0 -@__main_var2.x6 = unnamed_addr constant i32 1 -@__main_var3.x8 = unnamed_addr constant i32 0 -@__main_var3.x9 = unnamed_addr constant i32 1 -@__global_x.red = unnamed_addr constant i32 0 -@__global_x.green = unnamed_addr constant i32 2 +@x = global i32 2, section "var-$RUSTY$x:e3i32" +@__main_var1.x1 = unnamed_addr constant i32 1, section "var-$RUSTY$x1:e3i32" +@__main_var2.x7 = unnamed_addr constant i32 2, section "var-$RUSTY$x7:e3i32" +@__global_x.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" +@__main_y.redy = unnamed_addr constant i32 1, section "var-$RUSTY$redy:e3i32" +@__main_y.yellowy = unnamed_addr constant i32 2, section "var-$RUSTY$yellowy:e3i32" +@__main_y.greeny = unnamed_addr constant i32 3, section "var-$RUSTY$greeny:e3i32" +@__main_var1.x2 = unnamed_addr constant i32 2, section "var-$RUSTY$x2:e3i32" +@__main_var1.x3 = unnamed_addr constant i32 3, section "var-$RUSTY$x3:e3i32" +@__main_var2.x5 = unnamed_addr constant i32 0, section "var-$RUSTY$x5:e3i32" +@__main_var2.x6 = unnamed_addr constant i32 1, section "var-$RUSTY$x6:e3i32" +@__main_var3.x8 = unnamed_addr constant i32 0, section "var-$RUSTY$x8:e2i32" +@__main_var3.x9 = unnamed_addr constant i32 1, section "var-$RUSTY$x9:e2i32" +@__global_x.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" +@__global_x.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %y = alloca i32, align 4 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__expression_list_as_array_initilization.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__expression_list_as_array_initilization.snap index dd18222fa13..824ad9c5e10 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__expression_list_as_array_initilization.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__expression_list_as_array_initilization.snap @@ -1,13 +1,10 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs -assertion_line: 93 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@arr = global [5 x i16] [i16 1, i16 2, i16 3, i16 0, i16 0] -@b_exp = global [6 x i32] [i32 4, i32 6, i32 6, i32 10, i32 0, i32 0] -@str = global [4 x [81 x i8]] [[81 x i8] c"first\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] c"second\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] zeroinitializer, [81 x i8] zeroinitializer] - +@arr = global [5 x i16] [i16 1, i16 2, i16 3, i16 0, i16 0], section "var-$RUSTY$arr:ai16" +@b_exp = global [6 x i32] [i32 4, i32 6, i32 6, i32 10, i32 0, i32 0], section "var-$RUSTY$b_exp:ai32" +@str = global [4 x [81 x i8]] [[81 x i8] c"first\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] c"second\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] zeroinitializer, [81 x i8] zeroinitializer], section "var-$RUSTY$str:as8u81" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization.snap index 584be447f36..021515d7fda 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization.snap @@ -1,11 +1,8 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs -assertion_line: 105 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@arr = global [6 x i16] [i16 0, i16 1, i16 2, i16 0, i16 0, i16 0] - +@arr = global [6 x i16] [i16 0, i16 1, i16 2, i16 0, i16 0, i16 0], section "var-$RUSTY$arr:ai16" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization_with_custom_init_value.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization_with_custom_init_value.snap index 66951c1e73b..a6cbce9a07b 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization_with_custom_init_value.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__incomplete_array_initialization_with_custom_init_value.snap @@ -1,11 +1,8 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs -assertion_line: 119 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@arr = global [6 x i16] [i16 0, i16 1, i16 2, i16 7, i16 7, i16 7] - +@arr = global [6 x i16] [i16 0, i16 1, i16 2, i16 7, i16 7, i16 7], section "var-$RUSTY$arr:ai16" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_nested_struct_delayed_init.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_nested_struct_delayed_init.snap index 2e399090e9b..aac646fb3fa 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_nested_struct_delayed_init.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_nested_struct_delayed_init.snap @@ -8,8 +8,7 @@ source_filename = "main" %MyStruct2 = type { %MyStruct, %MyStruct } %MyStruct = type { i32, i32 } -@a = global %MyStruct2 { %MyStruct { i32 5, i32 7 }, %MyStruct { i32 3, i32 2 } } -@__MyStruct2__init = unnamed_addr constant %MyStruct2 { %MyStruct { i32 5, i32 3 }, %MyStruct { i32 0, i32 7 } } -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer -@b = global %MyStruct2 { %MyStruct { i32 5, i32 3 }, %MyStruct { i32 9, i32 0 } } - +@a = global %MyStruct2 { %MyStruct { i32 5, i32 7 }, %MyStruct { i32 3, i32 2 } }, section "var-$RUSTY$a:r2r2i32i32r2i32i32" +@__MyStruct2__init = unnamed_addr constant %MyStruct2 { %MyStruct { i32 5, i32 3 }, %MyStruct { i32 0, i32 7 } }, section "var-$RUSTY$__MyStruct2__init:r2r2i32i32r2i32i32" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r2i32i32" +@b = global %MyStruct2 { %MyStruct { i32 5, i32 3 }, %MyStruct { i32 9, i32 0 } }, section "var-$RUSTY$b:r2r2i32i32r2i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_array_variable_using_multiplied_statement.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_array_variable_using_multiplied_statement.snap index bb1bd1833f4..86bc9db0b6e 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_array_variable_using_multiplied_statement.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_array_variable_using_multiplied_statement.snap @@ -1,13 +1,11 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@a = global [4 x i8] c"\07\07\07\07" -@b = global [4 x i8] c"\02\07\07\03" -@c = global [10 x i8] c"\00\01\00\01\00\01\00\01\00\01" -@d = global [10 x i8] c"\00\00\01\01\02\00\00\01\01\02" - +@a = global [4 x i8] c"\07\07\07\07", section "var-$RUSTY$a:au8" +@b = global [4 x i8] c"\02\07\07\03", section "var-$RUSTY$b:au8" +@c = global [10 x i8] c"\00\01\00\01\00\01\00\01\00\01", section "var-$RUSTY$c:au8" +@d = global [10 x i8] c"\00\00\01\01\02\00\00\01\01\02", section "var-$RUSTY$d:au8" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_fb_variable.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_fb_variable.snap index c1d76999b91..7765eaf2090 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_fb_variable.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_fb_variable.snap @@ -8,19 +8,19 @@ source_filename = "main" %TON = type { i16, i16 } %main = type { i16, %TON, %TON } -@__TON__init = unnamed_addr constant %TON zeroinitializer -@main_instance = global %main { i16 10, %TON { i16 10, i16 17 }, %TON { i16 17, i16 10 } } +@__TON__init = unnamed_addr constant %TON zeroinitializer, section "var-$RUSTY$__TON__init:r2i16i16" +@main_instance = global %main { i16 10, %TON { i16 10, i16 17 }, %TON { i16 17, i16 10 } }, section "var-$RUSTY$main_instance:r3i16r2i16i16r2i16i16" @__main.struct1__init = unnamed_addr constant %TON { i16 10, i16 17 } @__main.struct2__init = unnamed_addr constant %TON { i16 17, i16 10 } -define void @TON(%TON* %0) section "fn-TON:v[i16][i16]" { +define void @TON(%TON* %0) section "fn-$RUSTY$TON:v[i16][i16]" { entry: %a = getelementptr inbounds %TON, %TON* %0, i32 0, i32 0 %b = getelementptr inbounds %TON, %TON* %0, i32 0, i32 1 ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %TEN = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %struct1 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_multi_dimension_array_variable.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_multi_dimension_array_variable.snap index 0f3864ac7c5..af8103d09fc 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_multi_dimension_array_variable.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_multi_dimension_array_variable.snap @@ -1,11 +1,8 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs -assertion_line: 158 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@a = global [4 x i8] c"\01\02\03\04" - +@a = global [4 x i8] c"\01\02\03\04", section "var-$RUSTY$a:au8" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_type.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_type.snap index efe72cb3123..315a178dbbe 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_type.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_type.snap @@ -5,6 +5,5 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@x = global [3 x i16] [i16 1, i16 2, i16 3] -@__MyArray__init = unnamed_addr constant [3 x i16] [i16 1, i16 2, i16 3] - +@x = global [3 x i16] [i16 1, i16 2, i16 3], section "var-$RUSTY$x:ai16" +@__MyArray__init = unnamed_addr constant [3 x i16] [i16 1, i16 2, i16 3], section "var-$RUSTY$__MyArray__init:ai16" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_variable.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_variable.snap index 387927ce958..11a1256f4eb 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_variable.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_single_dimension_array_variable.snap @@ -1,18 +1,15 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs -assertion_line: 159 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@a = global [3 x i8] c"\01\02\03" -@b = global [3 x i16] [i16 1, i16 2, i16 3] -@c = global [3 x i32] [i32 1, i32 2, i32 3] -@d = global [3 x i64] [i64 1, i64 2, i64 3] -@e = global [3 x i8] c"\01\02\03" -@f = global [3 x i16] [i16 1, i16 2, i16 3] -@g = global [3 x i64] [i64 1, i64 2, i64 3] -@h = global [3 x i8] [i8 true, i8 false, i8 true] - +@a = global [3 x i8] c"\01\02\03", section "var-$RUSTY$a:ai8" +@b = global [3 x i16] [i16 1, i16 2, i16 3], section "var-$RUSTY$b:ai16" +@c = global [3 x i32] [i32 1, i32 2, i32 3], section "var-$RUSTY$c:ai32" +@d = global [3 x i64] [i64 1, i64 2, i64 3], section "var-$RUSTY$d:ai64" +@e = global [3 x i8] c"\01\02\03", section "var-$RUSTY$e:au8" +@f = global [3 x i16] [i16 1, i16 2, i16 3], section "var-$RUSTY$f:au16" +@g = global [3 x i64] [i64 1, i64 2, i64 3], section "var-$RUSTY$g:au64" +@h = global [3 x i8] [i8 true, i8 false, i8 true], section "var-$RUSTY$h:au8" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_types.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_types.snap index 4371c8d7e68..08cd394f44c 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_types.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_types.snap @@ -7,6 +7,5 @@ source_filename = "main" %MyStruct = type { i16, i16, i8, i8, float, float } -@x = global %MyStruct { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } -@__MyStruct__init = unnamed_addr constant %MyStruct { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 } - +@x = global %MyStruct { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 }, section "var-$RUSTY$x:r6i16i16u8u8f32f32" +@__MyStruct__init = unnamed_addr constant %MyStruct { i16 7, i16 0, i8 1, i8 0, float 0x400921CAC0000000, float 0.000000e+00 }, section "var-$RUSTY$__MyStruct__init:r6i16i16u8u8f32f32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable.snap index bf4180e4390..81b708c0b7c 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable.snap @@ -7,7 +7,6 @@ source_filename = "main" %MyStruct = type { i32, i32 } -@a = global %MyStruct { i32 3, i32 5 } -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer -@b = global %MyStruct { i32 5, i32 3 } - +@a = global %MyStruct { i32 3, i32 5 }, section "var-$RUSTY$a:r2i32i32" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r2i32i32" +@b = global %MyStruct { i32 5, i32 3 }, section "var-$RUSTY$b:r2i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable_missing_init.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable_missing_init.snap index efd2696cdd4..1af6b57f9ac 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable_missing_init.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_struct_variable_missing_init.snap @@ -7,7 +7,6 @@ source_filename = "main" %MyStruct = type { i32, i32, i32 } -@a = global %MyStruct { i32 5, i32 0, i32 10 } -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer -@b = global %MyStruct { i32 0, i32 3, i32 10 } - +@a = global %MyStruct { i32 5, i32 0, i32 10 }, section "var-$RUSTY$a:r3i32i32i32" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r3i32i32i32" +@b = global %MyStruct { i32 0, i32 3, i32 10 }, section "var-$RUSTY$b:r3i32i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_sub_range_type.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_sub_range_type.snap index f41b371bc40..19e4368276a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_sub_range_type.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_sub_range_type.snap @@ -1,10 +1,8 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@x = global i16 7 - +@x = global i16 7, section "var-$RUSTY$x:i16" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_type_alias.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_type_alias.snap index f41b371bc40..19e4368276a 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_type_alias.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__initial_values_in_type_alias.snap @@ -1,10 +1,8 @@ --- source: src/codegen/tests/initialization_test/type_initializers.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@x = global i16 7 - +@x = global i16 7, section "var-$RUSTY$x:i16" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__partly_uninitialized_const_struct_will_get_default_values.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__partly_uninitialized_const_struct_will_get_default_values.snap index 5085a5dbb3c..7f537a59618 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__partly_uninitialized_const_struct_will_get_default_values.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__partly_uninitialized_const_struct_will_get_default_values.snap @@ -7,7 +7,6 @@ source_filename = "main" %Point = type { i32, i32, i32 } -@x = unnamed_addr constant %Point { i32 1, i32 2, i32 3 } -@__Point__init = unnamed_addr constant %Point { i32 0, i32 2, i32 3 } -@empty = unnamed_addr constant %Point { i32 0, i32 2, i32 3 } - +@x = unnamed_addr constant %Point { i32 1, i32 2, i32 3 }, section "var-$RUSTY$x:r3i32i32i32" +@__Point__init = unnamed_addr constant %Point { i32 0, i32 2, i32 3 }, section "var-$RUSTY$__Point__init:r3i32i32i32" +@empty = unnamed_addr constant %Point { i32 0, i32 2, i32 3 }, section "var-$RUSTY$empty:r3i32i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__skipped_field_members_for_array_of_structs_are_zero_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__skipped_field_members_for_array_of_structs_are_zero_initialized.snap index ed8acdc1818..46b624c2e8f 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__skipped_field_members_for_array_of_structs_are_zero_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__skipped_field_members_for_array_of_structs_are_zero_initialized.snap @@ -9,12 +9,12 @@ source_filename = "main" %STRUCT1 = type { i32, [2 x %STRUCT2] } %STRUCT2 = type { i32, i32 } -@main_instance = global %main { [3 x %STRUCT1] [%STRUCT1 { i32 0, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 2, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 1 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 1, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 { i32 0, i32 2 }] }] } -@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer -@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer +@main_instance = global %main { [3 x %STRUCT1] [%STRUCT1 { i32 0, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 2, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 1 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 1, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 { i32 0, i32 2 }] }] }, section "var-$RUSTY$main_instance:r1ar2i32ar2i32i32" +@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer, section "var-$RUSTY$__STRUCT1__init:r2i32ar2i32i32" +@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer, section "var-$RUSTY$__STRUCT2__init:r2i32i32" @__main.var_init1__init = unnamed_addr constant [3 x %STRUCT1] [%STRUCT1 { i32 0, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 2, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 1 }, %STRUCT2 zeroinitializer] }, %STRUCT1 { i32 1, [2 x %STRUCT2] [%STRUCT2 { i32 1, i32 0 }, %STRUCT2 { i32 0, i32 2 }] }] -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var_init1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initial_values_different_data_types.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initial_values_different_data_types.snap index 16b3f1ef6cb..ef300e26065 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initial_values_different_data_types.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initial_values_different_data_types.snap @@ -7,6 +7,5 @@ source_filename = "main" %MyStruct = type { i8, i8, i8, i16, i16, i16, i32, i32, i32, i64, i64, i64, float, double } -@x = global %MyStruct { i8 7, i8 7, i8 7, i16 7, i16 7, i16 7, i32 7, i32 7, i32 7, i64 7, i64 7, i64 7, float 0x401ECCCCC0000000, double 7.700000e+00 } -@__MyStruct__init = unnamed_addr constant %MyStruct { i8 7, i8 7, i8 7, i16 7, i16 7, i16 7, i32 7, i32 7, i32 7, i64 7, i64 7, i64 7, float 0x401ECCCCC0000000, double 7.700000e+00 } - +@x = global %MyStruct { i8 7, i8 7, i8 7, i16 7, i16 7, i16 7, i32 7, i32 7, i32 7, i64 7, i64 7, i64 7, float 0x401ECCCCC0000000, double 7.700000e+00 }, section "var-$RUSTY$x:r14u8i8u8u16i16u16u32i32u32u64i64u64f32f64" +@__MyStruct__init = unnamed_addr constant %MyStruct { i8 7, i8 7, i8 7, i16 7, i16 7, i16 7, i32 7, i32 7, i32 7, i64 7, i64 7, i64 7, float 0x401ECCCCC0000000, double 7.700000e+00 }, section "var-$RUSTY$__MyStruct__init:r14u8i8u8u16i16u16u32i32u32u64i64u64f32f64" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initialization_uses_types_default_if_not_provided.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initialization_uses_types_default_if_not_provided.snap index d5d1781a3b3..7be6b8fac0e 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initialization_uses_types_default_if_not_provided.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initialization_uses_types_default_if_not_provided.snap @@ -7,6 +7,5 @@ source_filename = "main" %Point = type { i32, i32, i32 } -@x = global %Point { i32 1, i32 2, i32 7 } -@__Point__init = unnamed_addr constant %Point { i32 0, i32 0, i32 7 } - +@x = global %Point { i32 1, i32 2, i32 7 }, section "var-$RUSTY$x:r3i32i32i32" +@__Point__init = unnamed_addr constant %Point { i32 0, i32 0, i32 7 }, section "var-$RUSTY$__Point__init:r3i32i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initializer_uses_fallback_to_field_default.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initializer_uses_fallback_to_field_default.snap index d7a15081874..91134e83f04 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initializer_uses_fallback_to_field_default.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_initializer_uses_fallback_to_field_default.snap @@ -7,6 +7,5 @@ source_filename = "main" %Point = type { i32, i32, i32 } -@x = global %Point { i32 1, i32 2, i32 3 } -@__Point__init = unnamed_addr constant %Point { i32 0, i32 2, i32 3 } - +@x = global %Point { i32 1, i32 2, i32 3 }, section "var-$RUSTY$x:r3i32i32i32" +@__Point__init = unnamed_addr constant %Point { i32 0, i32 2, i32 3 }, section "var-$RUSTY$__Point__init:r3i32i32i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_with_one_field_can_be_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_with_one_field_can_be_initialized.snap index f3c20bd570f..89fb1065d4d 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_with_one_field_can_be_initialized.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__struct_with_one_field_can_be_initialized.snap @@ -7,6 +7,5 @@ source_filename = "main" %MyPoint = type { i32 } -@a = global %MyPoint { i32 7 } -@__MyPoint__init = unnamed_addr constant %MyPoint zeroinitializer - +@a = global %MyPoint { i32 7 }, section "var-$RUSTY$a:r1i32" +@__MyPoint__init = unnamed_addr constant %MyPoint zeroinitializer, section "var-$RUSTY$__MyPoint__init:r1i32" diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__type_defaults_are_used_for_uninitialized_constants.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__type_defaults_are_used_for_uninitialized_constants.snap index 908bd3460a0..70a71050f98 100644 --- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__type_defaults_are_used_for_uninitialized_constants.snap +++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__type_defaults_are_used_for_uninitialized_constants.snap @@ -5,8 +5,7 @@ expression: result.unwrap() ; ModuleID = 'main' source_filename = "main" -@a = unnamed_addr constant i16 7 -@b = unnamed_addr constant i16 21 -@c = unnamed_addr constant i32 2 -@d = unnamed_addr constant i32 30 - +@a = unnamed_addr constant i16 7, section "var-$RUSTY$a:i16" +@b = unnamed_addr constant i16 21, section "var-$RUSTY$b:i16" +@c = unnamed_addr constant i32 2, section "var-$RUSTY$c:i32" +@d = unnamed_addr constant i32 30, section "var-$RUSTY$d:i32" diff --git a/src/codegen/tests/parameters_tests.rs b/src/codegen/tests/parameters_tests.rs index 0e2745257ab..f13d221a36a 100644 --- a/src/codegen/tests/parameters_tests.rs +++ b/src/codegen/tests/parameters_tests.rs @@ -711,7 +711,7 @@ fn by_value_function_arg_builtin_type_strings_are_memcopied() { ; ModuleID = 'main' source_filename = "main" - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %str = alloca [81 x i8], align 1 @@ -724,7 +724,7 @@ fn by_value_function_arg_builtin_type_strings_are_memcopied() { ret i32 %main_ret } - define i32 @foo(i8* %0) section "fn-foo:i32[s8u81]" { + define i32 @foo(i8* %0) section "fn-$RUSTY$foo:i32[s8u81]" { entry: %foo = alloca i32, align 4 %val = alloca [81 x i8], align 1 @@ -770,7 +770,7 @@ fn by_value_function_arg_user_type_strings_are_memcopied() { ; ModuleID = 'main' source_filename = "main" - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %str = alloca [65537 x i8], align 1 @@ -783,7 +783,7 @@ fn by_value_function_arg_user_type_strings_are_memcopied() { ret i32 %main_ret } - define i32 @foo(i8* %0) section "fn-foo:i32[s8u65537]" { + define i32 @foo(i8* %0) section "fn-$RUSTY$foo:i32[s8u65537]" { entry: %foo = alloca i32, align 4 %val = alloca [65537 x i8], align 1 @@ -829,7 +829,7 @@ fn by_value_function_arg_arrays_are_memcopied() { ; ModuleID = 'main' source_filename = "main" - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %arr = alloca [65537 x i32], align 4 @@ -842,7 +842,7 @@ fn by_value_function_arg_arrays_are_memcopied() { ret i32 %main_ret } - define i32 @foo(i32* %0) section "fn-foo:i32[v]" { + define i32 @foo(i32* %0) section "fn-$RUSTY$foo:i32[ai32]" { entry: %foo = alloca i32, align 4 %val = alloca [65537 x i32], align 4 @@ -897,9 +897,9 @@ fn by_value_function_arg_structs_are_memcopied() { %S_TY = type { i8, i8 } - @__S_TY__init = unnamed_addr constant %S_TY zeroinitializer + @__S_TY__init = unnamed_addr constant %S_TY zeroinitializer, section "var-$RUSTY$__S_TY__init:r2u8u8" - define i32 @foo(%S_TY* %0) section "fn-foo:i32[v]" { + define i32 @foo(%S_TY* %0) section "fn-$RUSTY$foo:i32[r2u8u8]" { entry: %foo = alloca i32, align 4 %val = alloca %S_TY, align 8 @@ -911,7 +911,7 @@ fn by_value_function_arg_structs_are_memcopied() { ret i32 %foo_ret } - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %s = alloca %S_TY, align 8 @@ -969,10 +969,10 @@ fn by_value_function_arg_structs_with_aggregate_members_are_memcopied() { %AGGREGATE_COLLECTOR_TY = type { [65537 x i32], [65537 x i8], %S_TY } %S_TY = type { i8, i8 } - @__AGGREGATE_COLLECTOR_TY__init = unnamed_addr constant %AGGREGATE_COLLECTOR_TY zeroinitializer - @__S_TY__init = unnamed_addr constant %S_TY zeroinitializer + @__AGGREGATE_COLLECTOR_TY__init = unnamed_addr constant %AGGREGATE_COLLECTOR_TY zeroinitializer, section "var-$RUSTY$__AGGREGATE_COLLECTOR_TY__init:r3ai32s8u65537r2u8u8" + @__S_TY__init = unnamed_addr constant %S_TY zeroinitializer, section "var-$RUSTY$__S_TY__init:r2u8u8" - define i32 @foo(%AGGREGATE_COLLECTOR_TY* %0) section "fn-foo:i32[v]" { + define i32 @foo(%AGGREGATE_COLLECTOR_TY* %0) section "fn-$RUSTY$foo:i32[r3ai32s8u65537r2u8u8]" { entry: %foo = alloca i32, align 4 %val = alloca %AGGREGATE_COLLECTOR_TY, align 8 @@ -984,7 +984,7 @@ fn by_value_function_arg_structs_with_aggregate_members_are_memcopied() { ret i32 %foo_ret } - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %s = alloca %AGGREGATE_COLLECTOR_TY, align 8 @@ -1031,9 +1031,9 @@ fn by_value_fb_arg_aggregates_are_memcopied() { %FOO = type { [65537 x i8], [1024 x i32] } - @__FOO__init = unnamed_addr constant %FOO zeroinitializer + @__FOO__init = unnamed_addr constant %FOO zeroinitializer, section "var-$RUSTY$__FOO__init:r2s8u65537ai32" - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %str = alloca [65537 x i8], align 1 @@ -1059,7 +1059,7 @@ fn by_value_fb_arg_aggregates_are_memcopied() { ret i32 %main_ret } - define void @FOO(%FOO* %0) section "fn-FOO:v[s8u65537][v]" { + define void @FOO(%FOO* %0) section "fn-$RUSTY$FOO:v[s8u65537][ai32]" { entry: %val = getelementptr inbounds %FOO, %FOO* %0, i32 0, i32 0 %field = getelementptr inbounds %FOO, %FOO* %0, i32 0, i32 1 @@ -1121,11 +1121,11 @@ fn var_output_aggregate_types_are_memcopied() { %OUT_TYPE = type { i8 } %PRG = type { %OUT_TYPE, [11 x i32], [11 x %OUT_TYPE], [81 x i8], [81 x i16], %FB } - @__FB__init = unnamed_addr constant %FB zeroinitializer - @__OUT_TYPE__init = unnamed_addr constant %OUT_TYPE zeroinitializer - @PRG_instance = global %PRG zeroinitializer + @__FB__init = unnamed_addr constant %FB zeroinitializer, section "var-$RUSTY$__FB__init:r5r1u8ai32ar1u8s8u81s16u81" + @__OUT_TYPE__init = unnamed_addr constant %OUT_TYPE zeroinitializer, section "var-$RUSTY$__OUT_TYPE__init:r1u8" + @PRG_instance = global %PRG zeroinitializer, section "var-$RUSTY$PRG_instance:r6r1u8ai32ar1u8s8u81s16u81r5r1u8ai32ar1u8s8u81s16u81" - define void @FB(%FB* %0) section "fn-FB:v[v][v][v][s8u81][s16u81]" { + define void @FB(%FB* %0) section "fn-$RUSTY$FB:v[r1u8][ai32][ar1u8][s8u81][s16u81]" { entry: %output = getelementptr inbounds %FB, %FB* %0, i32 0, i32 0 %output2 = getelementptr inbounds %FB, %FB* %0, i32 0, i32 1 @@ -1135,7 +1135,7 @@ fn var_output_aggregate_types_are_memcopied() { ret void } - define void @PRG(%PRG* %0) section "fn-PRG:v" { + define void @PRG(%PRG* %0) section "fn-$RUSTY$PRG:v" { entry: %out = getelementptr inbounds %PRG, %PRG* %0, i32 0, i32 0 %out2 = getelementptr inbounds %PRG, %PRG* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__a_global_variables_generates_in_separate_global_variables.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__a_global_variables_generates_in_separate_global_variables.snap index 109b0bd442e..7634d39be5c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__a_global_variables_generates_in_separate_global_variables.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__a_global_variables_generates_in_separate_global_variables.snap @@ -7,11 +7,11 @@ source_filename = "main" %main = type {} -@gX = global i16 0 -@gY = global i8 0 -@main_instance = global %main zeroinitializer +@gX = global i16 0, section "var-$RUSTY$gX:i16" +@gY = global i8 0, section "var-$RUSTY$gY:u8" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_array_in_struct.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_array_in_struct.snap index 29682365fe6..cb25e9ba1a8 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_array_in_struct.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_array_in_struct.snap @@ -8,10 +8,10 @@ source_filename = "main" %Main = type { %MyStruct } %MyStruct = type { [5 x i16] } -@Main_instance = global %Main zeroinitializer -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer +@Main_instance = global %Main zeroinitializer, section "var-$RUSTY$Main_instance:r1r1ai16" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r1ai16" -define void @Main(%Main* %0) section "fn-Main:v" { +define void @Main(%Main* %0) section "fn-$RUSTY$Main:v" { entry: %m = getelementptr inbounds %Main, %Main* %0, i32 0, i32 0 %field1 = getelementptr inbounds %MyStruct, %MyStruct* %m, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_structs.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_structs.snap index e32a4f30981..304525bce44 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_structs.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__accessing_nested_structs.snap @@ -9,11 +9,11 @@ source_filename = "main" %OuterStruct = type { %InnerStruct, %InnerStruct } %InnerStruct = type { i16, i16 } -@Main_instance = global %Main zeroinitializer -@__OuterStruct__init = unnamed_addr constant %OuterStruct zeroinitializer -@__InnerStruct__init = unnamed_addr constant %InnerStruct zeroinitializer +@Main_instance = global %Main zeroinitializer, section "var-$RUSTY$Main_instance:r1r2r2i16i16r2i16i16" +@__OuterStruct__init = unnamed_addr constant %OuterStruct zeroinitializer, section "var-$RUSTY$__OuterStruct__init:r2r2i16i16r2i16i16" +@__InnerStruct__init = unnamed_addr constant %InnerStruct zeroinitializer, section "var-$RUSTY$__InnerStruct__init:r2i16i16" -define void @Main(%Main* %0) section "fn-Main:v" { +define void @Main(%Main* %0) section "fn-$RUSTY$Main:v" { entry: %m = getelementptr inbounds %Main, %Main* %0, i32 0, i32 0 %out1 = getelementptr inbounds %OuterStruct, %OuterStruct* %m, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__action_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__action_called_in_program.snap index 112d4e99aa4..ae2766bb081 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__action_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__action_called_in_program.snap @@ -7,16 +7,16 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 call void @prg.foo(%prg* %0) ret void } -define void @prg.foo(%prg* %0) section "fn-prg.foo:v" { +define void @prg.foo(%prg* %0) section "fn-$RUSTY$prg.foo:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 2, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_cast_int_type_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_cast_int_type_generated.snap index 3f8c29168c9..e2aa3a0c5e8 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_cast_int_type_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_cast_int_type_generated.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [11 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_negative_type_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_negative_type_generated.snap index a3273bd0e94..c8c90ea6375 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_negative_type_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_negative_type_generated.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [31 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_type_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_type_generated.snap index 3f8c29168c9..e2aa3a0c5e8 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_type_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_non_zero_type_generated.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [11 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_generated.snap index 3f8c29168c9..e2aa3a0c5e8 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_generated.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [11 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_used.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_used.snap index afcb9daee65..82c76115c38 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_used.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_used.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [4 x i32] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %tmpVar = getelementptr inbounds [4 x i32], [4 x i32]* %x, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_negative_start_used.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_negative_start_used.snap index 605324ede9a..0a2219c7292 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_negative_start_used.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_negative_start_used.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [6 x i32] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %tmpVar = getelementptr inbounds [6 x i32], [6 x i32]* %x, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_start_used.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_start_used.snap index 6ed961f13e7..de08512f595 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_start_used.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_int_type_with_non_zero_start_used.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [3 x i32] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %tmpVar = getelementptr inbounds [3 x i32], [3 x i32]* %x, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_and_variable_declaration_is_initialized.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_and_variable_declaration_is_initialized.snap index 3c096b12859..ab227e820fe 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_and_variable_declaration_is_initialized.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_and_variable_declaration_is_initialized.snap @@ -9,12 +9,12 @@ source_filename = "main" %STRUCT1 = type { i16, [5 x %STRUCT2] } %STRUCT2 = type { i8, i32 } -@mainProg_instance = global %mainProg { [5 x %STRUCT1] [%STRUCT1 { i16 1, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 { i16 2, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 256 }, %STRUCT2 { i8 0, i32 2048 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer] } -@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer -@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer +@mainProg_instance = global %mainProg { [5 x %STRUCT1] [%STRUCT1 { i16 1, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 { i16 2, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 256 }, %STRUCT2 { i8 0, i32 2048 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer] }, section "var-$RUSTY$mainProg_instance:r1ar2i16ar2u8i32" +@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer, section "var-$RUSTY$__STRUCT1__init:r2i16ar2u8i32" +@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer, section "var-$RUSTY$__STRUCT2__init:r2u8i32" @__mainProg.var_str1__init = unnamed_addr constant [5 x %STRUCT1] [%STRUCT1 { i16 1, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 { i16 2, [5 x %STRUCT2] [%STRUCT2 { i8 1, i32 256 }, %STRUCT2 { i8 0, i32 2048 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] }, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer, %STRUCT1 zeroinitializer] -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" { entry: %var_str1 = getelementptr inbounds %mainProg, %mainProg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_is_initialized.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_is_initialized.snap index 671390a36aa..d26b1b97d47 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_is_initialized.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__array_of_struct_as_member_of_another_struct_is_initialized.snap @@ -9,12 +9,12 @@ source_filename = "main" %STRUCT1 = type { i16, [11 x %STRUCT2] } %STRUCT2 = type { i8, i32 } -@mainProg_instance = global %mainProg { %STRUCT1 { i16 10, [11 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] } } -@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer -@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer +@mainProg_instance = global %mainProg { %STRUCT1 { i16 10, [11 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] } }, section "var-$RUSTY$mainProg_instance:r1r2i16ar2u8i32" +@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer, section "var-$RUSTY$__STRUCT1__init:r2i16ar2u8i32" +@__STRUCT2__init = unnamed_addr constant %STRUCT2 zeroinitializer, section "var-$RUSTY$__STRUCT2__init:r2u8i32" @__mainProg.var_str1__init = unnamed_addr constant %STRUCT1 { i16 10, [11 x %STRUCT2] [%STRUCT2 { i8 1, i32 128 }, %STRUCT2 { i8 0, i32 1024 }, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer, %STRUCT2 zeroinitializer] } -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" { entry: %var_str1 = getelementptr inbounds %mainProg, %mainProg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_are_generated.snap index 6057650a3a4..6c6d0bea958 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_are_generated.snap @@ -1,11 +1,9 @@ --- source: src/codegen/tests/code_gen_tests.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@x = global [10 x i16] zeroinitializer -@y = global [6 x float] zeroinitializer - +@x = global [10 x i16] zeroinitializer, section "var-$RUSTY$x:ai16" +@y = global [6 x float] zeroinitializer, section "var-$RUSTY$y:af32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_with_global_const_size_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_with_global_const_size_are_generated.snap index d03111f3e69..dd64c485d5c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_with_global_const_size_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__arrays_with_global_const_size_are_generated.snap @@ -1,18 +1,15 @@ --- source: src/codegen/tests/code_gen_tests.rs -assertion_line: 1989 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@THREE = unnamed_addr constant i16 3 -@ZERO = unnamed_addr constant i16 0 -@LEN = unnamed_addr constant i16 9 -@x = global [10 x i16] zeroinitializer -@y = global [11 x i32] zeroinitializer -@z = global [19 x i8] zeroinitializer -@zz = global [100 x i8] zeroinitializer -@zzz = global [10 x [8 x i8]] zeroinitializer - +@THREE = unnamed_addr constant i16 3, section "var-$RUSTY$THREE:i16" +@ZERO = unnamed_addr constant i16 0, section "var-$RUSTY$ZERO:i16" +@LEN = unnamed_addr constant i16 9, section "var-$RUSTY$LEN:i16" +@x = global [10 x i16] zeroinitializer, section "var-$RUSTY$x:ai16" +@y = global [11 x i32] zeroinitializer, section "var-$RUSTY$y:ai32" +@z = global [19 x i8] zeroinitializer, section "var-$RUSTY$z:au8" +@zz = global [100 x i8] zeroinitializer, section "var-$RUSTY$zz:au8" +@zzz = global [10 x [8 x i8]] zeroinitializer, section "var-$RUSTY$zzz:aau8" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__basic_datatypes_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__basic_datatypes_generated.snap index bfa2c326410..5936e502fda 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__basic_datatypes_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__basic_datatypes_generated.snap @@ -1,23 +1,20 @@ --- source: src/codegen/tests/code_gen_tests.rs -assertion_line: 2224 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@bool_1 = global i8 0 -@byte_2 = global i8 0 -@sint_3 = global i8 0 -@usint_4 = global i8 0 -@word_5 = global i16 0 -@int_6 = global i16 0 -@uint_7 = global i16 0 -@dword_8 = global i32 0 -@dint_9 = global i32 0 -@udint_10 = global i32 0 -@lword_11 = global i64 0 -@lint_12 = global i64 0 -@ulint_13 = global i64 0 - +@bool_1 = global i8 0, section "var-$RUSTY$bool_1:u8" +@byte_2 = global i8 0, section "var-$RUSTY$byte_2:u8" +@sint_3 = global i8 0, section "var-$RUSTY$sint_3:i8" +@usint_4 = global i8 0, section "var-$RUSTY$usint_4:u8" +@word_5 = global i16 0, section "var-$RUSTY$word_5:u16" +@int_6 = global i16 0, section "var-$RUSTY$int_6:i16" +@uint_7 = global i16 0, section "var-$RUSTY$uint_7:u16" +@dword_8 = global i32 0, section "var-$RUSTY$dword_8:u32" +@dint_9 = global i32 0, section "var-$RUSTY$dint_9:i32" +@udint_10 = global i32 0, section "var-$RUSTY$udint_10:u32" +@lword_11 = global i64 0, section "var-$RUSTY$lword_11:u64" +@lint_12 = global i64 0, section "var-$RUSTY$lint_12:i64" +@ulint_13 = global i64 0, section "var-$RUSTY$ulint_13:u64" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_constant_expressions_in_case_selectors.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_constant_expressions_in_case_selectors.snap index e527800ea1e..52ff058371e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_constant_expressions_in_case_selectors.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_constant_expressions_in_case_selectors.snap @@ -5,11 +5,11 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@FORWARD = unnamed_addr constant i32 7 -@UP = unnamed_addr constant i32 8 -@DOWN = unnamed_addr constant i32 15 +@FORWARD = unnamed_addr constant i32 7, section "var-$RUSTY$FORWARD:i32" +@UP = unnamed_addr constant i32 8, section "var-$RUSTY$UP:i32" +@DOWN = unnamed_addr constant i32 15, section "var-$RUSTY$DOWN:i32" -define i32 @drive() section "fn-drive:i32" { +define i32 @drive() section "fn-$RUSTY$drive:i32" { entry: %drive = alloca i32, align 4 %input = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_enum_expressions_in_case_selectors.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_enum_expressions_in_case_selectors.snap index 5588e2370f6..c92e8dcee53 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_enum_expressions_in_case_selectors.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_enum_expressions_in_case_selectors.snap @@ -5,12 +5,12 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@BASE = unnamed_addr constant i32 7 -@Direction.FORWARD = unnamed_addr constant i32 7 -@Direction.UP = unnamed_addr constant i32 8 -@Direction.DOWN = unnamed_addr constant i32 28 +@BASE = unnamed_addr constant i32 7, section "var-$RUSTY$BASE:i32" +@Direction.FORWARD = unnamed_addr constant i32 7, section "var-$RUSTY$FORWARD:e3i32" +@Direction.UP = unnamed_addr constant i32 8, section "var-$RUSTY$UP:e3i32" +@Direction.DOWN = unnamed_addr constant i32 28, section "var-$RUSTY$DOWN:e3i32" -define i32 @drive() section "fn-drive:i32" { +define i32 @drive() section "fn-$RUSTY$drive:i32" { entry: %drive = alloca i32, align 4 %input = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_multiple_labels_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_multiple_labels_statement.snap index 75209200609..55a652984bf 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_multiple_labels_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_multiple_labels_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_ranges_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_ranges_statement.snap index 58fe060d197..3d517cb7c7f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_ranges_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__case_with_ranges_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_bool_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_bool_code_gen_test.snap index b84a0b5054d..225e7ac1cc1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_bool_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_bool_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i8 1, i8* %z, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_code_gen_test.snap index 55408b7bd88..8e7ce4e7efe 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i16i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_code_gen_test.snap index e7a4f21bb4c..58b69425f35 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i16i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_ints_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_ints_code_gen_test.snap index 3a57568ae38..0d6aa79303e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_ints_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_hex_ints_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 -1, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_lreal_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_lreal_code_gen_test.snap index 2468140ebe1..3c7fb322309 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_lreal_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_lreal_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_real_code_gen_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_real_code_gen_test.snap index 846e5eedf5e..0da2859836e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_real_code_gen_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__casted_literals_real_code_gen_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i16f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_member_access_from_method.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_member_access_from_method.snap index 90e79736909..013bcce3592 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_member_access_from_method.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_member_access_from_method.snap @@ -8,16 +8,16 @@ source_filename = "main" %MyClass = type { i16, i16 } %MyClass.testMethod = type { i16, i16 } -@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer +@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer, section "var-$RUSTY$__MyClass__init:r2i16i16" -define void @MyClass(%MyClass* %0) section "fn-MyClass:v" { +define void @MyClass(%MyClass* %0) section "fn-$RUSTY$MyClass:v" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 ret void } -define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-MyClass.testMethod:v[i16]" { +define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-$RUSTY$MyClass.testMethod:v[i16]" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_method_in_pou.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_method_in_pou.snap index 3c0ea0e41ce..b6d4db0881b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_method_in_pou.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__class_method_in_pou.snap @@ -9,17 +9,17 @@ source_filename = "main" %prg = type { %MyClass, i16 } %MyClass.testMethod = type { i16, i16 } -@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer -@prg_instance = global %prg zeroinitializer +@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer, section "var-$RUSTY$__MyClass__init:r2i16i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2r2i16i16i16" -define void @MyClass(%MyClass* %0) section "fn-MyClass:v" { +define void @MyClass(%MyClass* %0) section "fn-$RUSTY$MyClass:v" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 ret void } -define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-MyClass.testMethod:v[i16]" { +define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-$RUSTY$MyClass.testMethod:v[i16]" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 @@ -38,7 +38,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %cl = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__complex_pointers.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__complex_pointers.snap index 9ad5dd85ed6..0d9e5429060 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__complex_pointers.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__complex_pointers.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, [10 x i16], [10 x i16*], [10 x i16]* } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i16ai16api16pai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %X = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %arrX = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expression_in_function_blocks_are_propagated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expression_in_function_blocks_are_propagated.snap index 1942b71c28c..6cd81f4e4b7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expression_in_function_blocks_are_propagated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expression_in_function_blocks_are_propagated.snap @@ -7,9 +7,9 @@ source_filename = "main" %fbWithConstant = type { i16, i16 } -@__fbWithConstant__init = unnamed_addr constant %fbWithConstant { i16 0, i16 2 } +@__fbWithConstant__init = unnamed_addr constant %fbWithConstant { i16 0, i16 2 }, section "var-$RUSTY$__fbWithConstant__init:r2i16i16" -define void @fbWithConstant(%fbWithConstant* %0) section "fn-fbWithConstant:v" { +define void @fbWithConstant(%fbWithConstant* %0) section "fn-$RUSTY$fbWithConstant:v" { entry: %x = getelementptr inbounds %fbWithConstant, %fbWithConstant* %0, i32 0, i32 0 %const = getelementptr inbounds %fbWithConstant, %fbWithConstant* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expressions_in_ranged_type_declaration_are_propagated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expressions_in_ranged_type_declaration_are_propagated.snap index a018dd2f695..f1184db8de6 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expressions_in_ranged_type_declaration_are_propagated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_expressions_in_ranged_type_declaration_are_propagated.snap @@ -7,10 +7,10 @@ source_filename = "main" %prg = type { i16 } -@MIN = unnamed_addr constant i16 7 -@prg_instance = global %prg zeroinitializer +@MIN = unnamed_addr constant i16 7, section "var-$RUSTY$MIN:i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i16" -define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-CheckRangeSigned:i16[i16][i16][i16]" { +define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-$RUSTY$CheckRangeSigned:i16[i16][i16][i16]" { entry: %CheckRangeSigned = alloca i16, align 2 %value = alloca i16, align 2 @@ -26,7 +26,7 @@ entry: ret i16 %CheckRangeSigned_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i16 @CheckRangeSigned(i16 5, i16 0, i16 8) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_propagation_of_struct_fields_on_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_propagation_of_struct_fields_on_assignment.snap index 5e0d5cda0ce..2bed0e81abb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_propagation_of_struct_fields_on_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__constant_propagation_of_struct_fields_on_assignment.snap @@ -7,10 +7,10 @@ source_filename = "main" %STRUCT1 = type { i32 } -@MyStruct = unnamed_addr constant %STRUCT1 { i32 99 } -@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer +@MyStruct = unnamed_addr constant %STRUCT1 { i32 99 }, section "var-$RUSTY$MyStruct:r1i32" +@__STRUCT1__init = unnamed_addr constant %STRUCT1 zeroinitializer, section "var-$RUSTY$__STRUCT1__init:r1i32" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %local_value = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__contants_in_case_statements_resolved.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__contants_in_case_statements_resolved.snap index f922abe4168..41d5a82ad48 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__contants_in_case_statements_resolved.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__contants_in_case_statements_resolved.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32 } -@main_instance = global %main { i32 0, i32 60 } +@main_instance = global %main { i32 0, i32 60 }, section "var-$RUSTY$main_instance:r2i32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %DAYS_IN_MONTH = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %SIXTY = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_addition_in_var_output.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_addition_in_var_output.snap index 44f3117f1b3..3b0fa08f841 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_addition_in_var_output.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_addition_in_var_output.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @func(i64* %0, i64* %1) section "fn-func:i32[pi64][pi64]" { +define i32 @func(i64* %0, i64* %1) section "fn-$RUSTY$func:i32[pi64][pi64]" { entry: %func = alloca i32, align 4 %d_and_t = alloca i64*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_global_constants_initialize.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_global_constants_initialize.snap index 9c46fc7beea..55a96725a2c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_global_constants_initialize.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_and_time_global_constants_initialize.snap @@ -7,25 +7,25 @@ source_filename = "main" %main = type {} -@cT = unnamed_addr constant i64 1000000000 -@cT_SHORT = unnamed_addr constant i64 1000000000 -@cLT = unnamed_addr constant i64 1000000000000 -@cLT_SHORT = unnamed_addr constant i64 1000000000000 -@cD = unnamed_addr constant i64 0 -@cD_SHORT = unnamed_addr constant i64 161308800000000000 -@cLD = unnamed_addr constant i64 161308800000000000 -@cLD_SHORT = unnamed_addr constant i64 161308800000000000 -@cTOD = unnamed_addr constant i64 0 -@cTOD_SHORT = unnamed_addr constant i64 0 -@cLTOD = unnamed_addr constant i64 86399999999999 -@cLTOD_SHORT = unnamed_addr constant i64 86399999999999 -@cDT = unnamed_addr constant i64 172799000000000 -@cDT_SHORT = unnamed_addr constant i64 172799000000000 -@cLDT = unnamed_addr constant i64 172799123000000 -@cLDT_SHORT = unnamed_addr constant i64 172799123000000 -@main_instance = global %main zeroinitializer +@cT = unnamed_addr constant i64 1000000000, section "var-$RUSTY$cT:i64" +@cT_SHORT = unnamed_addr constant i64 1000000000, section "var-$RUSTY$cT_SHORT:i64" +@cLT = unnamed_addr constant i64 1000000000000, section "var-$RUSTY$cLT:i64" +@cLT_SHORT = unnamed_addr constant i64 1000000000000, section "var-$RUSTY$cLT_SHORT:i64" +@cD = unnamed_addr constant i64 0, section "var-$RUSTY$cD:i64" +@cD_SHORT = unnamed_addr constant i64 161308800000000000, section "var-$RUSTY$cD_SHORT:i64" +@cLD = unnamed_addr constant i64 161308800000000000, section "var-$RUSTY$cLD:i64" +@cLD_SHORT = unnamed_addr constant i64 161308800000000000, section "var-$RUSTY$cLD_SHORT:i64" +@cTOD = unnamed_addr constant i64 0, section "var-$RUSTY$cTOD:i64" +@cTOD_SHORT = unnamed_addr constant i64 0, section "var-$RUSTY$cTOD_SHORT:i64" +@cLTOD = unnamed_addr constant i64 86399999999999, section "var-$RUSTY$cLTOD:i64" +@cLTOD_SHORT = unnamed_addr constant i64 86399999999999, section "var-$RUSTY$cLTOD_SHORT:i64" +@cDT = unnamed_addr constant i64 172799000000000, section "var-$RUSTY$cDT:i64" +@cDT_SHORT = unnamed_addr constant i64 172799000000000, section "var-$RUSTY$cDT_SHORT:i64" +@cLDT = unnamed_addr constant i64 172799123000000, section "var-$RUSTY$cLDT:i64" +@cLDT_SHORT = unnamed_addr constant i64 172799123000000, section "var-$RUSTY$cLDT_SHORT:i64" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r16i64i64i64i64i64i64i64i64i64i64i64i64i64i64i64i64" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %t1 = alloca i64, align 8 %t2 = alloca i64, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_comparisons.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_comparisons.snap index b8f8ee1f3d4..b01ef6be320 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_comparisons.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__date_comparisons.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64, i64, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i64i64i64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__default_values_for_not_initialized_function_vars.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__default_values_for_not_initialized_function_vars.snap index 8adc6947eff..6accb260f68 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__default_values_for_not_initialized_function_vars.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__default_values_for_not_initialized_function_vars.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @func() section "fn-func:i16" { +define i16 @func() section "fn-$RUSTY$func:i16" { entry: %func = alloca i16, align 2 %int_var = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__different_case_references.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__different_case_references.snap index 714f7af5895..55c7afa92fa 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__different_case_references.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__different_case_references.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16, i32 } -@prg_instance = global %prg { i16 0, i16 1, i32 2 } +@prg_instance = global %prg { i16 0, i16 1, i32 2 }, section "var-$RUSTY$prg_instance:r3i16i16i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_function_with_name_generates_int_function.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_function_with_name_generates_int_function.snap index 644374ab5a0..1d50aaf7097 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_function_with_name_generates_int_function.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_function_with_name_generates_int_function.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @foo() section "fn-foo:i16" { +define i16 @foo() section "fn-$RUSTY$foo:i16" { entry: %foo = alloca i16, align 2 store i16 0, i16* %foo, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_global_variable_list_generates_nothing.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_global_variable_list_generates_nothing.snap index 687716fc304..58ead4ad4c7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_global_variable_list_generates_nothing.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_global_variable_list_generates_nothing.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_program_with_name_generates_void_function.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_program_with_name_generates_void_function.snap index 8518c00c821..cc9d1a042be 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_program_with_name_generates_void_function.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_program_with_name_generates_void_function.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_statements_dont_generate_anything.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_statements_dont_generate_anything.snap index 8e502d81c9b..45c105a08d4 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_statements_dont_generate_anything.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__empty_statements_dont_generate_anything.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enum_members_can_be_used_in_asignments.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enum_members_can_be_used_in_asignments.snap index aa2572299d3..ef1c55f2b2f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enum_members_can_be_used_in_asignments.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enum_members_can_be_used_in_asignments.snap @@ -7,12 +7,12 @@ source_filename = "main" %main = type { i32 } -@main_instance = global %main zeroinitializer -@MyEnum.red = unnamed_addr constant i32 0 -@MyEnum.yellow = unnamed_addr constant i32 1 -@MyEnum.green = unnamed_addr constant i32 2 +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1e3i32" +@MyEnum.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" +@MyEnum.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" +@MyEnum.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %color = getelementptr inbounds %main, %main* %0, i32 0, i32 0 store i32 0, i32* %color, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_are_generated.snap index 0abe1ca826f..057b3adc4da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_are_generated.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@x = global i32 0 -@MyEnum.red = unnamed_addr constant i32 0 -@MyEnum.yellow = unnamed_addr constant i32 1 -@MyEnum.green = unnamed_addr constant i32 2 +@x = global i32 0, section "var-$RUSTY$x:e3i32" +@MyEnum.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" +@MyEnum.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" +@MyEnum.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_custom_type_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_custom_type_are_generated.snap index e0d826b4519..bd82fedca37 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_custom_type_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__enums_custom_type_are_generated.snap @@ -7,13 +7,13 @@ source_filename = "main" %main = type { i32 } -@main_instance = global %main zeroinitializer -@TrafficLight.White = unnamed_addr constant i32 0 -@TrafficLight.Red = unnamed_addr constant i32 1 -@TrafficLight.Yellow = unnamed_addr constant i32 2 -@TrafficLight.Green = unnamed_addr constant i32 3 +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1e4i32" +@TrafficLight.White = unnamed_addr constant i32 0, section "var-$RUSTY$White:e4i32" +@TrafficLight.Red = unnamed_addr constant i32 1, section "var-$RUSTY$Red:e4i32" +@TrafficLight.Yellow = unnamed_addr constant i32 2, section "var-$RUSTY$Yellow:e4i32" +@TrafficLight.Green = unnamed_addr constant i32 3, section "var-$RUSTY$Green:e4i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %tf1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__expression_list_as_array_initilization.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__expression_list_as_array_initilization.snap index 74e64e517a1..dc31c6e4534 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__expression_list_as_array_initilization.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__expression_list_as_array_initilization.snap @@ -1,13 +1,10 @@ --- source: src/codegen/tests/code_gen_tests.rs -assertion_line: 2719 expression: result - --- ; ModuleID = 'main' source_filename = "main" -@arr = global [4 x i16] [i16 1, i16 2, i16 3, i16 0] -@b_exp = global [5 x i32] [i32 4, i32 6, i32 6, i32 10, i32 0] -@str = global [3 x [81 x i8]] [[81 x i8] c"first\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] c"second\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] zeroinitializer] - +@arr = global [4 x i16] [i16 1, i16 2, i16 3, i16 0], section "var-$RUSTY$arr:ai16" +@b_exp = global [5 x i32] [i32 4, i32 6, i32 6, i32 10, i32 0], section "var-$RUSTY$b_exp:ai32" +@str = global [3 x [81 x i8]] [[81 x i8] c"first\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] c"second\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [81 x i8] zeroinitializer], section "var-$RUSTY$str:as8u81" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_function_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_function_called_in_program.snap index cccc8d51d2e..6fc1325f79e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_function_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_function_called_in_program.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -declare i32 @foo() section "fn-foo:i32" +declare i32 @foo() section "fn-$RUSTY$foo:i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %call = call i32 @foo() ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_global_variable_generates_as_external.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_global_variable_generates_as_external.snap index f1e2407e55a..b7e06b1f739 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_global_variable_generates_as_external.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_global_variable_generates_as_external.snap @@ -7,11 +7,11 @@ source_filename = "main" %main = type {} -@gX = external global i16 -@gY = external global i8 -@main_instance = global %main zeroinitializer +@gX = external global i16, section "var-$RUSTY$gX:i16" +@gY = external global i8, section "var-$RUSTY$gY:u8" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_program_global_var_is_external.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_program_global_var_is_external.snap index 36e7bbb9af5..d9521f41def 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_program_global_var_is_external.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__external_program_global_var_is_external.snap @@ -7,6 +7,6 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = external global %prg +@prg_instance = external global %prg, section "var-$RUSTY$prg_instance:r2i32i32" -declare void @prg(%prg*) section "fn-prg:v" +declare void @prg(%prg*) section "fn-$RUSTY$prg:v" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__fb_method_in_pou.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__fb_method_in_pou.snap index 3c0ea0e41ce..b6d4db0881b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__fb_method_in_pou.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__fb_method_in_pou.snap @@ -9,17 +9,17 @@ source_filename = "main" %prg = type { %MyClass, i16 } %MyClass.testMethod = type { i16, i16 } -@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer -@prg_instance = global %prg zeroinitializer +@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer, section "var-$RUSTY$__MyClass__init:r2i16i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2r2i16i16i16" -define void @MyClass(%MyClass* %0) section "fn-MyClass:v" { +define void @MyClass(%MyClass* %0) section "fn-$RUSTY$MyClass:v" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 ret void } -define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-MyClass.testMethod:v[i16]" { +define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-$RUSTY$MyClass.testMethod:v[i16]" { entry: %x = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 0 %y = getelementptr inbounds %MyClass, %MyClass* %0, i32 0, i32 1 @@ -38,7 +38,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %cl = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_continue.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_continue.snap index 9158760cb76..9f414681697 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_continue.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_continue.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 3, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_int.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_int.snap index 5f745081384..2dca83f31a1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_int.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_int.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i16 3, i16* %x, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_lint.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_lint.snap index a1c90f3e7bd..0310b77ae10 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_lint.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_lint.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i64 3, i64* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_sint.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_sint.snap index fb9981f1eef..9d83bc8b7da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_sint.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_sint.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i8 3, i8* %x, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_continue.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_continue.snap index d818614e182..08569854f0a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_continue.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_continue.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 3, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_exit.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_exit.snap index 5b3736b042e..1a9a034b137 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_exit.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_exit.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 3, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_references_steps_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_references_steps_test.snap index 57bce3d6c1b..a3881483a74 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_references_steps_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_references_steps_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i32i32i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %step = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_steps_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_steps_test.snap index 84539899322..f0bb8cb4e5d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_steps_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_with_steps_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 3, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_without_steps_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_without_steps_test.snap index 5d3fac126f8..6c282954639 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_without_steps_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__for_statement_without_steps_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 3, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_instance_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_instance_call.snap index 005f6caf771..94777d2d7bb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_instance_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_instance_call.snap @@ -8,17 +8,17 @@ source_filename = "main" %foo = type { i16, i16 } %prg = type { %foo } -@__foo__init = unnamed_addr constant %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@__foo__init = unnamed_addr constant %foo zeroinitializer, section "var-$RUSTY$__foo__init:r2i16i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1r2i16i16" -define void @foo(%foo* %0) section "fn-foo:v[i16][i16]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i16][i16]" { entry: %x = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %y = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %fb_inst = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 call void @foo(%foo* %fb_inst) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_qualified_instance_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_qualified_instance_call.snap index 0b86c010d7c..72d159848b9 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_qualified_instance_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_block_qualified_instance_call.snap @@ -9,22 +9,22 @@ source_filename = "main" %bar = type {} %prg = type { %foo } -@__foo__init = unnamed_addr constant %foo zeroinitializer -@__bar__init = unnamed_addr constant %bar zeroinitializer -@prg_instance = global %prg zeroinitializer +@__foo__init = unnamed_addr constant %foo zeroinitializer, section "var-$RUSTY$__foo__init:r1r0" +@__bar__init = unnamed_addr constant %bar zeroinitializer, section "var-$RUSTY$__bar__init:r0" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1r1r0" -define void @foo(%foo* %0) section "fn-foo:v" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v" { entry: %bar_inst = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 ret void } -define void @bar(%bar* %0) section "fn-bar:v" { +define void @bar(%bar* %0) section "fn-$RUSTY$bar:v" { entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %foo_inst = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %bar_inst = getelementptr inbounds %foo, %foo* %foo_inst, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_call_with_same_name_as_return_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_call_with_same_name_as_return_type.snap index efd50eb79d6..5c36e240874 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_call_with_same_name_as_return_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_call_with_same_name_as_return_type.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define i64 @TIME() section "fn-TIME:i64" { +define i64 @TIME() section "fn-$RUSTY$TIME:i64" { entry: %TIME = alloca i64, align 8 store i64 0, i64* %TIME, align 4 @@ -17,7 +17,7 @@ entry: ret i64 %TIME_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %call = call i64 @TIME() ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_in_program.snap index e93b371d6bf..0317488398e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_in_program.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define i32 @foo() section "fn-foo:i32" { +define i32 @foo() section "fn-$RUSTY$foo:i32" { entry: %foo = alloca i32, align 4 store i32 0, i32* %foo, align 4 @@ -18,7 +18,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i32 @foo() diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_when_shadowed.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_when_shadowed.snap index d799007060a..87f13d62a35 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_when_shadowed.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_called_when_shadowed.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define i32 @foo() section "fn-foo:i32" { +define i32 @foo() section "fn-$RUSTY$foo:i32" { entry: %foo = alloca i32, align 4 store i32 0, i32* %foo, align 4 @@ -18,7 +18,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %froo = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i32 @foo() diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_temp_var_initialization.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_temp_var_initialization.snap index e64407254dd..e37a94c26f5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_temp_var_initialization.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_temp_var_initialization.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" { entry: %foo = alloca i32, align 4 %in1 = alloca i32, align 4 @@ -30,7 +30,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %call = call i32 @foo(i32 5) ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_var_initialization_and_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_var_initialization_and_call.snap index 502da9643cc..0339a12c6b1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_var_initialization_and_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_local_var_initialization_and_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" { entry: %foo = alloca i32, align 4 %in1 = alloca i32, align 4 @@ -26,7 +26,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %call = call i32 @foo(i32 5) ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_parameters_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_parameters_called_in_program.snap index 25d554785cb..9746527493a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_parameters_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_parameters_called_in_program.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" { entry: %foo = alloca i32, align 4 %bar = alloca i32, align 4 @@ -20,7 +20,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i32 @foo(i32 2) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_two_parameters_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_two_parameters_called_in_program.snap index c2071bde992..983140bb995 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_two_parameters_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__function_with_two_parameters_called_in_program.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define i32 @foo(i32 %0, i8 %1) section "fn-foo:i32[i32][u8]" { +define i32 @foo(i32 %0, i8 %1) section "fn-$RUSTY$foo:i32[i32][u8]" { entry: %foo = alloca i32, align 4 %bar = alloca i32, align 4 @@ -22,7 +22,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i32 @foo(i32 2, i8 1) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__global_variable_reference_is_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__global_variable_reference_is_generated.snap index a86223b3fd6..7ae048cffcf 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__global_variable_reference_is_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__global_variable_reference_is_generated.snap @@ -7,10 +7,10 @@ source_filename = "main" %prg = type { i16 } -@gX = global i16 0 -@prg_instance = global %prg zeroinitializer +@gX = global i16 0, section "var-$RUSTY$gX:i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i16 20, i16* @gX, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_elsif_else_generator_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_elsif_else_generator_test.snap index 98ed4b0730e..23df0bcab41 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_elsif_else_generator_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_elsif_else_generator_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32, i32, i32, i8, i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r7i32i32i32i32u8u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_generator_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_generator_test.snap index e65bc548b99..a824d5337e5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_generator_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_generator_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b1 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_with_expression_generator_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_with_expression_generator_test.snap index b12b4c415c7..e49be94e85b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_with_expression_generator_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__if_with_expression_generator_test.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b1 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_enums_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_enums_are_generated.snap index 4871a67eca0..a69798fd140 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_enums_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_enums_are_generated.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@x = global i32 0 -@__global_x.red = unnamed_addr constant i32 0 -@__global_x.yellow = unnamed_addr constant i32 1 -@__global_x.green = unnamed_addr constant i32 2 +@x = global i32 0, section "var-$RUSTY$x:e3i32" +@__global_x.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" +@__global_x.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" +@__global_x.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_structs_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_structs_are_generated.snap index 342b6acc449..5637181171a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_structs_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inline_structs_are_generated.snap @@ -7,6 +7,5 @@ source_filename = "main" %__global_x = type { i32, i32 } -@x = global %__global_x zeroinitializer -@____global_x__init = unnamed_addr constant %__global_x zeroinitializer - +@x = global %__global_x zeroinitializer, section "var-$RUSTY$x:r2i32i32" +@____global_x__init = unnamed_addr constant %__global_x zeroinitializer, section "var-$RUSTY$____global_x__init:r2i32i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inlined_array_size_from_local_scoped_constants.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inlined_array_size_from_local_scoped_constants.snap index cd41db2ea36..53cc42de783 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inlined_array_size_from_local_scoped_constants.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__inlined_array_size_from_local_scoped_constants.snap @@ -7,12 +7,12 @@ source_filename = "main" %aaa = type { i16, i16, [5 x i8], [3 x i8] } -@a = unnamed_addr constant i16 0 -@b = unnamed_addr constant i16 2 -@c = unnamed_addr constant i16 5 -@aaa_instance = global %aaa { i16 3, i16 7, [5 x i8] zeroinitializer, [3 x i8] zeroinitializer } +@a = unnamed_addr constant i16 0, section "var-$RUSTY$a:i16" +@b = unnamed_addr constant i16 2, section "var-$RUSTY$b:i16" +@c = unnamed_addr constant i16 5, section "var-$RUSTY$c:i16" +@aaa_instance = global %aaa { i16 3, i16 7, [5 x i8] zeroinitializer, [3 x i8] zeroinitializer }, section "var-$RUSTY$aaa_instance:r4i16i16au8au8" -define void @aaa(%aaa* %0) section "fn-aaa:v" { +define void @aaa(%aaa* %0) section "fn-$RUSTY$aaa:v" { entry: %a = getelementptr inbounds %aaa, %aaa* %0, i32 0, i32 0 %b = getelementptr inbounds %aaa, %aaa* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_return.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_return.snap index f0efdafb33d..87c7d9eaa1c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_return.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_return.snap @@ -8,14 +8,14 @@ source_filename = "main" %MyClass = type {} %MyClass.testMethod = type { i16 } -@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer +@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer, section "var-$RUSTY$__MyClass__init:r0" -define void @MyClass(%MyClass* %0) section "fn-MyClass:v" { +define void @MyClass(%MyClass* %0) section "fn-$RUSTY$MyClass:v" { entry: ret void } -define i16 @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-MyClass.testMethod:i16[i16]" { +define i16 @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-$RUSTY$MyClass.testMethod:i16[i16]" { entry: %myMethodArg = getelementptr inbounds %MyClass.testMethod, %MyClass.testMethod* %1, i32 0, i32 0 %testMethod = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_void.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_void.snap index 66f3b579fe6..8e9dc9ccaa1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_void.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__method_codegen_void.snap @@ -8,14 +8,14 @@ source_filename = "main" %MyClass = type {} %MyClass.testMethod = type { i16, i16 } -@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer +@__MyClass__init = unnamed_addr constant %MyClass zeroinitializer, section "var-$RUSTY$__MyClass__init:r0" -define void @MyClass(%MyClass* %0) section "fn-MyClass:v" { +define void @MyClass(%MyClass* %0) section "fn-$RUSTY$MyClass:v" { entry: ret void } -define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-MyClass.testMethod:v[i16]" { +define void @MyClass.testMethod(%MyClass* %0, %MyClass.testMethod* %1) section "fn-$RUSTY$MyClass.testMethod:v[i16]" { entry: %myMethodArg = getelementptr inbounds %MyClass.testMethod, %MyClass.testMethod* %1, i32 0, i32 0 %myMethodLocalVar = getelementptr inbounds %MyClass.testMethod, %MyClass.testMethod* %1, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__min_max_real_and_lreal_values_do_not_result_in_an_under_or_overflow.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__min_max_real_and_lreal_values_do_not_result_in_an_under_or_overflow.snap index adab6e978bb..1579e045bc3 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__min_max_real_and_lreal_values_do_not_result_in_an_under_or_overflow.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__min_max_real_and_lreal_values_do_not_result_in_an_under_or_overflow.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { float, float, double, double } -@main_instance = global %main { float 0xC7EFFFFFE0000000, float 0x47EFFFFFE0000000, double 0xFFEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF } +@main_instance = global %main { float 0xC7EFFFFFE0000000, float 0x47EFFFFFE0000000, double 0xFFEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF }, section "var-$RUSTY$main_instance:r4f32f32f64f64" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %F32_MIN = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %F32_MAX = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_access.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_access.snap index b53601e5bb2..736ff837860 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_access.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_access.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [8 x i32] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %tmpVar = getelementptr inbounds [8 x i32], [8 x i32]* %x, i32 0, i32 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_declaration.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_declaration.snap index bf625744037..a234c2d4994 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_declaration.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__multidim_array_declaration.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [6 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_access.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_access.snap index c64ea740096..2c82ee55a25 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_access.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_access.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [4 x [2 x i32]] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1aai32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %tmpVar = getelementptr inbounds [4 x [2 x i32]], [4 x [2 x i32]]* %x, i32 0, i32 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes.snap index 7f655ad893a..5fb0d0ebc4b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16, i16, i16, [125 x i32] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4i16i16i16ai32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes_negative_start.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes_negative_start.snap index a742dd204b3..03487be8279 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes_negative_start.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_cube_writes_negative_start.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16, i16, i16, [125 x i32] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4i16i16i16ai32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_declaration.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_declaration.snap index da38870f591..da7ea64ee9f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_declaration.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_array_declaration.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [3 x [2 x i16]] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1aai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_function_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_function_called_in_program.snap index 2b7d27f1de2..ca091a63ba1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_function_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__nested_function_called_in_program.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define i32 @bar() section "fn-bar:i32" { +define i32 @bar() section "fn-$RUSTY$bar:i32" { entry: %bar = alloca i32, align 4 store i32 0, i32* %bar, align 4 @@ -18,7 +18,7 @@ entry: ret i32 %bar_ret } -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" { entry: %foo = alloca i32, align 4 %in = alloca i32, align 4 @@ -29,7 +29,7 @@ entry: ret i32 %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call i32 @bar() diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__order_var_and_var_temp_block.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__order_var_and_var_temp_block.snap index 97a090218c3..92306239443 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__order_var_and_var_temp_block.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__order_var_and_var_temp_block.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2i16i16" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %temp = alloca i16, align 2 %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pass_inout_to_inout.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pass_inout_to_inout.snap index 8e515413218..a8e6b32c9ff 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pass_inout_to_inout.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pass_inout_to_inout.snap @@ -9,18 +9,18 @@ source_filename = "main" %foo = type { i32* } %prg = type { i32 } -@foo2_instance = global %foo2 zeroinitializer -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo2_instance = global %foo2 zeroinitializer, section "var-$RUSTY$foo2_instance:r2pi32i32" +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r1pi32" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @foo2(%foo2* %0) section "fn-foo2:v[pi32][i32]" { +define void @foo2(%foo2* %0) section "fn-$RUSTY$foo2:v[pi32][i32]" { entry: %inout = getelementptr inbounds %foo2, %foo2* %0, i32 0, i32 0 %in = getelementptr inbounds %foo2, %foo2* %0, i32 0, i32 1 ret void } -define void @foo(%foo* %0) section "fn-foo:v[pi32]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[pi32]" { entry: %inout = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %deref = load i32*, i32** %inout, align 8 @@ -32,7 +32,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %baz = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32* %baz, i32** getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointer_and_array_access_to_in_out.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointer_and_array_access_to_in_out.snap index 8bc8d5535dc..02c169bf672 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointer_and_array_access_to_in_out.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointer_and_array_access_to_in_out.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @main(i16** %0, i16* %1) section "fn-main:i16[ppi16][pv]" { +define i16 @main(i16** %0, i16* %1) section "fn-$RUSTY$main:i16[ppi16][pai16]" { entry: %main = alloca i16, align 2 %a = alloca i16**, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointers_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointers_generated.snap index 3f57f25b8da..cd9516d4a52 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointers_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__pointers_generated.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8*, i8* } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8pu8pu8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %X = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %pX = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_called_in_program.snap index 560393369b8..29ad582599f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_called_in_program.snap @@ -8,15 +8,15 @@ source_filename = "main" %foo = type {} %prg = type {} -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r0" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define void @foo(%foo* %0) section "fn-foo:v" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v" { entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: call void @foo(%foo* @foo_instance) ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_and_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_and_statement.snap index e361bbf28cb..7b0f68c8dcb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_and_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_and_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_bool_variables_and_references_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_bool_variables_and_references_generates_void_function_and_struct_and_body.snap index 56448021c18..8597d9c3276 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_bool_variables_and_references_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_bool_variables_and_references_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_boolean_assignment_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_boolean_assignment_generates_void_function_and_struct_and_body.snap index c003aa79699..0056daf87ef 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_boolean_assignment_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_boolean_assignment_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i8 1, i8* %y, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_casted_chars_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_casted_chars_assignment.snap index 4cb7a5f58a2..80a0e3ea47f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_casted_chars_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_casted_chars_assignment.snap @@ -7,11 +7,11 @@ source_filename = "main" %mainPROG = type { i8, i16 } -@mainPROG_instance = global %mainPROG zeroinitializer +@mainPROG_instance = global %mainPROG zeroinitializer, section "var-$RUSTY$mainPROG_instance:r2u8u16" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"B\00" @utf16_literal_0 = private unnamed_addr constant [2 x i16] [i16 65, i16 0] -define void @mainPROG(%mainPROG* %0) section "fn-mainPROG:v" { +define void @mainPROG(%mainPROG* %0) section "fn-$RUSTY$mainPROG:v" { entry: %x = getelementptr inbounds %mainPROG, %mainPROG* %0, i32 0, i32 0 %y = getelementptr inbounds %mainPROG, %mainPROG* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_chars.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_chars.snap index a4c73f6983b..bcd7ca81bca 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_chars.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_chars.snap @@ -7,7 +7,7 @@ source_filename = "main" %mainPROG = type { i8, i16 } -@mainPROG_instance = global %mainPROG zeroinitializer +@mainPROG_instance = global %mainPROG zeroinitializer, section "var-$RUSTY$mainPROG_instance:r2u8u16" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c" \00" @utf08_literal_1 = private unnamed_addr constant [2 x i8] c"a\00" @utf16_literal_0 = private unnamed_addr constant [2 x i16] [i16 32, i16 0] @@ -15,7 +15,7 @@ source_filename = "main" @utf16_literal_2 = private unnamed_addr constant [2 x i16] [i16 39, i16 0] @utf16_literal_3 = private unnamed_addr constant [2 x i16] [i16 65, i16 0] -define void @mainPROG(%mainPROG* %0) section "fn-mainPROG:v" { +define void @mainPROG(%mainPROG* %0) section "fn-$RUSTY$mainPROG:v" { entry: %x = getelementptr inbounds %mainPROG, %mainPROG* %0, i32 0, i32 0 %y = getelementptr inbounds %mainPROG, %mainPROG* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment.snap index 8bbb51edf7e..3fd53113a8f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64, i64, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i64i64i64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %w = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment_whit_short_datatype_names.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment_whit_short_datatype_names.snap index 0ce71bca5bb..e481318994d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment_whit_short_datatype_names.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_date_assignment_whit_short_datatype_names.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64, i64, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i64i64i64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %w = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_floats_variable_and_comparison_assignment_generates_correctly.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_floats_variable_and_comparison_assignment_generates_correctly.snap index 9b6672b871b..6247fa9ea4a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_floats_variable_and_comparison_assignment_generates_correctly.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_floats_variable_and_comparison_assignment_generates_correctly.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_local_temp_var_initialization.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_local_temp_var_initialization.snap index b5460fdea60..aadb49f9e3e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_local_temp_var_initialization.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_local_temp_var_initialization.snap @@ -8,10 +8,10 @@ source_filename = "main" %foo = type { i16 } %prg = type {} -@foo_instance = global %foo { i16 7 } -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo { i16 7 }, section "var-$RUSTY$foo_instance:r3i16i16i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define void @foo(%foo* %0) section "fn-foo:v" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v" { entry: %x = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %y = alloca i16, align 2 @@ -26,7 +26,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: call void @foo(%foo* @foo_instance) ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_long_date_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_long_date_assignment.snap index 6e14b94318f..6ddd1200b11 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_long_date_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_long_date_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64, i64, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4i64i64i64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %w = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_combined_expressions_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_combined_expressions_generates_void_function_and_struct_and_body.snap index a3a65b3cae3..54552d47b50 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_combined_expressions_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_combined_expressions_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_expressions_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_expressions_generates_void_function_and_struct_and_body.snap index 7f36c862247..a0ee38c4451 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_expressions_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_negated_expressions_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_or_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_or_statement.snap index ad31cb1492f..6529671a52c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_or_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_or_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_additions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_additions.snap index dff1485346e..ff2e14ca7eb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_additions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_additions.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, float, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3f32f32f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_assignment.snap index 07eb3ab7797..4b50d7ee453 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store float 1.562500e-01, float* %y, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_cast_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_cast_assignment.snap index 314b9c196d4..6e4363b5f17 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_cast_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_real_cast_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_signed_combined_expressions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_signed_combined_expressions.snap index e6fb6122b99..59a354dd178 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_signed_combined_expressions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_signed_combined_expressions.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_special_chars_in_string.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_special_chars_in_string.snap index 4f24fceac15..662befc1eac 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_special_chars_in_string.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_special_chars_in_string.snap @@ -7,13 +7,13 @@ source_filename = "main" %prg = type { [81 x i8], [81 x i8], [81 x i16], [81 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4s8u81s8u81s16u81s16u81" @utf08_literal_0 = private unnamed_addr constant [19 x i8] c"\0043 $\22no replace$\22\00" @utf08_literal_1 = private unnamed_addr constant [41 x i8] c"a\0A\0A b\0A\0A c\0C\0C d\0D\0D e\09\09 $ 'single' W\F0\9F\92\96\F0\9F\92\96\00" @utf16_literal_0 = private unnamed_addr constant [19 x i16] [i16 36, i16 52, i16 51, i16 32, i16 36, i16 39, i16 110, i16 111, i16 32, i16 114, i16 101, i16 112, i16 108, i16 97, i16 99, i16 101, i16 36, i16 39, i16 0] @utf16_literal_1 = private unnamed_addr constant [41 x i16] [i16 97, i16 10, i16 10, i16 32, i16 98, i16 10, i16 10, i16 32, i16 99, i16 12, i16 12, i16 32, i16 100, i16 13, i16 13, i16 32, i16 101, i16 9, i16 9, i16 32, i16 36, i16 32, i16 34, i16 100, i16 111, i16 117, i16 98, i16 108, i16 101, i16 34, i16 32, i16 87, i16 -10179, i16 -9066, i16 -10179, i16 -9066, i16 0, i16 0, i16 0, i16 0, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %should_replace_s = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %should_not_replace_s = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_string_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_string_assignment.snap index 2e9650b3f9f..cde09cf13e2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_string_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_string_assignment.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { [81 x i8], [81 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u81s16u81" @utf08_literal_0 = private unnamed_addr constant [12 x i8] c"im a genius\00" @utf16_literal_0 = private unnamed_addr constant [18 x i16] [i16 105, i16 109, i16 32, i16 97, i16 32, i16 117, i16 116, i16 102, i16 49, i16 54, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_assignment.snap index eefda5d4f54..7af52c8f382 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i64 0, i64* %y, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_of_day_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_of_day_assignment.snap index 0e15ee7c805..148f498e94b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_of_day_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_time_of_day_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i64 0, i64* %y, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_explicit_parameters_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_explicit_parameters_called_in_program.snap index bbbe1085558..eeacbb46c4a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_explicit_parameters_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_explicit_parameters_called_in_program.snap @@ -8,17 +8,17 @@ source_filename = "main" %foo = type { i32, i8 } %prg = type {} -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r2i32u8" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define void @foo(%foo* %0) section "fn-foo:v[i32][u8]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i32][u8]" { entry: %bar = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %buz = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: store i8 1, i8* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 1), align 1 store i32 2, i32* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_parameters_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_parameters_called_in_program.snap index e12d9f1dad2..af00d4d3f0d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_parameters_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_two_parameters_called_in_program.snap @@ -8,17 +8,17 @@ source_filename = "main" %foo = type { i32, i8 } %prg = type {} -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r2i32u8" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r0" -define void @foo(%foo* %0) section "fn-foo:v[i32][u8]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i32][u8]" { entry: %bar = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %buz = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: store i32 2, i32* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 4 store i8 1, i8* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 1), align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_inout_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_inout_called_in_program.snap index ccaeba9880c..d533f19db95 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_inout_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_inout_called_in_program.snap @@ -8,10 +8,10 @@ source_filename = "main" %foo = type { i32* } %prg = type { i32 } -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r1pi32" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @foo(%foo* %0) section "fn-foo:v[pi32]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[pi32]" { entry: %inout = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %deref = load i32*, i32** %inout, align 8 @@ -22,7 +22,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %baz = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 7, i32* %baz, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_in_program.snap index ffb7db7441e..cc8392f4360 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_in_program.snap @@ -8,17 +8,17 @@ source_filename = "main" %foo = type { i32, i8 } %prg = type { i8 } -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r2i32u8" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @foo(%foo* %0) section "fn-foo:v[i32][u8]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i32][u8]" { entry: %bar = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %buz = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %baz = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 2, i32* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_mixed_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_mixed_in_program.snap index ffb7db7441e..cc8392f4360 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_mixed_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_var_out_called_mixed_in_program.snap @@ -8,17 +8,17 @@ source_filename = "main" %foo = type { i32, i8 } %prg = type { i8 } -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r2i32u8" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @foo(%foo* %0) section "fn-foo:v[i32][u8]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i32][u8]" { entry: %bar = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %buz = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %baz = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 2, i32* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_addition_literal_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_addition_literal_generates_void_function_and_struct_and_body.snap index e97814a1eae..c3a91f18e9c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_addition_literal_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_addition_literal_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %load_x = load i32, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_arithmatic_assignment_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_arithmatic_assignment_generates_void_function_and_struct_and_body.snap index 059fb284667..31f63a6092e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_arithmatic_assignment_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_arithmatic_assignment_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_comparison_assignment_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_comparison_assignment_generates_void_function_and_struct_and_body.snap index d87b270482d..5e64b1a5343 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_comparison_assignment_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_and_comparison_assignment_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_assignment_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_assignment_generates_void_function_and_struct_and_body.snap index b1684598282..d8193c60c53 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_assignment_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variable_assignment_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 7, i32* %y, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_additions_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_additions_generates_void_function_and_struct_and_body.snap index 82bb93e5630..9480d5c1e50 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_additions_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_additions_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_references_generates_void_function_and_struct_and_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_references_generates_void_function_and_struct_and_body.snap index 8e502d81c9b..45c105a08d4 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_references_generates_void_function_and_struct_and_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_and_references_generates_void_function_and_struct_and_body.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_generates_void_function_and_struct.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_generates_void_function_and_struct.snap index b7ddb4a0a75..9536961b076 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_generates_void_function_and_struct.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_variables_generates_void_function_and_struct.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_xor_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_xor_statement.snap index aec25fbc6fa..4ad950148d8 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_xor_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__program_with_xor_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_action_from_fb_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_action_from_fb_called_in_program.snap index bce25d54138..945e2bde0ae 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_action_from_fb_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_action_from_fb_called_in_program.snap @@ -8,23 +8,23 @@ source_filename = "main" %bar = type { %fb } %fb = type { i32 } -@bar_instance = global %bar zeroinitializer -@__fb__init = unnamed_addr constant %fb zeroinitializer +@bar_instance = global %bar zeroinitializer, section "var-$RUSTY$bar_instance:r1r1i32" +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r1i32" -define void @bar(%bar* %0) section "fn-bar:v" { +define void @bar(%bar* %0) section "fn-$RUSTY$bar:v" { entry: %fb_inst = getelementptr inbounds %bar, %bar* %0, i32 0, i32 0 call void @fb.foo(%fb* %fb_inst) ret void } -define void @fb(%fb* %0) section "fn-fb:v" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v" { entry: %x = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0 ret void } -define void @fb.foo(%fb* %0) section "fn-fb.foo:v" { +define void @fb.foo(%fb* %0) section "fn-$RUSTY$fb.foo:v" { entry: %x = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0 store i32 2, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_foreign_action_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_foreign_action_called_in_program.snap index 6f41a49428f..55c0eb2814c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_foreign_action_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_foreign_action_called_in_program.snap @@ -8,22 +8,22 @@ source_filename = "main" %bar = type {} %prg = type { i32 } -@bar_instance = global %bar zeroinitializer -@prg_instance = global %prg zeroinitializer +@bar_instance = global %bar zeroinitializer, section "var-$RUSTY$bar_instance:r0" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @bar(%bar* %0) section "fn-bar:v" { +define void @bar(%bar* %0) section "fn-$RUSTY$bar:v" { entry: call void @prg.foo(%prg* @prg_instance) ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void } -define void @prg.foo(%prg* %0) section "fn-prg.foo:v" { +define void @prg.foo(%prg* %0) section "fn-$RUSTY$prg.foo:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 2, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_local_action_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_local_action_called_in_program.snap index 1671c4d3273..40b9b20ea5e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_local_action_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__qualified_local_action_called_in_program.snap @@ -7,16 +7,16 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 call void @prg.foo(%prg* @prg_instance) ret void } -define void @prg.foo(%prg* %0) section "fn-prg.foo:v" { +define void @prg.foo(%prg* %0) section "fn-$RUSTY$prg.foo:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 2, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__real_function_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__real_function_called_in_program.snap index 80252a1d474..17bbea8e09e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__real_function_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__real_function_called_in_program.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define float @foo() section "fn-foo:f32" { +define float @foo() section "fn-$RUSTY$foo:f32" { entry: %foo = alloca float, align 4 store float 0.000000e+00, float* %foo, align 4 @@ -18,7 +18,7 @@ entry: ret float %foo_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %call = call float @foo() diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_qualified_name.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_qualified_name.snap index f058d9cf683..fb28f15ddfc 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_qualified_name.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_qualified_name.snap @@ -9,17 +9,17 @@ source_filename = "main" %foo = type { i32, i32, %fb } %prg = type { i32 } -@__fb__init = unnamed_addr constant %fb zeroinitializer -@foo_instance = global %foo zeroinitializer -@prg_instance = global %prg zeroinitializer +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r1i32" +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r3i32i32r1i32" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @fb(%fb* %0) section "fn-fb:v[i32]" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v[i32]" { entry: %x = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0 ret void } -define void @foo(%foo* %0) section "fn-foo:v[i32][i32][v]" { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v[i32][i32][r1i32]" { entry: %x = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %y = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 @@ -27,7 +27,7 @@ entry: ret void } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %load_x = load i32, i32* getelementptr inbounds (%foo, %foo* @foo_instance, i32 0, i32 0), align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_to_reference_assignments_in_function_arguments.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_to_reference_assignments_in_function_arguments.snap index 1a0c976fbb9..6677ce0538b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_to_reference_assignments_in_function_arguments.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__reference_to_reference_assignments_in_function_arguments.snap @@ -9,24 +9,24 @@ source_filename = "main" %prog = type { %STRUCT_params*, %STRUCT_params* } %main = type {} -@global1 = global %STRUCT_params zeroinitializer -@__STRUCT_params__init = unnamed_addr constant %STRUCT_params zeroinitializer -@global2 = global %STRUCT_params zeroinitializer -@global3 = global %STRUCT_params zeroinitializer -@global4 = global i32 0 -@global5 = global [81 x i8] zeroinitializer -@global6 = global float 0.000000e+00 -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@global1 = global %STRUCT_params zeroinitializer, section "var-$RUSTY$global1:r3u8u8u8" +@__STRUCT_params__init = unnamed_addr constant %STRUCT_params zeroinitializer, section "var-$RUSTY$__STRUCT_params__init:r3u8u8u8" +@global2 = global %STRUCT_params zeroinitializer, section "var-$RUSTY$global2:r3u8u8u8" +@global3 = global %STRUCT_params zeroinitializer, section "var-$RUSTY$global3:r3u8u8u8" +@global4 = global i32 0, section "var-$RUSTY$global4:i32" +@global5 = global [81 x i8] zeroinitializer, section "var-$RUSTY$global5:s8u81" +@global6 = global float 0.000000e+00, section "var-$RUSTY$global6:f32" +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r2pr3u8u8u8pr3u8u8u8" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @prog(%prog* %0) section "fn-prog:v[pv][pv]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[pr3u8u8u8][pr3u8u8u8]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %input2 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: store %STRUCT_params* @global1, %STRUCT_params** getelementptr inbounds (%prog, %prog* @prog_instance, i32 0, i32 0), align 8 store %STRUCT_params* @global2, %STRUCT_params** getelementptr inbounds (%prog, %prog* @prog_instance, i32 0, i32 1), align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__repeat_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__repeat_statement.snap index 7412e36a42e..eec9b3d0078 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__repeat_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__repeat_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 br label %while_body diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function.snap index c2a46131f65..c00bf980ccc 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @smaller_than_ten(i8 %0) section "fn-smaller_than_ten:i16[i8]" { +define i16 @smaller_than_ten(i8 %0) section "fn-$RUSTY$smaller_than_ten:i16[i8]" { entry: %smaller_than_ten = alloca i16, align 2 %n = alloca i8, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function_block.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function_block.snap index ae484e44b46..cb295b58858 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function_block.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__returning_early_in_function_block.snap @@ -7,9 +7,9 @@ source_filename = "main" %abcdef = type { i8 } -@__abcdef__init = unnamed_addr constant %abcdef zeroinitializer +@__abcdef__init = unnamed_addr constant %abcdef zeroinitializer, section "var-$RUSTY$__abcdef__init:r1i8" -define void @abcdef(%abcdef* %0) section "fn-abcdef:v[i8]" { +define void @abcdef(%abcdef* %0) section "fn-$RUSTY$abcdef:v[i8]" { entry: %n = getelementptr inbounds %abcdef, %abcdef* %0, i32 0, i32 0 %load_n = load i8, i8* %n, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_i8_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_i8_statement.snap index 8786736fca2..c41c610a885 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_i8_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_i8_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_statement.snap index a6e5948dee6..d789eb77214 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__simple_case_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sizeof_works_in_binary_expression_with_different_size.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sizeof_works_in_binary_expression_with_different_size.snap index 46398c63e8d..2677cbcb878 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sizeof_works_in_binary_expression_with_different_size.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sizeof_works_in_binary_expression_with_different_size.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %i = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_are_generated.snap index ca1fd4ce42c..4371bad1814 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_are_generated.snap @@ -8,8 +8,7 @@ source_filename = "main" %MyStruct = type { i32, i16 } %__global_y = type { i8, i8 } -@x = global %MyStruct zeroinitializer -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer -@y = global %__global_y zeroinitializer -@____global_y__init = unnamed_addr constant %__global_y zeroinitializer - +@x = global %MyStruct zeroinitializer, section "var-$RUSTY$x:r2i32i16" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r2i32i16" +@y = global %__global_y zeroinitializer, section "var-$RUSTY$y:r2u8u8" +@____global_y__init = unnamed_addr constant %__global_y zeroinitializer, section "var-$RUSTY$____global_y__init:r2u8u8" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_members_can_be_referenced.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_members_can_be_referenced.snap index 4333aaab90f..3e83ed11ae7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_members_can_be_referenced.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__structs_members_can_be_referenced.snap @@ -8,10 +8,10 @@ source_filename = "main" %MainProg = type { %MyStruct } %MyStruct = type { i32, i32 } -@MainProg_instance = global %MainProg zeroinitializer -@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer +@MainProg_instance = global %MainProg zeroinitializer, section "var-$RUSTY$MainProg_instance:r1r2i32i32" +@__MyStruct__init = unnamed_addr constant %MyStruct zeroinitializer, section "var-$RUSTY$__MyStruct__init:r2i32i32" -define void @MainProg(%MainProg* %0) section "fn-MainProg:v" { +define void @MainProg(%MainProg* %0) section "fn-$RUSTY$MainProg:v" { entry: %Cord = getelementptr inbounds %MainProg, %MainProg* %0, i32 0, i32 0 %a = getelementptr inbounds %MyStruct, %MyStruct* %Cord, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_check_functions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_check_functions.snap index ed77c405c09..eb3ee8488d1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_check_functions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_check_functions.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i8, i8, i8, i16, i16, i16, i32, i32, i64, i64 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r10u8i8u8u16i16u16i32u32i64u64" -define i32 @CheckRangeSigned(i32 %0, i32 %1, i32 %2) section "fn-CheckRangeSigned:i32[i32][i32][i32]" { +define i32 @CheckRangeSigned(i32 %0, i32 %1, i32 %2) section "fn-$RUSTY$CheckRangeSigned:i32[i32][i32][i32]" { entry: %CheckRangeSigned = alloca i32, align 4 %v = alloca i32, align 4 @@ -24,7 +24,7 @@ entry: ret i32 %CheckRangeSigned_ret } -define i32 @CheckRangeUnsigned(i32 %0, i32 %1, i32 %2) section "fn-CheckRangeUnsigned:u32[u32][u32][u32]" { +define i32 @CheckRangeUnsigned(i32 %0, i32 %1, i32 %2) section "fn-$RUSTY$CheckRangeUnsigned:u32[u32][u32][u32]" { entry: %CheckRangeUnsigned = alloca i32, align 4 %v = alloca i32, align 4 @@ -39,7 +39,7 @@ entry: ret i32 %CheckRangeUnsigned_ret } -define i64 @CheckLRangeSigned(i64 %0, i64 %1, i64 %2) section "fn-CheckLRangeSigned:i64[i64][i64][i64]" { +define i64 @CheckLRangeSigned(i64 %0, i64 %1, i64 %2) section "fn-$RUSTY$CheckLRangeSigned:i64[i64][i64][i64]" { entry: %CheckLRangeSigned = alloca i64, align 8 %v = alloca i64, align 8 @@ -54,7 +54,7 @@ entry: ret i64 %CheckLRangeSigned_ret } -define i64 @CheckLRangeUnsigned(i64 %0, i64 %1, i64 %2) section "fn-CheckLRangeUnsigned:u64[u64][u64][u64]" { +define i64 @CheckLRangeUnsigned(i64 %0, i64 %1, i64 %2) section "fn-$RUSTY$CheckLRangeUnsigned:u64[u64][u64][u64]" { entry: %CheckLRangeUnsigned = alloca i64, align 8 %v = alloca i64, align 8 @@ -69,7 +69,7 @@ entry: ret i64 %CheckLRangeUnsigned_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_missing.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_missing.snap index b0a81bb92d7..bc09741b3b2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_missing.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_missing.snap @@ -7,9 +7,9 @@ source_filename = "main" %Main = type { i16 } -@Main_instance = global %Main zeroinitializer +@Main_instance = global %Main zeroinitializer, section "var-$RUSTY$Main_instance:r1i16" -define i16 @Check_XX_RangeSigned(i16 %0, i16 %1, i16 %2) section "fn-Check_XX_RangeSigned:i16[i16][i16][i16]" { +define i16 @Check_XX_RangeSigned(i16 %0, i16 %1, i16 %2) section "fn-$RUSTY$Check_XX_RangeSigned:i16[i16][i16][i16]" { entry: %Check_XX_RangeSigned = alloca i16, align 2 %value = alloca i16, align 2 @@ -25,7 +25,7 @@ entry: ret i16 %Check_XX_RangeSigned_ret } -define void @Main(%Main* %0) section "fn-Main:v" { +define void @Main(%Main* %0) section "fn-$RUSTY$Main:v" { entry: %x = getelementptr inbounds %Main, %Main* %0, i32 0, i32 0 store i16 7, i16* %x, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_on_assigment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_on_assigment.snap index 2b4de87c62a..dde219b2028 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_on_assigment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__sub_range_type_calls_check_function_on_assigment.snap @@ -7,9 +7,9 @@ source_filename = "main" %Main = type { i16 } -@Main_instance = global %Main zeroinitializer +@Main_instance = global %Main zeroinitializer, section "var-$RUSTY$Main_instance:r1i16" -define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-CheckRangeSigned:i16[i16][i16][i16]" { +define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-$RUSTY$CheckRangeSigned:i16[i16][i16][i16]" { entry: %CheckRangeSigned = alloca i16, align 2 %value = alloca i16, align 2 @@ -25,7 +25,7 @@ entry: ret i16 %CheckRangeSigned_ret } -define void @Main(%Main* %0) section "fn-Main:v" { +define void @Main(%Main* %0) section "fn-$RUSTY$Main:v" { entry: %x = getelementptr inbounds %Main, %Main* %0, i32 0, i32 0 %call = call i16 @CheckRangeSigned(i16 7, i16 0, i16 100) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__time_variables_have_nano_seconds_resolution.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__time_variables_have_nano_seconds_resolution.snap index fdfbf91e842..19aa36b0dfa 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__time_variables_have_nano_seconds_resolution.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__time_variables_have_nano_seconds_resolution.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i64 1000000, i64* %y, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__two_global_variables_generates_in_separate_global_variables.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__two_global_variables_generates_in_separate_global_variables.snap index dc394dd9577..1184d09cb37 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__two_global_variables_generates_in_separate_global_variables.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__two_global_variables_generates_in_separate_global_variables.snap @@ -7,12 +7,12 @@ source_filename = "main" %main = type {} -@gX = global i16 0 -@gY = global i8 0 -@gA = global i16 0 -@main_instance = global %main zeroinitializer +@gX = global i16 0, section "var-$RUSTY$gX:i16" +@gY = global i8 0, section "var-$RUSTY$gY:u8" +@gA = global i16 0, section "var-$RUSTY$gA:i16" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_generated.snap index dd20ce1e350..9c4d2a95272 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_generated.snap @@ -5,15 +5,15 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@x = global i8 0 -@y = global i16 0 -@z = global i32 0 -@MyEnum.red = unnamed_addr constant i8 0 -@MyEnum.yellow = unnamed_addr constant i8 1 -@MyEnum.green = unnamed_addr constant i8 2 -@MyEnum2.red = unnamed_addr constant i16 0 -@MyEnum2.yellow = unnamed_addr constant i16 1 -@MyEnum2.green = unnamed_addr constant i16 2 -@MyEnum3.red = unnamed_addr constant i32 0 -@MyEnum3.yellow = unnamed_addr constant i32 1 -@MyEnum3.green = unnamed_addr constant i32 2 +@x = global i8 0, section "var-$RUSTY$x:e3u8" +@y = global i16 0, section "var-$RUSTY$y:e3u16" +@z = global i32 0, section "var-$RUSTY$z:e3i32" +@MyEnum.red = unnamed_addr constant i8 0, section "var-$RUSTY$red:e3u8" +@MyEnum.yellow = unnamed_addr constant i8 1, section "var-$RUSTY$yellow:e3u8" +@MyEnum.green = unnamed_addr constant i8 2, section "var-$RUSTY$green:e3u8" +@MyEnum2.red = unnamed_addr constant i16 0, section "var-$RUSTY$red:e3u16" +@MyEnum2.yellow = unnamed_addr constant i16 1, section "var-$RUSTY$yellow:e3u16" +@MyEnum2.green = unnamed_addr constant i16 2, section "var-$RUSTY$green:e3u16" +@MyEnum3.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" +@MyEnum3.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" +@MyEnum3.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_used_properly.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_used_properly.snap index 57ad6134cb2..97965f04077 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_used_properly.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_are_used_properly.snap @@ -7,18 +7,18 @@ source_filename = "main" %prg = type { i8, i16, i32 } -@prg_instance = global %prg zeroinitializer -@MyEnum.red = unnamed_addr constant i8 5 -@MyEnum.yellow = unnamed_addr constant i8 6 -@MyEnum.green = unnamed_addr constant i8 7 -@MyEnum2.red = unnamed_addr constant i16 15 -@MyEnum2.yellow = unnamed_addr constant i16 16 -@MyEnum2.green = unnamed_addr constant i16 17 -@MyEnum3.red = unnamed_addr constant i32 25 -@MyEnum3.yellow = unnamed_addr constant i32 26 -@MyEnum3.green = unnamed_addr constant i32 27 +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u16i32" +@MyEnum.red = unnamed_addr constant i8 5, section "var-$RUSTY$red:e3u8" +@MyEnum.yellow = unnamed_addr constant i8 6, section "var-$RUSTY$yellow:e3u8" +@MyEnum.green = unnamed_addr constant i8 7, section "var-$RUSTY$green:e3u8" +@MyEnum2.red = unnamed_addr constant i16 15, section "var-$RUSTY$red:e3u16" +@MyEnum2.yellow = unnamed_addr constant i16 16, section "var-$RUSTY$yellow:e3u16" +@MyEnum2.green = unnamed_addr constant i16 17, section "var-$RUSTY$green:e3u16" +@MyEnum3.red = unnamed_addr constant i32 25, section "var-$RUSTY$red:e3i32" +@MyEnum3.yellow = unnamed_addr constant i32 26, section "var-$RUSTY$yellow:e3i32" +@MyEnum3.green = unnamed_addr constant i32 27, section "var-$RUSTY$green:e3i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_initializers_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_initializers_are_generated.snap index 14f10de461e..abef6cc783e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_initializers_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_initializers_are_generated.snap @@ -5,15 +5,15 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@x = global i8 0 -@y = global i16 0 -@z = global i32 0 -@MyEnum.red = unnamed_addr constant i8 1 -@MyEnum.yellow = unnamed_addr constant i8 2 -@MyEnum.green = unnamed_addr constant i8 3 -@MyEnum2.red = unnamed_addr constant i16 10 -@MyEnum2.yellow = unnamed_addr constant i16 11 -@MyEnum2.green = unnamed_addr constant i16 12 -@MyEnum3.red = unnamed_addr constant i32 22 -@MyEnum3.yellow = unnamed_addr constant i32 33 -@MyEnum3.green = unnamed_addr constant i32 44 +@x = global i8 0, section "var-$RUSTY$x:e3u8" +@y = global i16 0, section "var-$RUSTY$y:e3u16" +@z = global i32 0, section "var-$RUSTY$z:e3i32" +@MyEnum.red = unnamed_addr constant i8 1, section "var-$RUSTY$red:e3u8" +@MyEnum.yellow = unnamed_addr constant i8 2, section "var-$RUSTY$yellow:e3u8" +@MyEnum.green = unnamed_addr constant i8 3, section "var-$RUSTY$green:e3u8" +@MyEnum2.red = unnamed_addr constant i16 10, section "var-$RUSTY$red:e3u16" +@MyEnum2.yellow = unnamed_addr constant i16 11, section "var-$RUSTY$yellow:e3u16" +@MyEnum2.green = unnamed_addr constant i16 12, section "var-$RUSTY$green:e3u16" +@MyEnum3.red = unnamed_addr constant i32 22, section "var-$RUSTY$red:e3i32" +@MyEnum3.yellow = unnamed_addr constant i32 33, section "var-$RUSTY$yellow:e3i32" +@MyEnum3.green = unnamed_addr constant i32 44, section "var-$RUSTY$green:e3i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_partly_initializers_are_generated.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_partly_initializers_are_generated.snap index a6f7759b1da..c5505b5caaf 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_partly_initializers_are_generated.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__typed_enums_with_partly_initializers_are_generated.snap @@ -5,15 +5,15 @@ expression: result ; ModuleID = 'main' source_filename = "main" -@twenty = unnamed_addr constant i16 20 -@x = global i8 0 -@MyEnum.red = unnamed_addr constant i8 7 -@MyEnum.yellow = unnamed_addr constant i8 8 -@MyEnum.green = unnamed_addr constant i8 9 -@MyEnum2.a = unnamed_addr constant i8 0 -@MyEnum2.b = unnamed_addr constant i8 1 -@MyEnum2.c = unnamed_addr constant i8 7 -@MyEnum2.d = unnamed_addr constant i8 8 -@MyEnum2.e = unnamed_addr constant i8 9 -@MyEnum2.f = unnamed_addr constant i8 20 -@MyEnum2.g = unnamed_addr constant i8 21 +@twenty = unnamed_addr constant i16 20, section "var-$RUSTY$twenty:i16" +@x = global i8 0, section "var-$RUSTY$x:e3u8" +@MyEnum.red = unnamed_addr constant i8 7, section "var-$RUSTY$red:e3u8" +@MyEnum.yellow = unnamed_addr constant i8 8, section "var-$RUSTY$yellow:e3u8" +@MyEnum.green = unnamed_addr constant i8 9, section "var-$RUSTY$green:e3u8" +@MyEnum2.a = unnamed_addr constant i8 0, section "var-$RUSTY$a:e7u8" +@MyEnum2.b = unnamed_addr constant i8 1, section "var-$RUSTY$b:e7u8" +@MyEnum2.c = unnamed_addr constant i8 7, section "var-$RUSTY$c:e7u8" +@MyEnum2.d = unnamed_addr constant i8 8, section "var-$RUSTY$d:e7u8" +@MyEnum2.e = unnamed_addr constant i8 9, section "var-$RUSTY$e:e7u8" +@MyEnum2.f = unnamed_addr constant i8 20, section "var-$RUSTY$f:e7u8" +@MyEnum2.g = unnamed_addr constant i8 21, section "var-$RUSTY$g:e7u8" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_cast_statement_as_const_expression.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_cast_statement_as_const_expression.snap index 8272ecf6dea..5f55331eb1e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_cast_statement_as_const_expression.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_cast_statement_as_const_expression.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { [14 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1ai16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_const_expression_in_range_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_const_expression_in_range_type.snap index fda711bc8df..bf6f679b635 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_const_expression_in_range_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_const_expression_in_range_type.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { i16 } -@CONST = global i16 7 -@MIN = global i16 7 -@prg_instance = global %prg zeroinitializer +@CONST = global i16 7, section "var-$RUSTY$CONST:i16" +@MIN = global i16 7, section "var-$RUSTY$MIN:i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i16" -define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-CheckRangeSigned:i16[i16][i16][i16]" { +define i16 @CheckRangeSigned(i16 %0, i16 %1, i16 %2) section "fn-$RUSTY$CheckRangeSigned:i16[i16][i16][i16]" { entry: %CheckRangeSigned = alloca i16, align 2 %value = alloca i16, align 2 @@ -27,7 +27,7 @@ entry: ret i16 %CheckRangeSigned_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %load_MIN = load i16, i16* @MIN, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_global_consts_in_expressions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_global_consts_in_expressions.snap index 92306c19a08..f03fe9d1c1e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_global_consts_in_expressions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__using_global_consts_in_expressions.snap @@ -7,12 +7,12 @@ source_filename = "main" %prg = type { i32 } -@cA = unnamed_addr constant i16 1 -@cB = unnamed_addr constant i16 2 -@cC = unnamed_addr constant i16 3 -@prg_instance = global %prg zeroinitializer +@cA = unnamed_addr constant i16 1, section "var-$RUSTY$cA:i16" +@cB = unnamed_addr constant i16 2, section "var-$RUSTY$cB:i16" +@cC = unnamed_addr constant i16 3, section "var-$RUSTY$cC:i16" +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 store i32 6, i32* %z, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__variable_with_same_name_as_data_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__variable_with_same_name_as_data_type.snap index 244c5340aeb..51c2a26aa43 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__variable_with_same_name_as_data_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__variable_with_same_name_as_data_type.snap @@ -7,9 +7,9 @@ source_filename = "main" %prog = type { i64 } -@prog_instance = global %prog zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r1i64" -define i64 @func() section "fn-func:i64" { +define i64 @func() section "fn-$RUSTY$func:i64" { entry: %func = alloca i64, align 8 %TIME = alloca i64, align 8 @@ -19,7 +19,7 @@ entry: ret i64 %func_ret } -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %TIME = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_loop_with_if_exit.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_loop_with_if_exit.snap index 35f2497d9a0..bb75b11e967 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_loop_with_if_exit.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_loop_with_if_exit.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 br label %condition_check diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_statement.snap index fb30b7ee89a..2da5f62bc80 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 br label %condition_check diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_with_expression_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_with_expression_statement.snap index 3619b8afd0c..ff1fc737a2b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_with_expression_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__code_gen_tests__while_with_expression_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 br label %condition_check diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_number_type_comparing_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_number_type_comparing_test.snap index 294ce2caff2..e00468537da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_number_type_comparing_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_number_type_comparing_test.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %x = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_ranged_number_type_comparing_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_ranged_number_type_comparing_test.snap index 294ce2caff2..e00468537da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_ranged_number_type_comparing_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__aliased_ranged_number_type_comparing_test.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %x = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_datetime_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_datetime_types.snap index 33b062d4cfe..cb1dcf50c36 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_datetime_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_datetime_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i64, i64, i64, i64 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4i64i64i64i64" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var_time = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var_time_of_day = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instruction_functions_with_different_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instruction_functions_with_different_types.snap index 30f7cd9e8a7..23745331956 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instruction_functions_with_different_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instruction_functions_with_different_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { float*, i16, i32, float, double, i8, i16, i32, i64, i8, i16, i32, i64 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r13pf32i16i32f32f64i8i16i32i64u8u16u32u64" -define float @foo() section "fn-foo:f32" { +define float @foo() section "fn-$RUSTY$foo:f32" { entry: %foo = alloca float, align 4 store float 0.000000e+00, float* %foo, align 4 @@ -17,7 +17,7 @@ entry: ret float %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %ptr_float = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %a = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instructions_with_different_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instructions_with_different_types.snap index 09104ad5ec2..7061563847c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instructions_with_different_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__compare_instructions_with_different_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16*, i16, i32, i8, i16, i32, i64, i8, i16, i32, i64 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r11pi16i16i32i8i16i32i64u8u16u32u64" -define i64 @foo() section "fn-foo:i64" { +define i64 @foo() section "fn-$RUSTY$foo:i64" { entry: %foo = alloca i64, align 8 store i64 0, i64* %foo, align 4 @@ -17,7 +17,7 @@ entry: ret i64 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %ptr_int = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %a = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_compare_instructions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_compare_instructions.snap index b528b614047..8ea2a13eb6a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_compare_instructions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_compare_instructions.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16, i16, i16*, i8 } -@main_instance = global %main { i16 10, i16 20, i16* null, i8 0 } +@main_instance = global %main { i16 10, i16 20, i16* null, i8 0 }, section "var-$RUSTY$main_instance:r4i16i16pi16u8" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_function_call_compare_instructions.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_function_call_compare_instructions.snap index 71ab97bb9d9..e1405db64d5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_function_call_compare_instructions.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__pointer_function_call_compare_instructions.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16*, i16, i8 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3pi16i16u8" -define i64 @foo() section "fn-foo:i64" { +define i64 @foo() section "fn-$RUSTY$foo:i64" { entry: %foo = alloca i64, align 8 store i64 0, i64* %foo, align 4 @@ -17,7 +17,7 @@ entry: ret i64 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %pt = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__ranged_number_type_comparing_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__ranged_number_type_comparing_test.snap index 294ce2caff2..e00468537da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__ranged_number_type_comparing_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__ranged_number_type_comparing_test.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %x = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_comparison_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_comparison_test.snap index f692225ced3..48267d94d4a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_comparison_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_comparison_test.snap @@ -8,7 +8,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"a\00" @utf08_literal_1 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -24,7 +24,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_equal_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_equal_with_constant_test.snap index 68c952ff72e..96d9c979e57 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_equal_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_equal_with_constant_test.snap @@ -8,7 +8,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"a\00" @utf08_literal_1 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -24,7 +24,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_or_equal_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_or_equal_with_constant_test.snap index a569845d5f3..9f9a9afc1f0 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_or_equal_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_or_equal_with_constant_test.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_GREATER(i8* %0, i8* %1) section "fn-STRING_GREATER:u8[s8u1025][s8u1025]" { +define i8 @STRING_GREATER(i8* %0, i8* %1) section "fn-$RUSTY$STRING_GREATER:u8[s8u1025][s8u1025]" { entry: %STRING_GREATER = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -23,7 +23,7 @@ entry: ret i8 %STRING_GREATER_ret } -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -39,7 +39,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_with_constant_test.snap index cbebe3cb1fc..0df19053b22 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_greater_with_constant_test.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_GREATER(i8* %0, i8* %1) section "fn-STRING_GREATER:u8[s8u1025][s8u1025]" { +define i8 @STRING_GREATER(i8* %0, i8* %1) section "fn-$RUSTY$STRING_GREATER:u8[s8u1025][s8u1025]" { entry: %STRING_GREATER = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -23,7 +23,7 @@ entry: ret i8 %STRING_GREATER_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_less_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_less_with_constant_test.snap index 37ce4183d3a..1c657cb42ff 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_less_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_less_with_constant_test.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_LESS(i8* %0, i8* %1) section "fn-STRING_LESS:u8[s8u1025][s8u1025]" { +define i8 @STRING_LESS(i8* %0, i8* %1) section "fn-$RUSTY$STRING_LESS:u8[s8u1025][s8u1025]" { entry: %STRING_LESS = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -23,7 +23,7 @@ entry: ret i8 %STRING_LESS_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_not_equal_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_not_equal_with_constant_test.snap index 038ff3e2f85..f92c7987105 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_not_equal_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_not_equal_with_constant_test.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -23,7 +23,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_smaller_or_equal_with_constant_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_smaller_or_equal_with_constant_test.snap index db2db49d736..4ae435d7488 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_smaller_or_equal_with_constant_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__compare_instructions_tests__string_smaller_or_equal_with_constant_test.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"b\00" -define i8 @STRING_LESS(i8* %0, i8* %1) section "fn-STRING_LESS:u8[s8u1025][s8u1025]" { +define i8 @STRING_LESS(i8* %0, i8* %1) section "fn-$RUSTY$STRING_LESS:u8[s8u1025][s8u1025]" { entry: %STRING_LESS = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -23,7 +23,7 @@ entry: ret i8 %STRING_LESS_ret } -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -39,7 +39,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %a = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_array_variable.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_array_variable.snap index 6ab566dc672..ea2fbfae188 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_array_variable.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_array_variable.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [4 x i16] } -@const_arr = unnamed_addr constant [4 x i16] [i16 1, i16 2, i16 3, i16 4] -@main_instance = global %main zeroinitializer +@const_arr = unnamed_addr constant [4 x i16] [i16 1, i16 2, i16 3, i16 4], section "var-$RUSTY$const_arr:ai16" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1ai16" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %arr = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = bitcast [4 x i16]* %arr to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_string_variable.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_string_variable.snap index 98e3e4218a2..2b61ed25b8f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_string_variable.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_string_variable.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [81 x i8] } -@const_str = unnamed_addr constant [81 x i8] c"global constant string\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" -@main_instance = global %main zeroinitializer +@const_str = unnamed_addr constant [81 x i8] c"global constant string\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", section "var-$RUSTY$const_str:s8u81" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %str = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = bitcast [81 x i8]* %str to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_struct_variable.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_struct_variable.snap index 1504e0742fa..2691f18820d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_struct_variable.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__constants_tests__assigning_const_struct_variable.snap @@ -8,11 +8,11 @@ source_filename = "main" %Point = type { i16, i16 } %main = type { %Point } -@const_strct = unnamed_addr constant %Point { i16 1, i16 2 } -@__Point__init = unnamed_addr constant %Point zeroinitializer -@main_instance = global %main zeroinitializer +@const_strct = unnamed_addr constant %Point { i16 1, i16 2 }, section "var-$RUSTY$const_strct:r2i16i16" +@__Point__init = unnamed_addr constant %Point zeroinitializer, section "var-$RUSTY$__Point__init:r2i16i16" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1r2i16i16" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %strct = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = bitcast %Point* %strct to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__dwarf_version_override.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__dwarf_version_override.snap index 97f35d7d5af..f73180c2823 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__dwarf_version_override.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__dwarf_version_override.snap @@ -5,7 +5,7 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@gInt = global i32 0, !dbg !0 +@gInt = global i32 0, section "var-$RUSTY$gInt:i32", !dbg !0 !llvm.module.flags = !{!5, !6} !llvm.dbg.cu = !{!7} @@ -19,4 +19,3 @@ source_filename = "main" !6 = !{i32 2, !"Debug Info Version", i32 3} !7 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false) !8 = !{!0} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_alias_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_alias_type.snap index f768c755d42..1811dc5f2f6 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_alias_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_alias_type.snap @@ -5,7 +5,7 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@gInt = global i32 0, !dbg !0 +@gInt = global i32 0, section "var-$RUSTY$gInt:i32", !dbg !0 !llvm.module.flags = !{!5, !6} !llvm.dbg.cu = !{!7} @@ -19,4 +19,3 @@ source_filename = "main" !6 = !{i32 2, !"Debug Info Version", i32 3} !7 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false) !8 = !{!0} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap index bc8939baec6..6de29550fd9 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap @@ -5,9 +5,9 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global [11 x i32] zeroinitializer, !dbg !0 -@b = global [110 x i32] zeroinitializer, !dbg !7 -@c = global [11 x [10 x i32]] zeroinitializer, !dbg !12 +@a = global [11 x i32] zeroinitializer, section "var-$RUSTY$a:ai32", !dbg !0 +@b = global [110 x i32] zeroinitializer, section "var-$RUSTY$b:ai32", !dbg !7 +@c = global [11 x [10 x i32]] zeroinitializer, section "var-$RUSTY$c:aai32", !dbg !12 !llvm.module.flags = !{!17, !18} !llvm.dbg.cu = !{!19} diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_byteseq_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_byteseq_added_to_debug_info.snap index c3bcfd9c53a..5f3be0978ec 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_byteseq_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_byteseq_added_to_debug_info.snap @@ -5,11 +5,11 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global i8 0, !dbg !0 -@b = global i8 0, !dbg !4 -@c = global i16 0, !dbg !7 -@d = global i32 0, !dbg !10 -@e = global i64 0, !dbg !13 +@a = global i8 0, section "var-$RUSTY$a:u8", !dbg !0 +@b = global i8 0, section "var-$RUSTY$b:u8", !dbg !4 +@c = global i16 0, section "var-$RUSTY$c:u16", !dbg !7 +@d = global i32 0, section "var-$RUSTY$d:u32", !dbg !10 +@e = global i64 0, section "var-$RUSTY$e:u64", !dbg !13 !llvm.module.flags = !{!16, !17} !llvm.dbg.cu = !{!18} @@ -34,4 +34,3 @@ source_filename = "main" !17 = !{i32 2, !"Debug Info Version", i32 3} !18 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !19, splitDebugInlining: false) !19 = !{!0, !4, !7, !10, !13} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_enum_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_enum_added_to_debug_info.snap index f2e51fc23c9..aa115753be5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_enum_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_enum_added_to_debug_info.snap @@ -5,16 +5,16 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@en3 = global i64 0, !dbg !0 -@en1.a = unnamed_addr constant i32 0, !dbg !5 -@en1.b = unnamed_addr constant i32 1, !dbg !9 -@en1.c = unnamed_addr constant i32 2, !dbg !11 -@en2.d = unnamed_addr constant i8 0, !dbg !13 -@en2.e = unnamed_addr constant i8 1, !dbg !17 -@en2.f = unnamed_addr constant i8 2, !dbg !19 -@__global_en3.a = unnamed_addr constant i64 0, !dbg !21 -@__global_en3.b = unnamed_addr constant i64 1, !dbg !23 -@__global_en3.c = unnamed_addr constant i64 2, !dbg !25 +@en3 = global i64 0, section "var-$RUSTY$en3:e3i64", !dbg !0 +@en1.a = unnamed_addr constant i32 0, section "var-$RUSTY$a:e3i32", !dbg !5 +@en1.b = unnamed_addr constant i32 1, section "var-$RUSTY$b:e3i32", !dbg !9 +@en1.c = unnamed_addr constant i32 2, section "var-$RUSTY$c:e3i32", !dbg !11 +@en2.d = unnamed_addr constant i8 0, section "var-$RUSTY$d:e3u8", !dbg !13 +@en2.e = unnamed_addr constant i8 1, section "var-$RUSTY$e:e3u8", !dbg !17 +@en2.f = unnamed_addr constant i8 2, section "var-$RUSTY$f:e3u8", !dbg !19 +@__global_en3.a = unnamed_addr constant i64 0, section "var-$RUSTY$a:e3i64", !dbg !21 +@__global_en3.b = unnamed_addr constant i64 1, section "var-$RUSTY$b:e3i64", !dbg !23 +@__global_en3.c = unnamed_addr constant i64 2, section "var-$RUSTY$c:e3i64", !dbg !25 !llvm.module.flags = !{!27, !28} !llvm.dbg.cu = !{!29} diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_float_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_float_added_to_debug_info.snap index 3072a3a70e7..0b88473ac83 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_float_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_float_added_to_debug_info.snap @@ -5,8 +5,8 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global float 0.000000e+00, !dbg !0 -@b = global double 0.000000e+00, !dbg !4 +@a = global float 0.000000e+00, section "var-$RUSTY$a:f32", !dbg !0 +@b = global double 0.000000e+00, section "var-$RUSTY$b:f64", !dbg !4 !llvm.module.flags = !{!7, !8} !llvm.dbg.cu = !{!9} @@ -22,4 +22,3 @@ source_filename = "main" !8 = !{i32 2, !"Debug Info Version", i32 3} !9 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !10, splitDebugInlining: false) !10 = !{!0, !4} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_int_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_int_added_to_debug_info.snap index ef994f3a9ec..28d2d68c713 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_int_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_int_added_to_debug_info.snap @@ -5,14 +5,14 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global i8 0, !dbg !0 -@b = global i8 0, !dbg !4 -@c = global i16 0, !dbg !7 -@d = global i16 0, !dbg !10 -@e = global i32 0, !dbg !13 -@f = global i32 0, !dbg !16 -@g = global i64 0, !dbg !19 -@h = global i64 0, !dbg !22 +@a = global i8 0, section "var-$RUSTY$a:i8", !dbg !0 +@b = global i8 0, section "var-$RUSTY$b:u8", !dbg !4 +@c = global i16 0, section "var-$RUSTY$c:i16", !dbg !7 +@d = global i16 0, section "var-$RUSTY$d:u16", !dbg !10 +@e = global i32 0, section "var-$RUSTY$e:i32", !dbg !13 +@f = global i32 0, section "var-$RUSTY$f:u32", !dbg !16 +@g = global i64 0, section "var-$RUSTY$g:i64", !dbg !19 +@h = global i64 0, section "var-$RUSTY$h:u64", !dbg !22 !llvm.module.flags = !{!25, !26} !llvm.dbg.cu = !{!27} @@ -46,4 +46,3 @@ source_filename = "main" !26 = !{i32 2, !"Debug Info Version", i32 3} !27 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !28, splitDebugInlining: false) !28 = !{!0, !4, !7, !10, !13, !16, !19, !22} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_nested_struct_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_nested_struct_added_to_debug_info.snap index 77a450c403c..803a57f3496 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_nested_struct_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_nested_struct_added_to_debug_info.snap @@ -8,9 +8,9 @@ source_filename = "main" %myStruct = type { i32, %myStruct2 } %myStruct2 = type { i32, double } -@gStruct = global %myStruct zeroinitializer, !dbg !0 -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, !dbg !13 -@__myStruct2__init = unnamed_addr constant %myStruct2 zeroinitializer, !dbg !15 +@gStruct = global %myStruct zeroinitializer, section "var-$RUSTY$gStruct:r2i32r2i32f64", !dbg !0 +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r2i32r2i32f64", !dbg !13 +@__myStruct2__init = unnamed_addr constant %myStruct2 zeroinitializer, section "var-$RUSTY$__myStruct2__init:r2i32f64", !dbg !15 !llvm.module.flags = !{!17, !18} !llvm.dbg.cu = !{!19} @@ -36,4 +36,3 @@ source_filename = "main" !18 = !{i32 2, !"Debug Info Version", i32 3} !19 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !20, splitDebugInlining: false) !20 = !{!0, !13, !15} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap index 627648ab048..866adc90253 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap @@ -5,7 +5,7 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global i32* null, !dbg !0 +@a = global i32* null, section "var-$RUSTY$a:pi32", !dbg !0 !llvm.module.flags = !{!5, !6} !llvm.dbg.cu = !{!7} @@ -19,4 +19,3 @@ source_filename = "main" !6 = !{i32 2, !"Debug Info Version", i32 3} !7 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "RuSTy Structured text Compiler", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !8, splitDebugInlining: false) !8 = !{!0} - diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_string_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_string_added_to_debug_info.snap index eb898b7e821..864e7f4fba5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_string_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_string_added_to_debug_info.snap @@ -5,8 +5,8 @@ expression: codegen ; ModuleID = 'main' source_filename = "main" -@a = global [81 x i8] zeroinitializer, !dbg !0 -@b = global [81 x i16] zeroinitializer, !dbg !7 +@a = global [81 x i8] zeroinitializer, section "var-$RUSTY$a:s8u81", !dbg !0 +@b = global [81 x i16] zeroinitializer, section "var-$RUSTY$b:s16u81", !dbg !7 !llvm.module.flags = !{!11, !12} !llvm.dbg.cu = !{!13} diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_struct_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_struct_added_to_debug_info.snap index e4da745f10c..0597974f4c3 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_struct_added_to_debug_info.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_struct_added_to_debug_info.snap @@ -7,9 +7,9 @@ source_filename = "main" %myStruct = type { i32, double, [11 x i32] } -@gStruct = global %myStruct zeroinitializer, !dbg !0 -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, !dbg !13 -@b = global [11 x %myStruct] zeroinitializer, !dbg !15 +@gStruct = global %myStruct zeroinitializer, section "var-$RUSTY$gStruct:r3i32f64ai32", !dbg !0 +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r3i32f64ai32", !dbg !13 +@b = global [11 x %myStruct] zeroinitializer, section "var-$RUSTY$b:ar3i32f64ai32", !dbg !15 !llvm.module.flags = !{!18, !19} !llvm.dbg.cu = !{!20} diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__bitaccess_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__bitaccess_assignment.snap index 7d43f2e95ae..17b1cc07805 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__bitaccess_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__bitaccess_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %a = alloca i8, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__byteaccess_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__byteaccess_assignment.snap index a2afbc1809b..9dd16c7c5e7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__byteaccess_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__byteaccess_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %b = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__chained_bit_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__chained_bit_assignment.snap index 3bdd26d450d..be0753e99e9 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__chained_bit_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__chained_bit_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %d = alloca i64, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__dwordaccess_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__dwordaccess_assignment.snap index ef35b7c34e6..3e4cf086736 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__dwordaccess_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__dwordaccess_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %d = alloca i64, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__lwordaccess_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__lwordaccess_assignment.snap index 414c121c50b..4b2a62507b6 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__lwordaccess_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__lwordaccess_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %d = alloca i64, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__qualified_reference_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__qualified_reference_assignment.snap index 18595e72682..178b8710e93 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__qualified_reference_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__qualified_reference_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %myStruct = type { i8 } -@__myStruct__init = unnamed_addr constant %myStruct { i8 1 } +@__myStruct__init = unnamed_addr constant %myStruct { i8 1 }, section "var-$RUSTY$__myStruct__init:r1u8" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %str = alloca %myStruct, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__wordaccess_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__wordaccess_assignment.snap index d2ce83e27ca..b0ac3abacac 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__wordaccess_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__directaccess_test__wordaccess_assignment.snap @@ -5,7 +5,7 @@ expression: prog ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 %c = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__access_string_via_byte_array.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__access_string_via_byte_array.snap index 68a042fcf58..7b186085efd 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__access_string_via_byte_array.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__access_string_via_byte_array.snap @@ -7,9 +7,9 @@ source_filename = "main" %baz = type { [11 x i8], i8*, [10 x i8]* } -@baz_instance = global %baz zeroinitializer +@baz_instance = global %baz zeroinitializer, section "var-$RUSTY$baz_instance:r3s8u11pu8pau8" -define void @baz(%baz* %0) section "fn-baz:v" { +define void @baz(%baz* %0) section "fn-$RUSTY$baz:v" { entry: %str = getelementptr inbounds %baz, %baz* %0, i32 0, i32 0 %ptr = getelementptr inbounds %baz, %baz* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__allowed_assignable_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__allowed_assignable_types.snap index 32fb59a6dc5..772275ede2a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__allowed_assignable_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__allowed_assignable_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16, [2 x i16], i16*, [2 x i16]* } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4i16ai16pi16pai16" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %v = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_float.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_float.snap index 34fcd40fde5..28886fa044f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_float.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_float.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_ints.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_ints.snap index 53f6c8618b3..f8efd2d2ac1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_ints.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_ints.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_mixed.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_mixed.snap index 36adeb195f9..3007b561279 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_mixed.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_add_mixed.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_float.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_float.snap index 8fff2dea878..34a91ddfc71 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_float.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_float.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_ints.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_ints.snap index c3559a71d3c..c08bacfc033 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_ints.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_ints.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_mixed.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_mixed.snap index 0cc25f9daf7..d6d8a79ac06 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_mixed.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_div_mixed.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_adr.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_adr.snap index 8f00ddfb91a..8b30fb03c9b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_adr.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_adr.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32*, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2pi32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_lower_bound.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_lower_bound.snap index aa7a2bb241a..8a90e7a9607 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_lower_bound.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_lower_bound.snap @@ -8,10 +8,10 @@ source_filename = "main" %main = type { [2 x i32], i32 } %__foo_vla = type { i32*, [2 x i32] } -@main_instance = global %main zeroinitializer -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2ai32i32" +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai32ai32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 @@ -30,7 +30,7 @@ entry: ret void } -define i32 @foo(%__foo_vla* %0) section "fn-foo:i32[pv]" { +define i32 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %vla = alloca %__foo_vla*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap index 5d0484af4b8..48d5aecaccf 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_move.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2i32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap index 27229cc276f..83fc6f99f0c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r5i32i32i32i32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux_with_aggregate_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux_with_aggregate_type.snap index 75f90dd458b..25482f90dbe 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux_with_aggregate_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_mux_with_aggregate_type.snap @@ -7,13 +7,13 @@ source_filename = "main" %main = type { [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"dolor\00" @utf08_literal_1 = private unnamed_addr constant [6 x i8] c"ipsum\00" @utf08_literal_2 = private unnamed_addr constant [6 x i8] c"lorem\00" @utf08_literal_3 = private unnamed_addr constant [4 x i8] c"sit\00" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %str1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_ref.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_ref.snap index 43033311c3d..e4be51277bc 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_ref.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_ref.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32*, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2pi32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap index df8babe7d6e..bd9ab0f2a90 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap index 367c4cb9f0b..035232f1692 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sel_as_expression.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sizeof.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sizeof.snap index f4f198abfd3..be59e2f268a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sizeof.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_sizeof.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i64 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2i32i64" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound.snap index fd899f8f69a..f652e3b20de 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound.snap @@ -8,10 +8,10 @@ source_filename = "main" %main = type { [2 x i32], i32 } %__foo_vla = type { i32*, [2 x i32] } -@main_instance = global %main zeroinitializer -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2ai32i32" +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai32ai32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 @@ -30,7 +30,7 @@ entry: ret void } -define i32 @foo(%__foo_vla* %0) section "fn-foo:i32[pv]" { +define i32 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %vla = alloca %__foo_vla*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound_expr.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound_expr.snap index 36f5e9ee4dd..6451ebd31bc 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound_expr.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_function_call_upper_bound_expr.snap @@ -8,11 +8,11 @@ source_filename = "main" %main = type { [16 x i32], i32 } %__foo_vla = type { i32*, [2 x i32] } -@MY_CONST = unnamed_addr constant i32 10 -@main_instance = global %main zeroinitializer -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@MY_CONST = unnamed_addr constant i32 10, section "var-$RUSTY$MY_CONST:i32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2ai32i32" +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai32ai32" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %b = getelementptr inbounds %main, %main* %0, i32 0, i32 1 @@ -31,7 +31,7 @@ entry: ret void } -define i32 @foo(%__foo_vla* %0) section "fn-foo:i32[pv]" { +define i32 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %vla = alloca %__foo_vla*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_float.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_float.snap index db2dcd61de4..ee02b908f5c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_float.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_float.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_ints.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_ints.snap index f2f1b0fb5a2..f8ff9fdbf9a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_ints.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_ints.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_mixed.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_mixed.snap index 5dd59ae0085..20a48a564fb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_mixed.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_mul_mixed.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_float.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_float.snap index 018095b01f4..36e78e620c4 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_float.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_float.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_ints.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_ints.snap index 6b2e8e4fa38..a3fd7da5db2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_ints.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_ints.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_mixed.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_mixed.snap index 1db3a1d24c5..db9b19e5834 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_mixed.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__builtin_sub_mixed.snap @@ -5,7 +5,7 @@ expression: res ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__calling_strings_in_function_return.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__calling_strings_in_function_return.snap index 491ea335728..4171b614530 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__calling_strings_in_function_return.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__calling_strings_in_function_return.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" -define void @func([81 x i8]* %0) section "fn-func:s8u81" { +define void @func([81 x i8]* %0) section "fn-$RUSTY$func:s8u81" { entry: %func = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %func, align 8 @@ -23,7 +23,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_between_pointer_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_between_pointer_types.snap index 934a893e2b3..e9f7708b718 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_between_pointer_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_between_pointer_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %baz = type { i8*, i16 } -@baz_instance = global %baz zeroinitializer +@baz_instance = global %baz zeroinitializer, section "var-$RUSTY$baz_instance:r2pu8u16" -define void @baz(%baz* %0) section "fn-baz:v" { +define void @baz(%baz* %0) section "fn-$RUSTY$baz:v" { entry: %ptr_x = getelementptr inbounds %baz, %baz* %0, i32 0, i32 0 %y = getelementptr inbounds %baz, %baz* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_lword_to_pointer.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_lword_to_pointer.snap index e6506fd430f..32dc6e8eb66 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_lword_to_pointer.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_lword_to_pointer.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %ptr_x = alloca i16*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_pointer_to_lword.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_pointer_to_lword.snap index 2aa73303cdc..57b04fefea2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_pointer_to_lword.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__cast_pointer_to_lword.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 %ptr_x = alloca i16*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__compare_date_time_literals.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__compare_date_time_literals.snap index 3599d8dfc17..2d4d578bcb4 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__compare_date_time_literals.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__compare_date_time_literals.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r8u8u8u8u8u8u8u8u8" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %cmp1 = alloca i8, align 1 %cmp2 = alloca i8, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_assign_codegen.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_assign_codegen.snap index 5c9db0d4731..2b0dd2a5773 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_assign_codegen.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_assign_codegen.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_codegen.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_codegen.snap index 8aaf65c189c..de482e43a16 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_codegen.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__hardware_access_codegen.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u8u8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap index 137f73001bf..eb1dc9ec1c5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__max_int.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @main() section "fn-main:i16" { +define i16 @main() section "fn-$RUSTY$main:i16" { entry: %main = alloca i16, align 2 store i16 0, i16* %main, align 2 @@ -31,4 +31,4 @@ entry: ret i16 %main_ret } -declare i16 @MAX__INT(i32, i16*) section "fn-MAX__INT:i16" +declare i16 @MAX__INT(i32, i16*) section "fn-$RUSTY$MAX__INT:i16" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__nested_call_statements.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__nested_call_statements.snap index 702898de621..6857bb5d92f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__nested_call_statements.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__nested_call_statements.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" { entry: %foo = alloca i32, align 4 %a = alloca i32, align 4 @@ -19,7 +19,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %call = call i32 @foo(i32 2) %call1 = call i32 @foo(i32 %call) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics.snap index 66d17c646b5..fd925253078 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16, i16, i16* } -@main_instance = global %main { i16 10, i16 20, i16* null } +@main_instance = global %main { i16 10, i16 20, i16* null }, section "var-$RUSTY$main_instance:r3i16i16pi16" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics_function_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics_function_call.snap index f402dd63149..0820ec9a248 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics_function_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointer_arithmetics_function_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16*, i16 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2pi16i16" -define i64 @foo() section "fn-foo:i64" { +define i64 @foo() section "fn-$RUSTY$foo:i64" { entry: %foo = alloca i64, align 8 store i64 0, i64* %foo, align 4 @@ -17,7 +17,7 @@ entry: ret i64 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %pt = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointers_in_function_return.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointers_in_function_return.snap index 47f7065d73b..f4aef10525f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointers_in_function_return.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__pointers_in_function_return.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16* @func() section "fn-func:pi16" { +define i16* @func() section "fn-$RUSTY$func:pi16" { entry: %func = alloca i16*, align 8 store i16* null, i16** %func, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__strings_in_function_return.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__strings_in_function_return.snap index ff548ae5b6c..941ea6b3e65 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__strings_in_function_return.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__strings_in_function_return.snap @@ -7,7 +7,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" -define void @func([81 x i8]* %0, [81 x i8]* %1) section "fn-func:s8u81[ps8u81]" { +define void @func([81 x i8]* %0, [81 x i8]* %1) section "fn-$RUSTY$func:s8u81[ps8u81]" { entry: %func = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %func, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__structs_in_function_return.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__structs_in_function_return.snap index 87dce219e80..cfe7c759084 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__structs_in_function_return.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__structs_in_function_return.snap @@ -7,9 +7,9 @@ source_filename = "main" %myStruct = type { i16 } -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r1i16" -define void @func(%myStruct* %0, %myStruct* %1) section "fn-func:v[pv]" { +define void @func(%myStruct* %0, %myStruct* %1) section "fn-$RUSTY$func:r1i16[pr1i16]" { entry: %func = alloca %myStruct*, align 8 store %myStruct* %0, %myStruct** %func, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__type_mix_in_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__type_mix_in_call.snap index 30e41c84a7d..5905a187d29 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__type_mix_in_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__type_mix_in_call.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i16 @foo(i16 %0) section "fn-foo:i16[i16]" { +define i16 @foo(i16 %0) section "fn-$RUSTY$foo:i16[i16]" { entry: %foo = alloca i16, align 2 %in = alloca i16, align 2 @@ -15,7 +15,7 @@ entry: ret i16 %foo_ret } -define i16 @baz() section "fn-baz:i16" { +define i16 @baz() section "fn-$RUSTY$baz:i16" { entry: %baz = alloca i16, align 2 store i16 0, i16* %baz, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unary_expressions_can_be_real.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unary_expressions_can_be_real.snap index b0d68fe813d..9aded1e339e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unary_expressions_can_be_real.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unary_expressions_can_be_real.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unnecessary_casts_between_pointer_types.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unnecessary_casts_between_pointer_types.snap index 1c78aafcc18..885da78a65f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unnecessary_casts_between_pointer_types.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__expression_tests__unnecessary_casts_between_pointer_types.snap @@ -7,9 +7,9 @@ source_filename = "main" %baz = type { i8*, i8, i8, i8 } -@baz_instance = global %baz zeroinitializer +@baz_instance = global %baz zeroinitializer, section "var-$RUSTY$baz_instance:r4pu8u8i8u8" -define void @baz(%baz* %0) section "fn-baz:v" { +define void @baz(%baz* %0) section "fn-$RUSTY$baz:v" { entry: %ptr = getelementptr inbounds %baz, %baz* %0, i32 0, i32 0 %b = getelementptr inbounds %baz, %baz* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__argument_fed_by_ref_then_by_val.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__argument_fed_by_ref_then_by_val.snap index ef7538caaea..cb493902b8c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__argument_fed_by_ref_then_by_val.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__argument_fed_by_ref_then_by_val.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %arr = alloca [5 x i32], align 4 @@ -18,7 +18,7 @@ entry: ret i32 %main_ret } -define i32 @fn_by_ref(i32* %0) section "fn-fn_by_ref:i32[pv]" { +define i32 @fn_by_ref(i32* %0) section "fn-$RUSTY$fn_by_ref:i32[pau32]" { entry: %fn_by_ref = alloca i32, align 4 %arg_by_ref = alloca i32*, align 8 @@ -30,7 +30,7 @@ entry: ret i32 %fn_by_ref_ret } -define i32 @fn_by_val(i32* %0) section "fn-fn_by_val:i32[v]" { +define i32 @fn_by_val(i32* %0) section "fn-$RUSTY$fn_by_val:i32[au32]" { entry: %fn_by_val = alloca i32, align 4 %arg_by_val = alloca [5 x i32], align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__autocast_argument_literals_for_function_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__autocast_argument_literals_for_function_call.snap index 760a8ba1dce..a43fa0ad8da 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__autocast_argument_literals_for_function_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__autocast_argument_literals_for_function_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define i32 @func(i8* %0, i16* %1, i32* %2, i64* %3, float* %4, double* %5) section "fn-func:i32[pi8][pi16][pi32][pi64][pf32][pf64]" { +define i32 @func(i8* %0, i16* %1, i32* %2, i64* %3, float* %4, double* %5) section "fn-$RUSTY$func:i32[pi8][pi16][pi32][pi64][pf32][pf64]" { entry: %func = alloca i32, align 4 %byInt1 = alloca i8*, align 8 @@ -30,7 +30,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %1 = alloca i8, align 1 store i8 1, i8* %1, align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__bitcast_argument_references_for_function_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__bitcast_argument_references_for_function_call.snap index 7eeed6da58c..eba1401e347 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__bitcast_argument_references_for_function_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__bitcast_argument_references_for_function_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i8, i8, i16, i16, i32, i32, i64, i64, float, float, double, double } -@main_instance = global %main { i8 1, i8 1, i16 2, i16 2, i32 3, i32 3, i64 4, i64 4, float 5.000000e+00, float 5.000000e+00, double 6.000000e+00, double 6.000000e+00 } +@main_instance = global %main { i8 1, i8 1, i16 2, i16 2, i32 3, i32 3, i64 4, i64 4, float 5.000000e+00, float 5.000000e+00, double 6.000000e+00, double 6.000000e+00 }, section "var-$RUSTY$main_instance:r12i8i8i16i16i32i32i64i64f32f32f64f64" -define i8 @fn_sint(i8* %0, i8* %1) section "fn-fn_sint:i8[pi8][pi8]" { +define i8 @fn_sint(i8* %0, i8* %1) section "fn-$RUSTY$fn_sint:i8[pi8][pi8]" { entry: %fn_sint = alloca i8, align 1 %in_ref = alloca i8*, align 8 @@ -21,7 +21,7 @@ entry: ret i8 %fn_sint_ret } -define i64 @fn_lint(i64* %0, i64* %1) section "fn-fn_lint:i64[pi64][pi64]" { +define i64 @fn_lint(i64* %0, i64* %1) section "fn-$RUSTY$fn_lint:i64[pi64][pi64]" { entry: %fn_lint = alloca i64, align 8 %in_ref = alloca i64*, align 8 @@ -33,7 +33,7 @@ entry: ret i64 %fn_lint_ret } -define i64 @fn_real(float* %0, float* %1) section "fn-fn_real:i64[pf32][pf32]" { +define i64 @fn_real(float* %0, float* %1) section "fn-$RUSTY$fn_real:i64[pf32][pf32]" { entry: %fn_real = alloca i64, align 8 %in_ref = alloca float*, align 8 @@ -45,7 +45,7 @@ entry: ret i64 %fn_real_ret } -define i64 @fn_lreal(double* %0, double* %1) section "fn-fn_lreal:i64[pf64][pf64]" { +define i64 @fn_lreal(double* %0, double* %1) section "fn-$RUSTY$fn_lreal:i64[pf64][pf64]" { entry: %fn_lreal = alloca i64, align 8 %in_ref = alloca double*, align 8 @@ -57,7 +57,7 @@ entry: ret i64 %fn_lreal_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1_sint = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2_sint = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_ref_sized_string_varargs_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_ref_sized_string_varargs_called_in_program.snap index c83905fbf90..dce4f413a14 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_ref_sized_string_varargs_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_ref_sized_string_varargs_called_in_program.snap @@ -7,14 +7,14 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"a\00" @utf08_literal_1 = private unnamed_addr constant [4 x i8] c"abc\00" @utf08_literal_2 = private unnamed_addr constant [7 x i8] c"abcdef\00" -declare i32 @foo(i32, i8**) section "fn-foo:i32" +declare i32 @foo(i32, i8**) section "fn-$RUSTY$foo:i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %1 = alloca [3 x i8*], align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap index 6908aaecc33..d91b7b02edd 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_sized_varargs_called_in_program.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -declare i32 @foo(i32, i32*) section "fn-foo:i32" +declare i32 @foo(i32, i32*) section "fn-$RUSTY$foo:i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %load_x = load i32, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap index 7e7b60961ea..1be4fb41172 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__function_with_varargs_called_in_program.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -declare i32 @foo(...) section "fn-foo:i32" +declare i32 @foo(...) section "fn-$RUSTY$foo:i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %load_x = load i32, i32* %x, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__literal_string_argument_passed_by_ref.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__literal_string_argument_passed_by_ref.snap index 5d3bad001d5..2e5636d68b7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__literal_string_argument_passed_by_ref.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__literal_string_argument_passed_by_ref.snap @@ -7,12 +7,12 @@ source_filename = "main" %main = type { [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" -declare void @func([81 x i8]*, i8*) section "fn-func:s8u81[ps8u81]" +declare void @func([81 x i8]*, i8*) section "fn-$RUSTY$func:s8u81[ps8u81]" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %res = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__member_variables_in_body.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__member_variables_in_body.snap index 87f407e59ff..94c6a39e2c2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__member_variables_in_body.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__member_variables_in_body.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @func(i16 %0, i8* %1, i64* %2) section "fn-func:i32[i16][pi8][pi64]" { +define i32 @func(i16 %0, i8* %1, i64* %2) section "fn-$RUSTY$func:i32[i16][pi8][pi64]" { entry: %func = alloca i32, align 4 %i = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__on_functions_var_output_should_be_passed_as_a_pointer.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__on_functions_var_output_should_be_passed_as_a_pointer.snap index 1c13b04b7f6..770242651b5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__on_functions_var_output_should_be_passed_as_a_pointer.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__on_functions_var_output_should_be_passed_as_a_pointer.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @bump(i8* %0) section "fn-bump:i32[pi8]" { +define i32 @bump(i8* %0) section "fn-$RUSTY$bump:i32[pi8]" { entry: %bump = alloca i32, align 4 %v = alloca i8*, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap index 1411ca6172b..082aa876117 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [6 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u6" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"12345\00" -define i32 @func(i8* %0) section "fn-func:i32[s8u6]" { +define i32 @func(i8* %0) section "fn-$RUSTY$func:i32[s8u6]" { entry: %func = alloca i32, align 4 %x = alloca [6 x i8], align 1 @@ -22,7 +22,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = bitcast [6 x i8]* %a to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap index 2bd5e485a1e..1a2b372911b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_a_string_to_a_function_as_reference.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [6 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u6" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"12345\00" -define i32 @func(i8* %0) section "fn-func:i32[ps8u6]" { +define i32 @func(i8* %0) section "fn-$RUSTY$func:i32[ps8u6]" { entry: %func = alloca i32, align 4 %x = alloca i8*, align 8 @@ -20,7 +20,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = bitcast [6 x i8]* %a to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap index 3bb606f5909..e6cf5dc9520 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__passing_arguments_to_functions_by_ref_and_val.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define i32 @func(i16* %0, i32* %1, i16 %2, i32 %3) section "fn-func:i32[pi16][pi32][i16][i32]" { +define i32 @func(i16* %0, i32* %1, i16 %2, i32 %3) section "fn-$RUSTY$func:i32[pi16][pi32][i16][i32]" { entry: %func = alloca i32, align 4 %byRef1 = alloca i16*, align 8 @@ -38,7 +38,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %1 = alloca i16, align 2 store i16 1, i16* %1, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__return_variable_in_nested_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__return_variable_in_nested_call.snap index 468a05a0d28..10118853240 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__return_variable_in_nested_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__return_variable_in_nested_call.snap @@ -5,7 +5,7 @@ expression: codegen(src) ; ModuleID = 'main' source_filename = "main" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x1 = alloca i32, align 4 @@ -20,7 +20,7 @@ entry: ret i32 %main_ret } -define i32 @SMC_Read(i64 %0) section "fn-SMC_Read:i32[u64]" { +define i32 @SMC_Read(i64 %0) section "fn-$RUSTY$SMC_Read:i32[u64]" { entry: %SMC_Read = alloca i32, align 4 %ValAddr = alloca i64, align 8 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap index 2355a116c6f..b0d691e2619 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__simple_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1i32" -define i32 @func(i32 %0) section "fn-func:i32[i32]" { +define i32 @func(i32 %0) section "fn-$RUSTY$func:i32[i32]" { entry: %func = alloca i32, align 4 %x = alloca i32, align 4 @@ -19,7 +19,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %load_a = load i32, i32* %a, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__var_output_in_function_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__var_output_in_function_call.snap index 7babfb50431..93ce1a318bb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__var_output_in_function_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__function_tests__var_output_in_function_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i16 } -@main_instance = global %main { i16 4 } +@main_instance = global %main { i16 4 }, section "var-$RUSTY$main_instance:r1i16" -define i32 @func(i16* %0) section "fn-func:i32[pi16]" { +define i32 @func(i16* %0) section "fn-$RUSTY$func:i32[pi16]" { entry: %func = alloca i32, align 4 %o = alloca i16*, align 8 @@ -22,7 +22,7 @@ entry: ret i32 %func_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %call = call i32 @func(i16* %x) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__any_real_function_called_with_ints.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__any_real_function_called_with_ints.snap index f4cd2fde23b..8c1b8cb6f56 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__any_real_function_called_with_ints.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__any_real_function_called_with_ints.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, float, float, double, float, float, float, double } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r10f32f32f32f64f32f32f32f64i32i32" -define float @foo__REAL(float %0) section "fn-foo__REAL:f32[f32]" { +define float @foo__REAL(float %0) section "fn-$RUSTY$foo__REAL:f32[f32]" { entry: %foo__REAL = alloca float, align 4 %in1 = alloca float, align 4 @@ -19,7 +19,7 @@ entry: ret float %foo__REAL_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %res_sint = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %res_int = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -56,4 +56,4 @@ entry: ret void } -declare double @foo__LREAL(double) section "fn-foo__LREAL:f64[f64]" +declare double @foo__LREAL(double) section "fn-$RUSTY$foo__LREAL:f64[f64]" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap index fa1248d4855..e60815a9c2a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_call_gets_cast_to_biggest_type.snap @@ -5,7 +5,7 @@ expression: codegen(src) ; ModuleID = 'main' source_filename = "main" -define double @main() section "fn-main:f64" { +define double @main() section "fn-$RUSTY$main:f64" { entry: %main = alloca double, align 8 store double 0.000000e+00, double* %main, align 8 @@ -25,4 +25,4 @@ entry: ret double %main_ret } -declare double @MAX__LREAL(i32, double*) section "fn-MAX__LREAL:f64" +declare double @MAX__LREAL(i32, double*) section "fn-$RUSTY$MAX__LREAL:f64" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_function_call_generates_real_type_call.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_function_call_generates_real_type_call.snap index 06744fe4a59..e689ca4ee8c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_function_call_generates_real_type_call.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_function_call_generates_real_type_call.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i16i16" -define i32 @MAX__DINT(i32 %0, i32 %1) section "fn-MAX__DINT:i32[i32][i32]" { +define i32 @MAX__DINT(i32 %0, i32 %1) section "fn-$RUSTY$MAX__DINT:i32[i32][i32]" { entry: %MAX__DINT = alloca i32, align 4 %in1 = alloca i32, align 4 @@ -21,7 +21,7 @@ entry: ret i32 %MAX__DINT_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -32,4 +32,4 @@ entry: ret void } -declare i16 @MAX__INT(i16, i16) section "fn-MAX__INT:i16[i16][i16]" +declare i16 @MAX__INT(i16, i16) section "fn-$RUSTY$MAX__INT:i16[i16][i16]" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_output_parameter.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_output_parameter.snap index f0b16563c7c..800a20c0765 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_output_parameter.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__generics_test__generic_output_parameter.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i16i16i64" -define i16 @foo__INT(i64 %0, i16* %1) section "fn-foo__INT:i16[i64][pi16]" { +define i16 @foo__INT(i64 %0, i16* %1) section "fn-$RUSTY$foo__INT:i16[i64][pi16]" { entry: %foo__INT = alloca i16, align 2 %in1 = alloca i64, align 8 @@ -21,7 +21,7 @@ entry: ret i16 %foo__INT_ret } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %theInt = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %iResult = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_in_module.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_in_module.snap index 41c47d74c2a..51630a2755a 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_in_module.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_in_module.snap @@ -7,7 +7,7 @@ source_filename = "myStruct.st" %myStruct = type { i32, i16* } -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r2i32pi16" ; ModuleID = 'prog.st' source_filename = "prog.st" @@ -15,10 +15,10 @@ source_filename = "prog.st" %prog = type { %myStruct.1 } %myStruct.1 = type { i32, i16* } -@prog_instance = global %prog zeroinitializer -@__myStruct__init = external global %myStruct.1 +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r1r2i32pi16" +@__myStruct__init = external global %myStruct.1, section "var-$RUSTY$__myStruct__init:r2i32pi16" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %x = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_no_deps_in_module.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_no_deps_in_module.snap index 65414424ad0..c988a330045 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_no_deps_in_module.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_defined_in_external_file_no_deps_in_module.snap @@ -7,16 +7,16 @@ source_filename = "myStruct.st" %myStruct = type { i32, i16* } -@__myStruct__init = unnamed_addr constant %myStruct { i32 20, i16* null } +@__myStruct__init = unnamed_addr constant %myStruct { i32 20, i16* null }, section "var-$RUSTY$__myStruct__init:r2i32pi16" ; ModuleID = 'prog.st' source_filename = "prog.st" %prog = type { i32 } -@prog_instance = global %prog zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r1i32" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %x = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_initialized_in_external_file_in_module.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_initialized_in_external_file_in_module.snap index 6c5e306f9dc..dd5914128e6 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_initialized_in_external_file_in_module.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__datatype_initialized_in_external_file_in_module.snap @@ -10,9 +10,9 @@ source_filename = "prog.st" %prog = type { i16 } -@prog_instance = global %prog { i16 5 } +@prog_instance = global %prog { i16 5 }, section "var-$RUSTY$prog_instance:r1i16" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %x = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__enum_referenced_in_fb_nested.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__enum_referenced_in_fb_nested.snap index 0868c261e60..72d74b90c36 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__enum_referenced_in_fb_nested.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__enum_referenced_in_fb_nested.snap @@ -5,18 +5,18 @@ expression: "codegen_multi(units, crate::DebugLevel::None).join(\"\\n\")" ; ModuleID = 'myEnum.st' source_filename = "myEnum.st" -@myEnum.a = unnamed_addr constant i32 1 -@myEnum.b = unnamed_addr constant i32 2 -@myEnum.c = unnamed_addr constant i32 3 +@myEnum.a = unnamed_addr constant i32 1, section "var-$RUSTY$a:e3i32" +@myEnum.b = unnamed_addr constant i32 2, section "var-$RUSTY$b:e3i32" +@myEnum.c = unnamed_addr constant i32 3, section "var-$RUSTY$c:e3i32" ; ModuleID = 'fb.st' source_filename = "fb.st" %fb = type { i32 } -@__fb__init = unnamed_addr constant %fb zeroinitializer +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r1e3i32" -define void @fb(%fb* %0) section "fn-fb:v" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v" { entry: %x = getelementptr inbounds %fb, %fb* %0, i32 0, i32 0 ret void @@ -28,10 +28,10 @@ source_filename = "myStruct.st" %myStruct = type { %fb.2 } %fb.2 = type { i32 } -@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer -@__fb__init = external global %fb.2 +@__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r1r1e3i32" +@__fb__init = external global %fb.2, section "var-$RUSTY$__fb__init:r1e3i32" -declare void @fb(%fb.2*) section "fn-fb:v" +declare void @fb(%fb.2*) section "fn-$RUSTY$fb:v" ; ModuleID = 'fb2.st' source_filename = "fb2.st" @@ -40,26 +40,26 @@ source_filename = "fb2.st" %myStruct.4 = type { %fb.5 } %fb.5 = type { i32 } -@__fb2__init = unnamed_addr constant %fb2 zeroinitializer -@__myStruct__init = external global %myStruct.4 -@__fb__init = external global %fb.5 +@__fb2__init = unnamed_addr constant %fb2 zeroinitializer, section "var-$RUSTY$__fb2__init:r1r1r1e3i32" +@__myStruct__init = external global %myStruct.4, section "var-$RUSTY$__myStruct__init:r1r1e3i32" +@__fb__init = external global %fb.5, section "var-$RUSTY$__fb__init:r1e3i32" -define void @fb2(%fb2* %0) section "fn-fb2:v" { +define void @fb2(%fb2* %0) section "fn-$RUSTY$fb2:v" { entry: %x = getelementptr inbounds %fb2, %fb2* %0, i32 0, i32 0 ret void } -declare void @fb(%fb.5*) section "fn-fb:v" +declare void @fb(%fb.5*) section "fn-$RUSTY$fb:v" ; ModuleID = 'fb3.st' source_filename = "fb3.st" %fb3 = type {} -@__fb3__init = unnamed_addr constant %fb3 zeroinitializer +@__fb3__init = unnamed_addr constant %fb3 zeroinitializer, section "var-$RUSTY$__fb3__init:r0" -define void @fb3(%fb3* %0) section "fn-fb3:v" { +define void @fb3(%fb3* %0) section "fn-$RUSTY$fb3:v" { entry: ret void } diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__function_defined_in_external_file.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__function_defined_in_external_file.snap index d25ccf90a35..f0db85384b1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__function_defined_in_external_file.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__function_defined_in_external_file.snap @@ -5,7 +5,7 @@ expression: "codegen_multi(units, crate::DebugLevel::None).join(\"\\n\")" ; ModuleID = 'func.st' source_filename = "func.st" -define i32 @func() section "fn-func:i32" { +define i32 @func() section "fn-$RUSTY$func:i32" { entry: %func = alloca i32, align 4 store i32 0, i32* %func, align 4 @@ -18,9 +18,9 @@ source_filename = "fb.st" %fb = type {} -@__fb__init = unnamed_addr constant %fb zeroinitializer +@__fb__init = unnamed_addr constant %fb zeroinitializer, section "var-$RUSTY$__fb__init:r0" -define void @fb(%fb* %0) section "fn-fb:v" { +define void @fb(%fb* %0) section "fn-$RUSTY$fb:v" { entry: ret void } @@ -30,9 +30,9 @@ source_filename = "prg.st" %prg = type { i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 ret void @@ -43,9 +43,9 @@ source_filename = "prg2.st" %prg2 = type { i32 } -@prg2_instance = global %prg2 zeroinitializer +@prg2_instance = global %prg2 zeroinitializer, section "var-$RUSTY$prg2_instance:r1i32" -define void @prg2(%prg2* %0) section "fn-prg2:v" { +define void @prg2(%prg2* %0) section "fn-$RUSTY$prg2:v" { entry: %b = getelementptr inbounds %prg2, %prg2* %0, i32 0, i32 0 ret void @@ -59,12 +59,12 @@ source_filename = "prog.st" %prg.5 = type { i32 } %prg2.6 = type { i32 } -@prog_instance = global %prog zeroinitializer -@__fb__init = external global %fb.4 -@prg_instance = external global %prg.5 -@prg2_instance = external global %prg2.6 +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r1r0" +@__fb__init = external global %fb.4, section "var-$RUSTY$__fb__init:r0" +@prg_instance = external global %prg.5, section "var-$RUSTY$prg_instance:r1i32" +@prg2_instance = external global %prg2.6, section "var-$RUSTY$prg2_instance:r1i32" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %myFb = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %load_a = load i32, i32* getelementptr inbounds (%prg.5, %prg.5* @prg_instance, i32 0, i32 0), align 4 @@ -74,10 +74,10 @@ entry: ret void } -declare void @fb(%fb.4*) section "fn-fb:v" +declare void @fb(%fb.4*) section "fn-$RUSTY$fb:v" -declare void @prg(%prg.5*) section "fn-prg:v" +declare void @prg(%prg.5*) section "fn-$RUSTY$prg:v" -declare void @prg2(%prg2.6*) section "fn-prg2:v" +declare void @prg2(%prg2.6*) section "fn-$RUSTY$prg2:v" -declare i32 @func() section "fn-func:i32" +declare i32 @func() section "fn-$RUSTY$func:i32" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__global_value_from_different_file.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__global_value_from_different_file.snap index 9742323315d..1bc2997856f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__global_value_from_different_file.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__global_value_from_different_file.snap @@ -5,28 +5,28 @@ expression: "codegen_multi(units, crate::DebugLevel::None).join(\"\\n\")" ; ModuleID = 'g1.st' source_filename = "g1.st" -@x = global i32 6 -@d = external global i32 -@y = global i32 7 -@e = external global i32 +@x = global i32 6, section "var-$RUSTY$x:i32" +@d = external global i32, section "var-$RUSTY$d:i32" +@y = global i32 7, section "var-$RUSTY$y:i32" +@e = external global i32, section "var-$RUSTY$e:i32" ; ModuleID = 'g2.st' source_filename = "g2.st" -@c = unnamed_addr constant i32 5 -@d = unnamed_addr constant i32 6 -@e = unnamed_addr constant i32 7 +@c = unnamed_addr constant i32 5, section "var-$RUSTY$c:i32" +@d = unnamed_addr constant i32 6, section "var-$RUSTY$d:i32" +@e = unnamed_addr constant i32 7, section "var-$RUSTY$e:i32" ; ModuleID = 'prog.st' source_filename = "prog.st" %prog = type {} -@prog_instance = global %prog zeroinitializer -@c = external global i32 -@x = external global i32 +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r0" +@c = external global i32, section "var-$RUSTY$c:i32" +@x = external global i32, section "var-$RUSTY$x:i32" -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: store i32 7, i32* @x, align 4 ret void diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__struct_with_custom_init_in_different_file.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__struct_with_custom_init_in_different_file.snap index 08f55ab4cda..722b4754f87 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__struct_with_custom_init_in_different_file.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__multifile_codegen_tests__struct_with_custom_init_in_different_file.snap @@ -7,14 +7,14 @@ source_filename = "myStruct.st" %myStruct = type { i32, i16 } -@__myStruct__init = unnamed_addr constant %myStruct { i32 6, i16 2 } +@__myStruct__init = unnamed_addr constant %myStruct { i32 6, i16 2 }, section "var-$RUSTY$__myStruct__init:r2i32i16" ; ModuleID = 'myStruct2.st' source_filename = "myStruct2.st" %myStruct2 = type { i32, i16 } -@__myStruct2__init = unnamed_addr constant %myStruct2 { i32 6, i16 2 } +@__myStruct2__init = unnamed_addr constant %myStruct2 { i32 6, i16 2 }, section "var-$RUSTY$__myStruct2__init:r2i32i16" ; ModuleID = 'prog.st' source_filename = "prog.st" @@ -23,12 +23,12 @@ source_filename = "prog.st" %myStruct.2 = type { i32, i16 } %myStruct2.3 = type { i32, i16 } -@prog_instance = global %prog { %myStruct.2 { i32 5, i16 2 }, %myStruct2.3 { i32 6, i16 2 } } -@__myStruct__init = external global %myStruct.2 -@__myStruct2__init = external global %myStruct2.3 +@prog_instance = global %prog { %myStruct.2 { i32 5, i16 2 }, %myStruct2.3 { i32 6, i16 2 } }, section "var-$RUSTY$prog_instance:r2r2i32i16r2i32i16" +@__myStruct__init = external global %myStruct.2, section "var-$RUSTY$__myStruct__init:r2i32i16" +@__myStruct2__init = external global %myStruct2.3, section "var-$RUSTY$__myStruct2__init:r2i32i16" @__prog.x__init = unnamed_addr constant %myStruct.2 { i32 5, i16 2 } -define void @prog(%prog* %0) section "fn-prog:v" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v" { entry: %x = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %y = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_input_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_input_param.snap index 9f0a2624970..c9a5612cc4f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_input_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_input_param.snap @@ -8,17 +8,17 @@ source_filename = "main" %fb_t = type { i32, i32 } %main = type { %fb_t } -@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer -@main_instance = global %main zeroinitializer +@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer, section "var-$RUSTY$__fb_t__init:r2i32i32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1r2i32i32" -define void @fb_t(%fb_t* %0) section "fn-fb_t:v[i32][i32]" { +define void @fb_t(%fb_t* %0) section "fn-$RUSTY$fb_t:v[i32][i32]" { entry: %in1 = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 0 %in2 = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 1 ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %fb = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = getelementptr inbounds %fb_t, %fb_t* %fb, i32 0, i32 0 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_output_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_output_param.snap index a6cfbe4ab16..21a90da4c60 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_output_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__fb_accepts_empty_statement_as_output_param.snap @@ -8,17 +8,17 @@ source_filename = "main" %fb_t = type { i32, i32 } %main = type { %fb_t, i32 } -@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer -@main_instance = global %main zeroinitializer +@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer, section "var-$RUSTY$__fb_t__init:r2i32i32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2r2i32i32i32" -define void @fb_t(%fb_t* %0) section "fn-fb_t:v[i32][i32]" { +define void @fb_t(%fb_t* %0) section "fn-$RUSTY$fb_t:v[i32][i32]" { entry: %out1 = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 0 %out2 = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 1 ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %fb = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_input_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_input_param.snap index 39324edd55e..c09ca8415aa 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_input_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_input_param.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @foo(i32 %0, i32 %1) section "fn-foo:v[i32][i32]" { +define void @foo(i32 %0, i32 %1) section "fn-$RUSTY$foo:v[i32][i32]" { entry: %in1 = alloca i32, align 4 store i32 %0, i32* %in1, align 4 @@ -18,7 +18,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %1 = alloca i32, align 4 %2 = load i32, i32* %1, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_output_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_output_param.snap index 52e8f828de7..77bd2105681 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_output_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_accepts_empty_statement_as_output_param.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1i32" -define void @foo(i32* %0, i32* %1) section "fn-foo:v[pi32][pi32]" { +define void @foo(i32* %0, i32* %1) section "fn-$RUSTY$foo:v[pi32][pi32]" { entry: %out1 = alloca i32*, align 8 store i32* %0, i32** %out1, align 8 @@ -18,7 +18,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca i32, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_all_parameters_assigned.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_all_parameters_assigned.snap index 094ab12b375..7f1397cbf19 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_all_parameters_assigned.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_all_parameters_assigned.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_default_value_parameter_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_default_value_parameter_type.snap index bfc66e6526f..1ab6960d563 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_default_value_parameter_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_default_value_parameter_type.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2, i32* %3) section "fn-foo:i32[i32][pi32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2, i32* %3) section "fn-$RUSTY$foo:i32[i32][pi32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -25,7 +25,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_inout_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_inout_assignment.snap index 1e544425eed..ce8d64e4d17 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_inout_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_inout_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_input_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_input_assignment.snap index b57f573c602..1f61d44c229 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_input_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_input_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_assignment.snap index ea03ab08ecb..4d4a4078796 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_default_value_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_default_value_assignment.snap index 0aa2e8f3429..ef1bc546979 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_default_value_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_empty_output_default_value_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_inout_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_inout_assignment.snap index 1e544425eed..ce8d64e4d17 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_inout_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_inout_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_assignment.snap index b57f573c602..1f61d44c229 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_default_value_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_default_value_assignment.snap index 4401729c257..81994a15703 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_default_value_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_input_default_value_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_assignment.snap index ea03ab08ecb..4d4a4078796 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_default_value_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_default_value_assignment.snap index 0aa2e8f3429..ef1bc546979 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_default_value_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__function_missing_output_default_value_assignment.snap @@ -7,9 +7,9 @@ source_filename = "main" %main = type { i32, i32, i32 } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-foo:i32[i32][pi32][pi32]" { +define i32 @foo(i32 %0, i32* %1, i32* %2) section "fn-$RUSTY$foo:i32[i32][pi32][pi32]" { entry: %foo = alloca i32, align 4 %input1 = alloca i32, align 4 @@ -23,7 +23,7 @@ entry: ret i32 %foo_ret } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__parameters_behind_function_block_pointer_are_assigned_to.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__parameters_behind_function_block_pointer_are_assigned_to.snap index 185a060f5b8..997d9285978 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__parameters_behind_function_block_pointer_are_assigned_to.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__parameters_behind_function_block_pointer_are_assigned_to.snap @@ -8,10 +8,10 @@ source_filename = "main" %main = type { %file_t, %file_t* } %file_t = type { i8, i8 } -@main_instance = global %main zeroinitializer -@__file_t__init = unnamed_addr constant %file_t zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2r2u8u8pr2u8u8" +@__file_t__init = unnamed_addr constant %file_t zeroinitializer, section "var-$RUSTY$__file_t__init:r2u8u8" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %file = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %FileOpen = getelementptr inbounds %main, %main* %0, i32 0, i32 1 @@ -23,7 +23,7 @@ entry: ret void } -define void @file_t(%file_t* %0) section "fn-file_t:v[u8][u8]" { +define void @file_t(%file_t* %0) section "fn-$RUSTY$file_t:v[u8][u8]" { entry: %var1 = getelementptr inbounds %file_t, %file_t* %0, i32 0, i32 0 %var2 = getelementptr inbounds %file_t, %file_t* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_input_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_input_param.snap index 31f71c8838b..461ca281a03 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_input_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_input_param.snap @@ -8,17 +8,17 @@ source_filename = "main" %prog = type { i32, i32 } %main = type {} -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r2i32i32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r0" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32]" { entry: %in1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %in2 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: store i32 1, i32* getelementptr inbounds (%prog, %prog* @prog_instance, i32 0, i32 0), align 4 call void @prog(%prog* @prog_instance) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_output_param.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_output_param.snap index 093ab00e9f2..72fae89445f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_output_param.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_accepts_empty_statement_as_output_param.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32 } %main = type { i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r2i32i32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32]" { entry: %out1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %out2 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -20,7 +20,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 call void @prog(%prog* @prog_instance) diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_explicit.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_explicit.snap index 1dd9d67c128..d4904984eec 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_explicit.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_explicit.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32, i32* } %main = type { i32, i32, i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r3i32i32pi32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32][pi32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32][pi32]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -19,7 +19,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_implicit.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_implicit.snap index 35d2ffb07af..aadcc395ccc 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_implicit.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_all_parameters_assigned_implicit.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32, i32* } %main = type { i32, i32, i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r3i32i32pi32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32][pi32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32][pi32]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -19,7 +19,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_empty_inout_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_empty_inout_assignment.snap index 5754af5b20f..633ef5775a5 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_empty_inout_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_empty_inout_assignment.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32, i32* } %main = type { i32, i32, i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r3i32i32pi32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32][pi32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32][pi32]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -19,7 +19,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_input_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_input_assignment.snap index ebae600179e..7b3e689396d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_input_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_input_assignment.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32, i32* } %main = type { i32, i32, i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r3i32i32pi32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32][pi32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32][pi32]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -19,7 +19,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_output_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_output_assignment.snap index 87d98a06417..296ca297db4 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_output_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__program_missing_output_assignment.snap @@ -8,10 +8,10 @@ source_filename = "main" %prog = type { i32, i32, i32* } %main = type { i32, i32, i32 } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r3i32i32pi32" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r3i32i32i32" -define void @prog(%prog* %0) section "fn-prog:v[i32][i32][pi32]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[i32][i32][pi32]" { entry: %input1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -19,7 +19,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %var1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %var2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__var_in_out_params_can_be_out_of_order.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__var_in_out_params_can_be_out_of_order.snap index ec2c998881e..56d71b38e2f 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__var_in_out_params_can_be_out_of_order.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__parameters_tests__var_in_out_params_can_be_out_of_order.snap @@ -8,10 +8,10 @@ source_filename = "main" %mainProg = type { %fb_t, i8, i8 } %fb_t = type { i8, i8, i8*, i8, i8* } -@mainProg_instance = global %mainProg zeroinitializer -@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer +@mainProg_instance = global %mainProg zeroinitializer, section "var-$RUSTY$mainProg_instance:r3r5u8u8pu8u8pu8u8u8" +@__fb_t__init = unnamed_addr constant %fb_t zeroinitializer, section "var-$RUSTY$__fb_t__init:r5u8u8pu8u8pu8" -define void @mainProg(%mainProg* %0) section "fn-mainProg:v" { +define void @mainProg(%mainProg* %0) section "fn-$RUSTY$mainProg:v" { entry: %fb = getelementptr inbounds %mainProg, %mainProg* %0, i32 0, i32 0 %out1 = getelementptr inbounds %mainProg, %mainProg* %0, i32 0, i32 1 @@ -35,7 +35,7 @@ entry: ret void } -define void @fb_t(%fb_t* %0) section "fn-fb_t:v[u8][pu8][u8][pu8]" { +define void @fb_t(%fb_t* %0) section "fn-$RUSTY$fb_t:v[u8][pu8][u8][pu8]" { entry: %myVar = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 0 %myInput = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 1 @@ -45,7 +45,7 @@ entry: ret void } -define void @fb_t.foo(%fb_t* %0) section "fn-fb_t.foo:v" { +define void @fb_t.foo(%fb_t* %0) section "fn-$RUSTY$fb_t.foo:v" { entry: %myVar = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 0 %myInput = getelementptr inbounds %fb_t, %fb_t* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__bitaccess_generated_as_rsh_and_trunc_i1.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__bitaccess_generated_as_rsh_and_trunc_i1.snap index a339d326d61..e9e2500aabd 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__bitaccess_generated_as_rsh_and_trunc_i1.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__bitaccess_generated_as_rsh_and_trunc_i1.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__byteaccess_generated_as_rsh_and_trunc_i8.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__byteaccess_generated_as_rsh_and_trunc_i8.snap index 607a355c179..867df6704bb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__byteaccess_generated_as_rsh_and_trunc_i8.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__byteaccess_generated_as_rsh_and_trunc_i8.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8u32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__dwordaccess_generated_as_rsh_and_trunc_i32.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__dwordaccess_generated_as_rsh_and_trunc_i32.snap index 8c93248cf29..b3afe4628db 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__dwordaccess_generated_as_rsh_and_trunc_i32.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__dwordaccess_generated_as_rsh_and_trunc_i32.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u32u64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__floating_point_type_casting.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__floating_point_type_casting.snap index a95abc87da0..1f93b11da81 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__floating_point_type_casting.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__floating_point_type_casting.snap @@ -5,7 +5,7 @@ expression: result ; ModuleID = 'main' source_filename = "main" -define i32 @fn() section "fn-fn:i32" { +define i32 @fn() section "fn-$RUSTY$fn:i32" { entry: %fn = alloca i32, align 4 %a = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_aliased_string.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_aliased_string.snap index 36383987b3b..8932121af18 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_aliased_string.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_aliased_string.snap @@ -5,9 +5,9 @@ expression: result ; ModuleID = 'main' source_filename = "main" -declare void @CONCAT([1025 x i8]*, i8*, i8*) section "fn-CONCAT:s8u1025[s8u1025][s8u1025]" +declare void @CONCAT([1025 x i8]*, i8*, i8*) section "fn-$RUSTY$CONCAT:s8u1025[s8u1025][s8u1025]" -define i8 @LIST_ADD(i8* %0, i8* %1) section "fn-LIST_ADD:u8[s8u1001][s8u2]" { +define i8 @LIST_ADD(i8* %0, i8* %1) section "fn-$RUSTY$LIST_ADD:u8[s8u1001][s8u2]" { entry: %LIST_ADD = alloca i8, align 1 %INS = alloca [1001 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_string.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_string.snap index 36383987b3b..8932121af18 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_string.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__function_result_assignment_on_string.snap @@ -5,9 +5,9 @@ expression: result ; ModuleID = 'main' source_filename = "main" -declare void @CONCAT([1025 x i8]*, i8*, i8*) section "fn-CONCAT:s8u1025[s8u1025][s8u1025]" +declare void @CONCAT([1025 x i8]*, i8*, i8*) section "fn-$RUSTY$CONCAT:s8u1025[s8u1025][s8u1025]" -define i8 @LIST_ADD(i8* %0, i8* %1) section "fn-LIST_ADD:u8[s8u1001][s8u2]" { +define i8 @LIST_ADD(i8* %0, i8* %1) section "fn-$RUSTY$LIST_ADD:u8[s8u1001][s8u2]" { entry: %LIST_ADD = alloca i8, align 1 %INS = alloca [1001 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__nested_bitwise_access.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__nested_bitwise_access.snap index 53c5974e89e..21697941632 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__nested_bitwise_access.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__nested_bitwise_access.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8u64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__variable_based_bitwise_access.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__variable_based_bitwise_access.snap index 66581e44377..ff8e6e1eff6 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__variable_based_bitwise_access.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__variable_based_bitwise_access.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8, i16, i16 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r4u8u8i16i16" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__wordaccess_generated_as_rsh_and_trunc_i16.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__wordaccess_generated_as_rsh_and_trunc_i16.snap index 846ec42e0b9..52722c634fe 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__wordaccess_generated_as_rsh_and_trunc_i16.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__statement_codegen_test__wordaccess_generated_as_rsh_and_trunc_i16.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u16u32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__casted_string_assignment_uses_memcpy.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__casted_string_assignment_uses_memcpy.snap index c22cb172237..9acdab89c7e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__casted_string_assignment_uses_memcpy.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__casted_string_assignment_uses_memcpy.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { [81 x i8], [81 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u81s16u81" @utf08_literal_0 = private unnamed_addr constant [4 x i8] c"abc\00" @utf16_literal_0 = private unnamed_addr constant [4 x i16] [i16 97, i16 98, i16 99, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returning_generic_string_should_return_by_ref.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returning_generic_string_should_return_by_ref.snap index 196004e2c04..29fa2da807d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returning_generic_string_should_return_by_ref.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returning_generic_string_should_return_by_ref.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [61 x i8], [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2s8u61s8u81" @utf08_literal_0 = private unnamed_addr constant [4 x i8] c"abc\00" -define void @MID__STRING([81 x i8]* %0, i8* %1, i32 %2, i32 %3) section "fn-MID__STRING:s8u81[ps8u81][i32][i32]" { +define void @MID__STRING([81 x i8]* %0, i8* %1, i32 %2, i32 %3) section "fn-$RUSTY$MID__STRING:s8u81[ps8u81][i32][i32]" { entry: %MID__STRING = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %MID__STRING, align 8 @@ -29,7 +29,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v[s8u61][s8u81]" { +define void @main(%main* %0) section "fn-$RUSTY$main:v[s8u61][s8u81]" { entry: %fmt = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returns_a_literal_string.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returns_a_literal_string.snap index 46621822794..bdc1540913e 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returns_a_literal_string.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_returns_a_literal_string.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [4 x i8] c"abc\00" -define void @ret([81 x i8]* %0) section "fn-ret:s8u81" { +define void @ret([81 x i8]* %0) section "fn-$RUSTY$ret:s8u81" { entry: %ret = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %ret, align 8 @@ -23,7 +23,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %str = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_takes_string_paramter_and_returns_string.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_takes_string_paramter_and_returns_string.snap index f6f317c2fd4..385f0cc4706 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_takes_string_paramter_and_returns_string.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_takes_string_paramter_and_returns_string.snap @@ -7,10 +7,10 @@ source_filename = "main" %main = type { [81 x i8] } -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [154 x i8] c"abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc\00" -define void @read_string([81 x i8]* %0, i8* %1) section "fn-read_string:s8u81[s8u81]" { +define void @read_string([81 x i8]* %0, i8* %1) section "fn-$RUSTY$read_string:s8u81[s8u81]" { entry: %read_string = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %read_string, align 8 @@ -28,7 +28,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %text1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_var_constant_strings_should_be_collected_as_literals.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_var_constant_strings_should_be_collected_as_literals.snap index abd14006e4b..9e9c351040b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_var_constant_strings_should_be_collected_as_literals.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__function_var_constant_strings_should_be_collected_as_literals.snap @@ -10,7 +10,7 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [2 x i8] c"#\00" @utf08_literal_1 = private unnamed_addr constant [2 x i8] c"*\00" -define i64 @FSTRING_TO_DT() section "fn-FSTRING_TO_DT:v" { +define i64 @FSTRING_TO_DT() section "fn-$RUSTY$FSTRING_TO_DT:i64" { entry: %FSTRING_TO_DT = alloca i64, align 8 %ignore = alloca [2 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__nested_struct_initialization_of_multi_dim_string_arrays.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__nested_struct_initialization_of_multi_dim_string_arrays.snap index 3a44ecd3b04..e9a7ca8dc58 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__nested_struct_initialization_of_multi_dim_string_arrays.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__nested_struct_initialization_of_multi_dim_string_arrays.snap @@ -7,6 +7,5 @@ source_filename = "main" %CONSTANTS_LANGUAGE = type { i16, i16, [21 x [11 x i8]], [21 x [3 x i8]], [36 x [11 x i8]], [36 x [4 x i8]], [48 x [4 x i8]] } -@x = global %CONSTANTS_LANGUAGE { i16 1, i16 3, [21 x [11 x i8]] [[11 x i8] c"Monday\00\00\00\00\00", [11 x i8] c"Tuesday\00\00\00\00", [11 x i8] c"Wednesday\00\00", [11 x i8] c"Thursday\00\00\00", [11 x i8] c"Friday\00\00\00\00\00", [11 x i8] c"Saturday\00\00\00", [11 x i8] c"Sunday\00\00\00\00\00", [11 x i8] c"Montag\00\00\00\00\00", [11 x i8] c"Dienstag\00\00\00", [11 x i8] c"Mittwoch\00\00\00", [11 x i8] c"Donnerstag\00", [11 x i8] c"Freitag\00\00\00\00", [11 x i8] c"Samstag\00\00\00\00", [11 x i8] c"Sonntag\00\00\00\00", [11 x i8] c"Lundi\00\00\00\00\00\00", [11 x i8] c"Mardi\00\00\00\00\00\00", [11 x i8] c"Mercredi\00\00\00", [11 x i8] c"Jeudi\00\00\00\00\00\00", [11 x i8] c"Vendredi\00\00\00", [11 x i8] c"Samedi\00\00\00\00\00", [11 x i8] c"Dimanche\00\00\00"], [21 x [3 x i8]] [[3 x i8] c"Mo\00", [3 x i8] c"Tu\00", [3 x i8] c"We\00", [3 x i8] c"Th\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"Su\00", [3 x i8] c"Mo\00", [3 x i8] c"Di\00", [3 x i8] c"Mi\00", [3 x i8] c"Do\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"So\00", [3 x i8] c"Lu\00", [3 x i8] c"Ma\00", [3 x i8] c"Me\00", [3 x i8] c"Je\00", [3 x i8] c"Ve\00", [3 x i8] c"Sa\00", [3 x i8] c"Di\00"], [36 x [11 x i8]] [[11 x i8] c"January\00\00\00\00", [11 x i8] c"February\00\00\00", [11 x i8] c"March\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"May\00\00\00\00\00\00\00\00", [11 x i8] c"June\00\00\00\00\00\00\00", [11 x i8] c"July\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"October\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"December\00\00\00", [11 x i8] c"Januar\00\00\00\00\00", [11 x i8] c"Februar\00\00\00\00", [11 x i8] c"M\C3\A4rz\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juni\00\00\00\00\00\00\00", [11 x i8] c"Juli\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"Oktober\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"Dezember\00\00\00", [11 x i8] c"Janvier\00\00\00\00", [11 x i8] c"F\C3\A9vrier\00\00\00", [11 x i8] c"mars\00\00\00\00\00\00\00", [11 x i8] c"Avril\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juin\00\00\00\00\00\00\00", [11 x i8] c"Juillet\00\00\00\00", [11 x i8] c"Ao\C3\BBt\00\00\00\00\00\00", [11 x i8] c"Septembre\00\00", [11 x i8] c"Octobre\00\00\00\00", [11 x i8] c"Novembre\00\00\00", [11 x i8] c"Decembre\00\00\00"], [36 x [4 x i8]] [[4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mar\00", [4 x i8] c"Apr\00", [4 x i8] c"May\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00", [4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mrz\00", [4 x i8] c"Apr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Okt\00", [4 x i8] c"Nov\00", [4 x i8] c"Dez\00", [4 x i8] c"Jan\00", [4 x i8] c"Fev\00", [4 x i8] c"Mar\00", [4 x i8] c"Avr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aou\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00"], [48 x [4 x i8]] [[4 x i8] c"N\00\00\00", [4 x i8] c"NNE\00", [4 x i8] c"NE\00\00", [4 x i8] c"ENE\00", [4 x i8] c"E\00\00\00", [4 x i8] c"ESE\00", [4 x i8] c"SE\00\00", [4 x i8] c"SSE\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00"] } -@__CONSTANTS_LANGUAGE__init = unnamed_addr constant %CONSTANTS_LANGUAGE { i16 1, i16 3, [21 x [11 x i8]] [[11 x i8] c"Monday\00\00\00\00\00", [11 x i8] c"Tuesday\00\00\00\00", [11 x i8] c"Wednesday\00\00", [11 x i8] c"Thursday\00\00\00", [11 x i8] c"Friday\00\00\00\00\00", [11 x i8] c"Saturday\00\00\00", [11 x i8] c"Sunday\00\00\00\00\00", [11 x i8] c"Montag\00\00\00\00\00", [11 x i8] c"Dienstag\00\00\00", [11 x i8] c"Mittwoch\00\00\00", [11 x i8] c"Donnerstag\00", [11 x i8] c"Freitag\00\00\00\00", [11 x i8] c"Samstag\00\00\00\00", [11 x i8] c"Sonntag\00\00\00\00", [11 x i8] c"Lundi\00\00\00\00\00\00", [11 x i8] c"Mardi\00\00\00\00\00\00", [11 x i8] c"Mercredi\00\00\00", [11 x i8] c"Jeudi\00\00\00\00\00\00", [11 x i8] c"Vendredi\00\00\00", [11 x i8] c"Samedi\00\00\00\00\00", [11 x i8] c"Dimanche\00\00\00"], [21 x [3 x i8]] [[3 x i8] c"Mo\00", [3 x i8] c"Tu\00", [3 x i8] c"We\00", [3 x i8] c"Th\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"Su\00", [3 x i8] c"Mo\00", [3 x i8] c"Di\00", [3 x i8] c"Mi\00", [3 x i8] c"Do\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"So\00", [3 x i8] c"Lu\00", [3 x i8] c"Ma\00", [3 x i8] c"Me\00", [3 x i8] c"Je\00", [3 x i8] c"Ve\00", [3 x i8] c"Sa\00", [3 x i8] c"Di\00"], [36 x [11 x i8]] [[11 x i8] c"January\00\00\00\00", [11 x i8] c"February\00\00\00", [11 x i8] c"March\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"May\00\00\00\00\00\00\00\00", [11 x i8] c"June\00\00\00\00\00\00\00", [11 x i8] c"July\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"October\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"December\00\00\00", [11 x i8] c"Januar\00\00\00\00\00", [11 x i8] c"Februar\00\00\00\00", [11 x i8] c"M\C3\A4rz\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juni\00\00\00\00\00\00\00", [11 x i8] c"Juli\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"Oktober\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"Dezember\00\00\00", [11 x i8] c"Janvier\00\00\00\00", [11 x i8] c"F\C3\A9vrier\00\00\00", [11 x i8] c"mars\00\00\00\00\00\00\00", [11 x i8] c"Avril\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juin\00\00\00\00\00\00\00", [11 x i8] c"Juillet\00\00\00\00", [11 x i8] c"Ao\C3\BBt\00\00\00\00\00\00", [11 x i8] c"Septembre\00\00", [11 x i8] c"Octobre\00\00\00\00", [11 x i8] c"Novembre\00\00\00", [11 x i8] c"Decembre\00\00\00"], [36 x [4 x i8]] [[4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mar\00", [4 x i8] c"Apr\00", [4 x i8] c"May\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00", [4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mrz\00", [4 x i8] c"Apr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Okt\00", [4 x i8] c"Nov\00", [4 x i8] c"Dez\00", [4 x i8] c"Jan\00", [4 x i8] c"Fev\00", [4 x i8] c"Mar\00", [4 x i8] c"Avr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aou\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00"], [48 x [4 x i8]] [[4 x i8] c"N\00\00\00", [4 x i8] c"NNE\00", [4 x i8] c"NE\00\00", [4 x i8] c"ENE\00", [4 x i8] c"E\00\00\00", [4 x i8] c"ESE\00", [4 x i8] c"SE\00\00", [4 x i8] c"SSE\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00"] } - +@x = global %CONSTANTS_LANGUAGE { i16 1, i16 3, [21 x [11 x i8]] [[11 x i8] c"Monday\00\00\00\00\00", [11 x i8] c"Tuesday\00\00\00\00", [11 x i8] c"Wednesday\00\00", [11 x i8] c"Thursday\00\00\00", [11 x i8] c"Friday\00\00\00\00\00", [11 x i8] c"Saturday\00\00\00", [11 x i8] c"Sunday\00\00\00\00\00", [11 x i8] c"Montag\00\00\00\00\00", [11 x i8] c"Dienstag\00\00\00", [11 x i8] c"Mittwoch\00\00\00", [11 x i8] c"Donnerstag\00", [11 x i8] c"Freitag\00\00\00\00", [11 x i8] c"Samstag\00\00\00\00", [11 x i8] c"Sonntag\00\00\00\00", [11 x i8] c"Lundi\00\00\00\00\00\00", [11 x i8] c"Mardi\00\00\00\00\00\00", [11 x i8] c"Mercredi\00\00\00", [11 x i8] c"Jeudi\00\00\00\00\00\00", [11 x i8] c"Vendredi\00\00\00", [11 x i8] c"Samedi\00\00\00\00\00", [11 x i8] c"Dimanche\00\00\00"], [21 x [3 x i8]] [[3 x i8] c"Mo\00", [3 x i8] c"Tu\00", [3 x i8] c"We\00", [3 x i8] c"Th\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"Su\00", [3 x i8] c"Mo\00", [3 x i8] c"Di\00", [3 x i8] c"Mi\00", [3 x i8] c"Do\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"So\00", [3 x i8] c"Lu\00", [3 x i8] c"Ma\00", [3 x i8] c"Me\00", [3 x i8] c"Je\00", [3 x i8] c"Ve\00", [3 x i8] c"Sa\00", [3 x i8] c"Di\00"], [36 x [11 x i8]] [[11 x i8] c"January\00\00\00\00", [11 x i8] c"February\00\00\00", [11 x i8] c"March\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"May\00\00\00\00\00\00\00\00", [11 x i8] c"June\00\00\00\00\00\00\00", [11 x i8] c"July\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"October\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"December\00\00\00", [11 x i8] c"Januar\00\00\00\00\00", [11 x i8] c"Februar\00\00\00\00", [11 x i8] c"M\C3\A4rz\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juni\00\00\00\00\00\00\00", [11 x i8] c"Juli\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"Oktober\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"Dezember\00\00\00", [11 x i8] c"Janvier\00\00\00\00", [11 x i8] c"F\C3\A9vrier\00\00\00", [11 x i8] c"mars\00\00\00\00\00\00\00", [11 x i8] c"Avril\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juin\00\00\00\00\00\00\00", [11 x i8] c"Juillet\00\00\00\00", [11 x i8] c"Ao\C3\BBt\00\00\00\00\00\00", [11 x i8] c"Septembre\00\00", [11 x i8] c"Octobre\00\00\00\00", [11 x i8] c"Novembre\00\00\00", [11 x i8] c"Decembre\00\00\00"], [36 x [4 x i8]] [[4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mar\00", [4 x i8] c"Apr\00", [4 x i8] c"May\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00", [4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mrz\00", [4 x i8] c"Apr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Okt\00", [4 x i8] c"Nov\00", [4 x i8] c"Dez\00", [4 x i8] c"Jan\00", [4 x i8] c"Fev\00", [4 x i8] c"Mar\00", [4 x i8] c"Avr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aou\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00"], [48 x [4 x i8]] [[4 x i8] c"N\00\00\00", [4 x i8] c"NNE\00", [4 x i8] c"NE\00\00", [4 x i8] c"ENE\00", [4 x i8] c"E\00\00\00", [4 x i8] c"ESE\00", [4 x i8] c"SE\00\00", [4 x i8] c"SSE\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00"] }, section "var-$RUSTY$x:r7i16i16as8u11as8u3as8u11as8u4as8u4" +@__CONSTANTS_LANGUAGE__init = unnamed_addr constant %CONSTANTS_LANGUAGE { i16 1, i16 3, [21 x [11 x i8]] [[11 x i8] c"Monday\00\00\00\00\00", [11 x i8] c"Tuesday\00\00\00\00", [11 x i8] c"Wednesday\00\00", [11 x i8] c"Thursday\00\00\00", [11 x i8] c"Friday\00\00\00\00\00", [11 x i8] c"Saturday\00\00\00", [11 x i8] c"Sunday\00\00\00\00\00", [11 x i8] c"Montag\00\00\00\00\00", [11 x i8] c"Dienstag\00\00\00", [11 x i8] c"Mittwoch\00\00\00", [11 x i8] c"Donnerstag\00", [11 x i8] c"Freitag\00\00\00\00", [11 x i8] c"Samstag\00\00\00\00", [11 x i8] c"Sonntag\00\00\00\00", [11 x i8] c"Lundi\00\00\00\00\00\00", [11 x i8] c"Mardi\00\00\00\00\00\00", [11 x i8] c"Mercredi\00\00\00", [11 x i8] c"Jeudi\00\00\00\00\00\00", [11 x i8] c"Vendredi\00\00\00", [11 x i8] c"Samedi\00\00\00\00\00", [11 x i8] c"Dimanche\00\00\00"], [21 x [3 x i8]] [[3 x i8] c"Mo\00", [3 x i8] c"Tu\00", [3 x i8] c"We\00", [3 x i8] c"Th\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"Su\00", [3 x i8] c"Mo\00", [3 x i8] c"Di\00", [3 x i8] c"Mi\00", [3 x i8] c"Do\00", [3 x i8] c"Fr\00", [3 x i8] c"Sa\00", [3 x i8] c"So\00", [3 x i8] c"Lu\00", [3 x i8] c"Ma\00", [3 x i8] c"Me\00", [3 x i8] c"Je\00", [3 x i8] c"Ve\00", [3 x i8] c"Sa\00", [3 x i8] c"Di\00"], [36 x [11 x i8]] [[11 x i8] c"January\00\00\00\00", [11 x i8] c"February\00\00\00", [11 x i8] c"March\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"May\00\00\00\00\00\00\00\00", [11 x i8] c"June\00\00\00\00\00\00\00", [11 x i8] c"July\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"October\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"December\00\00\00", [11 x i8] c"Januar\00\00\00\00\00", [11 x i8] c"Februar\00\00\00\00", [11 x i8] c"M\C3\A4rz\00\00\00\00\00\00", [11 x i8] c"April\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juni\00\00\00\00\00\00\00", [11 x i8] c"Juli\00\00\00\00\00\00\00", [11 x i8] c"August\00\00\00\00\00", [11 x i8] c"September\00\00", [11 x i8] c"Oktober\00\00\00\00", [11 x i8] c"November\00\00\00", [11 x i8] c"Dezember\00\00\00", [11 x i8] c"Janvier\00\00\00\00", [11 x i8] c"F\C3\A9vrier\00\00\00", [11 x i8] c"mars\00\00\00\00\00\00\00", [11 x i8] c"Avril\00\00\00\00\00\00", [11 x i8] c"Mai\00\00\00\00\00\00\00\00", [11 x i8] c"Juin\00\00\00\00\00\00\00", [11 x i8] c"Juillet\00\00\00\00", [11 x i8] c"Ao\C3\BBt\00\00\00\00\00\00", [11 x i8] c"Septembre\00\00", [11 x i8] c"Octobre\00\00\00\00", [11 x i8] c"Novembre\00\00\00", [11 x i8] c"Decembre\00\00\00"], [36 x [4 x i8]] [[4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mar\00", [4 x i8] c"Apr\00", [4 x i8] c"May\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00", [4 x i8] c"Jan\00", [4 x i8] c"Feb\00", [4 x i8] c"Mrz\00", [4 x i8] c"Apr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aug\00", [4 x i8] c"Sep\00", [4 x i8] c"Okt\00", [4 x i8] c"Nov\00", [4 x i8] c"Dez\00", [4 x i8] c"Jan\00", [4 x i8] c"Fev\00", [4 x i8] c"Mar\00", [4 x i8] c"Avr\00", [4 x i8] c"Mai\00", [4 x i8] c"Jun\00", [4 x i8] c"Jul\00", [4 x i8] c"Aou\00", [4 x i8] c"Sep\00", [4 x i8] c"Oct\00", [4 x i8] c"Nov\00", [4 x i8] c"Dec\00"], [48 x [4 x i8]] [[4 x i8] c"N\00\00\00", [4 x i8] c"NNE\00", [4 x i8] c"NE\00\00", [4 x i8] c"ENE\00", [4 x i8] c"E\00\00\00", [4 x i8] c"ESE\00", [4 x i8] c"SE\00\00", [4 x i8] c"SSE\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00", [4 x i8] c"N\00\00\00", [4 x i8] c"NNO\00", [4 x i8] c"NO\00\00", [4 x i8] c"ONO\00", [4 x i8] c"O\00\00\00", [4 x i8] c"OSO\00", [4 x i8] c"SO\00\00", [4 x i8] c"SSO\00", [4 x i8] c"S\00\00\00", [4 x i8] c"SSW\00", [4 x i8] c"SW\00\00", [4 x i8] c"WSW\00", [4 x i8] c"W\00\00\00", [4 x i8] c"WNW\00", [4 x i8] c"NW\00\00", [4 x i8] c"NNW\00"] }, section "var-$RUSTY$__CONSTANTS_LANGUAGE__init:r7i16i16as8u11as8u3as8u11as8u4as8u4" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_string_output.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_string_output.snap index a85faa2de55..3968ed43062 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_string_output.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_string_output.snap @@ -8,12 +8,12 @@ source_filename = "main" %prog = type { [81 x i8], [81 x i16] } %main = type { [7 x i8], [8 x i16] } -@prog_instance = global %prog zeroinitializer -@main_instance = global %main zeroinitializer +@prog_instance = global %prog zeroinitializer, section "var-$RUSTY$prog_instance:r2s8u81s16u81" +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2s8u7s16u8" @utf08_literal_0 = private unnamed_addr constant [7 x i8] c"string\00" @utf16_literal_0 = private unnamed_addr constant [8 x i16] [i16 119, i16 115, i16 116, i16 114, i16 105, i16 110, i16 103, i16 0] -define void @prog(%prog* %0) section "fn-prog:v[s8u81][s16u81]" { +define void @prog(%prog* %0) section "fn-$RUSTY$prog:v[s8u81][s16u81]" { entry: %output1 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 0 %output2 = getelementptr inbounds %prog, %prog* %0, i32 0, i32 1 @@ -24,7 +24,7 @@ entry: ret void } -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %y = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_casted_string_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_casted_string_assignment.snap index 3a57950c3bb..3f2af07b08b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_casted_string_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_casted_string_assignment.snap @@ -7,13 +7,13 @@ source_filename = "main" %prg = type { [81 x i8], [81 x i16] } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u81s16u81" @utf08_literal_0 = private unnamed_addr constant [12 x i8] c"im a genius\00" @utf08_literal_1 = private unnamed_addr constant [18 x i8] c"im a utf16 genius\00" @utf16_literal_0 = private unnamed_addr constant [12 x i16] [i16 105, i16 109, i16 32, i16 97, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] @utf16_literal_1 = private unnamed_addr constant [18 x i16] [i16 105, i16 109, i16 32, i16 97, i16 32, i16 117, i16 116, i16 102, i16 49, i16 54, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_string_type_assignment.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_string_type_assignment.snap index bef912eb1d3..73237fe8e02 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_string_type_assignment.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__program_with_string_type_assignment.snap @@ -7,14 +7,14 @@ source_filename = "main" %prg = type { [81 x i8], [100 x i8], [100 x i16] } -@prg_instance = global %prg { [81 x i8] zeroinitializer, [100 x i8] c"abc\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [100 x i16] [i16 97, i16 98, i16 99, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0] } -@__MyString__init = unnamed_addr constant [100 x i8] c"abc\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" -@__MyWString__init = unnamed_addr constant [100 x i16] [i16 97, i16 98, i16 99, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0] +@prg_instance = global %prg { [81 x i8] zeroinitializer, [100 x i8] c"abc\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", [100 x i16] [i16 97, i16 98, i16 99, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0] }, section "var-$RUSTY$prg_instance:r3s8u81s8u100s16u100" +@__MyString__init = unnamed_addr constant [100 x i8] c"abc\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", section "var-$RUSTY$__MyString__init:s8u100" +@__MyWString__init = unnamed_addr constant [100 x i16] [i16 97, i16 98, i16 99, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0], section "var-$RUSTY$__MyWString__init:s16u100" @utf08_literal_0 = private unnamed_addr constant [12 x i8] c"im a genius\00" @utf08_literal_1 = private unnamed_addr constant [17 x i8] c"im also a genius\00" @utf16_literal_0 = private unnamed_addr constant [17 x i16] [i16 105, i16 109, i16 32, i16 97, i16 108, i16 115, i16 111, i16 32, i16 97, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__simple_string_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__simple_string_test.snap index 8b1a844a790..942e6e48077 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__simple_string_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__simple_string_test.snap @@ -1,11 +1,9 @@ --- source: src/codegen/tests/string_tests.rs expression: result - --- ; ModuleID = 'main' source_filename = "main" -@str = global [21 x i8] zeroinitializer -@wstr = global [21 x i16] zeroinitializer - +@str = global [21 x i8] zeroinitializer, section "var-$RUSTY$str:s8u21" +@wstr = global [21 x i16] zeroinitializer, section "var-$RUSTY$wstr:s16u21" diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__string_function_parameters.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__string_function_parameters.snap index 29b9c8ae6a4..763d82a4f85 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__string_function_parameters.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__string_function_parameters.snap @@ -7,11 +7,11 @@ source_filename = "main" %prg = type { [11 x i8], [81 x i8] } -@prg_instance = global %prg { [11 x i8] c"hello\00\00\00\00\00\00", [81 x i8] zeroinitializer } +@prg_instance = global %prg { [11 x i8] c"hello\00\00\00\00\00\00", [81 x i8] zeroinitializer }, section "var-$RUSTY$prg_instance:r2s8u11s8u81" @__prg.s__init = unnamed_addr constant [11 x i8] c"hello\00\00\00\00\00\00" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" -define i16 @foo(i8* %0) section "fn-foo:i16[s8u81]" { +define i16 @foo(i8* %0) section "fn-$RUSTY$foo:i16[s8u81]" { entry: %foo = alloca i16, align 2 %s = alloca [81 x i8], align 1 @@ -27,7 +27,7 @@ buffer_block: ; No predecessors! ret i16 %foo_ret1 } -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %s = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable.snap index 16bcbdf9adc..b12538dbe8d 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable.snap @@ -8,7 +8,7 @@ source_filename = "main" @__FSTRING_TO_DT.ignore__init = unnamed_addr constant [2 x i8] c"*\00" @__FSTRING_TO_DT.fchar__init = unnamed_addr constant [2 x i8] c"#\00" -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[ps8u1025][ps8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[ps8u1025][ps8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca i8*, align 8 @@ -20,7 +20,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i64 @FSTRING_TO_DT() section "fn-FSTRING_TO_DT:v" { +define i64 @FSTRING_TO_DT() section "fn-$RUSTY$FSTRING_TO_DT:i64" { entry: %FSTRING_TO_DT = alloca i64, align 8 %ignore = alloca [2 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable_nonref.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable_nonref.snap index 4c7455e8c09..e9582efb1b9 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable_nonref.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__using_a_constant_var_string_should_be_memcpyable_nonref.snap @@ -8,7 +8,7 @@ source_filename = "main" @__FSTRING_TO_DT.ignore__init = unnamed_addr constant [2 x i8] c"*\00" @__FSTRING_TO_DT.fchar__init = unnamed_addr constant [2 x i8] c"#\00" -define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-STRING_EQUAL:u8[s8u1025][s8u1025]" { +define i8 @STRING_EQUAL(i8* %0, i8* %1) section "fn-$RUSTY$STRING_EQUAL:u8[s8u1025][s8u1025]" { entry: %STRING_EQUAL = alloca i8, align 1 %op1 = alloca [1025 x i8], align 1 @@ -24,7 +24,7 @@ entry: ret i8 %STRING_EQUAL_ret } -define i64 @FSTRING_TO_DT() section "fn-FSTRING_TO_DT:v" { +define i64 @FSTRING_TO_DT() section "fn-$RUSTY$FSTRING_TO_DT:i64" { entry: %FSTRING_TO_DT = alloca i64, align 8 %ignore = alloca [2 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_can_be_created.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_can_be_created.snap index 3f72b2b1ffa..f8a29a88a09 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_can_be_created.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_can_be_created.snap @@ -7,13 +7,13 @@ source_filename = "main" %prg = type { [16 x i8], [4 x i8], [16 x i16], [4 x i16] } -@prg_instance = global %prg { [16 x i8] zeroinitializer, [4 x i8] c"xyz\00", [16 x i16] zeroinitializer, [4 x i16] [i16 120, i16 121, i16 122, i16 0] } +@prg_instance = global %prg { [16 x i8] zeroinitializer, [4 x i8] c"xyz\00", [16 x i16] zeroinitializer, [4 x i16] [i16 120, i16 121, i16 122, i16 0] }, section "var-$RUSTY$prg_instance:r4s8u16s8u4s16u16s16u4" @__prg.z__init = unnamed_addr constant [4 x i8] c"xyz\00" @__prg.wz__init = unnamed_addr constant [4 x i16] [i16 120, i16 121, i16 122, i16 0] @utf08_literal_0 = private unnamed_addr constant [12 x i8] c"im a genius\00" @utf16_literal_0 = private unnamed_addr constant [12 x i16] [i16 105, i16 109, i16 32, i16 97, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_using_constants_can_be_created.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_using_constants_can_be_created.snap index 28e7166105c..c66d927edb0 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_using_constants_can_be_created.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_length_strings_using_constants_can_be_created.snap @@ -7,15 +7,15 @@ source_filename = "main" %prg = type { [16 x i8], [4 x i8], [31 x i16], [7 x i16] } -@LONG_STRING = unnamed_addr constant i16 15 -@SHORT_STRING = unnamed_addr constant i16 3 -@prg_instance = global %prg { [16 x i8] zeroinitializer, [4 x i8] c"xyz\00", [31 x i16] zeroinitializer, [7 x i16] [i16 120, i16 121, i16 122, i16 0, i16 0, i16 0, i16 0] } +@LONG_STRING = unnamed_addr constant i16 15, section "var-$RUSTY$LONG_STRING:i16" +@SHORT_STRING = unnamed_addr constant i16 3, section "var-$RUSTY$SHORT_STRING:i16" +@prg_instance = global %prg { [16 x i8] zeroinitializer, [4 x i8] c"xyz\00", [31 x i16] zeroinitializer, [7 x i16] [i16 120, i16 121, i16 122, i16 0, i16 0, i16 0, i16 0] }, section "var-$RUSTY$prg_instance:r4vvvv" @__prg.z__init = unnamed_addr constant [4 x i8] c"xyz\00" @__prg.wz__init = unnamed_addr constant [7 x i16] [i16 120, i16 121, i16 122, i16 0, i16 0, i16 0, i16 0] @utf08_literal_0 = private unnamed_addr constant [12 x i8] c"im a genius\00" @utf16_literal_0 = private unnamed_addr constant [12 x i16] [i16 105, i16 109, i16 32, i16 97, i16 32, i16 103, i16 101, i16 110, i16 105, i16 117, i16 115, i16 0] -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_string_assignment_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_string_assignment_test.snap index a9d938e4994..160ce6ed308 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_string_assignment_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__variable_string_assignment_test.snap @@ -7,10 +7,10 @@ source_filename = "main" %prg = type { [16 x i8], [31 x i8] } -@prg_instance = global %prg { [16 x i8] zeroinitializer, [31 x i8] c"xyz\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" } +@prg_instance = global %prg { [16 x i8] zeroinitializer, [31 x i8] c"xyz\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" }, section "var-$RUSTY$prg_instance:r2s8u16s8u31" @__prg.z__init = unnamed_addr constant [31 x i8] c"xyz\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__vartmp_string_init_test.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__vartmp_string_init_test.snap index 4fec55113e8..b18d8db47c2 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__vartmp_string_init_test.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__string_tests__vartmp_string_init_test.snap @@ -7,10 +7,10 @@ source_filename = "main" %prg = type {} -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u16s8u31" @__prg.z__init = unnamed_addr constant [31 x i8] c"xyz\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %y = alloca [16 x i8], align 1 %z = alloca [31 x i8], align 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__aliased_datatypes_respect_conversion_rules.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__aliased_datatypes_respect_conversion_rules.snap index d5c05a45978..c5e96b18bdb 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__aliased_datatypes_respect_conversion_rules.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__aliased_datatypes_respect_conversion_rules.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i8i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %c = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_larger_than_int_promote_the_second_operand.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_larger_than_int_promote_the_second_operand.snap index 404b889c93b..aeb30559df0 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_larger_than_int_promote_the_second_operand.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_larger_than_int_promote_the_second_operand.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i32, i64, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i32i64i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %c = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_smaller_than_dint_promoted_to_dint.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_smaller_than_dint_promoted_to_dint.snap index a339a3e731c..9217183a402 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_smaller_than_dint_promoted_to_dint.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__datatypes_smaller_than_dint_promoted_to_dint.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i8i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %c = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__even_all_sint_expressions_fallback_to_dint.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__even_all_sint_expressions_fallback_to_dint.snap index 61e0e8aa0be..be13838b668 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__even_all_sint_expressions_fallback_to_dint.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__even_all_sint_expressions_fallback_to_dint.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i8, i8 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i8i8i8" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %c = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_and_double_mix_converted_to_double.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_and_double_mix_converted_to_double.snap index 86ba11023ff..3645170b4a1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_and_double_mix_converted_to_double.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_and_double_mix_converted_to_double.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, double, double } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3f32f64f64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assigned_to_int_is_cast.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assigned_to_int_is_cast.snap index dc8cee115c1..1cc04585f94 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assigned_to_int_is_cast.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assigned_to_int_is_cast.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i16u16f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assinged_to_double_to_double.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assinged_to_double_to_double.snap index 93ff27bfd5f..6f9cd627e60 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assinged_to_double_to_double.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__float_assinged_to_double_to_double.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, double } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32f64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_assigned_to_float_is_cast.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_assigned_to_float_is_cast.snap index f46afe08414..a0d78252fef 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_assigned_to_float_is_cast.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_assigned_to_float_is_cast.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i16, i16, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i16u16f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_byte_promoted_on_compare_statement.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_byte_promoted_on_compare_statement.snap index 261e31be4a6..41368ecbee1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_byte_promoted_on_compare_statement.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_byte_promoted_on_compare_statement.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2u8i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_float_converted_to_double.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_float_converted_to_double.snap index 7f2f3d41147..5e02bd0f58c 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_float_converted_to_double.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_bigger_than_float_converted_to_double.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, i64 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2f32i64" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_smaller_or_equal_to_float_converted_to_float.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_smaller_or_equal_to_float_converted_to_float.snap index 70ec2025271..abcb8aca8a7 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_smaller_or_equal_to_float_converted_to_float.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__int_smaller_or_equal_to_float_converted_to_float.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { float, i16, float } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3f32i16f32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__numerical_promotion_for_variadic_functions_without_declaration.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__numerical_promotion_for_variadic_functions_without_declaration.snap index 6c790a5b78b..a6c9934fbf1 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__numerical_promotion_for_variadic_functions_without_declaration.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__numerical_promotion_for_variadic_functions_without_declaration.snap @@ -7,12 +7,12 @@ source_filename = "main" %main = type {} -@main_instance = global %main zeroinitializer +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4s8u81f32f64i16" @__main.s__init = unnamed_addr constant [81 x i8] c"\0A numbers: %f %f %f %d \0A \0A\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00" -declare i32 @printf(i8*, ...) section "fn-printf:i32[ps8u81]" +declare i32 @printf(i8*, ...) section "fn-$RUSTY$printf:i32[ps8u81]" -define void @main(%main* %0) section "fn-main:v" { +define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %s = alloca [81 x i8], align 1 %float = alloca float, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__small_int_varargs_get_promoted_while_32bit_and_higher_keep_their_type.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__small_int_varargs_get_promoted_while_32bit_and_higher_keep_their_type.snap index 6c986be051c..367285edf78 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__small_int_varargs_get_promoted_while_32bit_and_higher_keep_their_type.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__small_int_varargs_get_promoted_while_32bit_and_higher_keep_their_type.snap @@ -8,9 +8,9 @@ source_filename = "main" @utf08_literal_0 = private unnamed_addr constant [26 x i8] c"(d) result : %d %d %d %u\0A\00" @utf08_literal_1 = private unnamed_addr constant [27 x i8] c"(hd) result : %hd %hd %hd\0A\00" -declare i32 @printf(i8*, ...) section "fn-printf:i32[ps8u81]" +declare i32 @printf(i8*, ...) section "fn-$RUSTY$printf:i32[ps8u81]" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %out1 = alloca i16, align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__unsingned_datatypes_smaller_than_dint_promoted_to_dint.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__unsingned_datatypes_smaller_than_dint_promoted_to_dint.snap index d7d78e7b45e..f7c53cabc40 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__unsingned_datatypes_smaller_than_dint_promoted_to_dint.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__typesystem_test__unsingned_datatypes_smaller_than_dint_promoted_to_dint.snap @@ -7,9 +7,9 @@ source_filename = "main" %prg = type { i8, i32, i32 } -@prg_instance = global %prg zeroinitializer +@prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3u8i32i32" -define void @prg(%prg* %0) section "fn-prg:v" { +define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %c = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__consecutive_calls_with_differently_sized_arrays.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__consecutive_calls_with_differently_sized_arrays.snap index 4681fafeb19..7517e8f8193 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__consecutive_calls_with_differently_sized_arrays.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__consecutive_calls_with_differently_sized_arrays.snap @@ -7,9 +7,9 @@ source_filename = "main" %__foo_vla = type { i16*, [4 x i32] } -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai16ai32" -define i16 @foo(%__foo_vla* %0) section "fn-foo:i16[v]" { +define i16 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i16[r2pai16ai32]" { entry: %foo = alloca i16, align 2 %vla = alloca %__foo_vla, align 8 @@ -57,7 +57,7 @@ entry: ret i16 %foo_ret } -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %arr = alloca [60 x i16], align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__global_variable_passed_to_function_as_vla.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__global_variable_passed_to_function_as_vla.snap index 71d8b1c3389..188e363617b 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__global_variable_passed_to_function_as_vla.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__global_variable_passed_to_function_as_vla.snap @@ -7,10 +7,10 @@ source_filename = "main" %__foo_vla = type { i16*, [2 x i32] } -@arr = global [2 x i16] zeroinitializer -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@arr = global [2 x i16] zeroinitializer, section "var-$RUSTY$arr:ai16" +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai16ai32" -define i16 @foo(%__foo_vla* %0) section "fn-foo:i16[v]" { +define i16 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i16[r2pai16ai32]" { entry: %foo = alloca i16, align 2 %vla = alloca %__foo_vla, align 8 @@ -32,7 +32,7 @@ entry: ret i16 %foo_ret } -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 store i32 0, i32* %main, align 4 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__internal_vla_struct_is_generated_for_call_statements.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__internal_vla_struct_is_generated_for_call_statements.snap index 2c464533af1..d7cf5af6d39 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__internal_vla_struct_is_generated_for_call_statements.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__internal_vla_struct_is_generated_for_call_statements.snap @@ -7,9 +7,9 @@ source_filename = "main" %__foo_vla = type { i16*, [2 x i32] } -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai16ai32" -define void @foo(%__foo_vla* %0) section "fn-foo:v[v]" { +define void @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:v[r2pai16ai32]" { entry: %vla = alloca %__foo_vla, align 8 %1 = bitcast %__foo_vla* %vla to i8* @@ -18,7 +18,7 @@ entry: ret void } -define void @bar() section "fn-bar:v" { +define void @bar() section "fn-$RUSTY$bar:v" { entry: %arr = alloca [2 x i16], align 2 %0 = bitcast [2 x i16]* %arr to i8* diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__multi_dimensional_vla.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__multi_dimensional_vla.snap index 339ee6d6d3e..2d4e774ca82 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__multi_dimensional_vla.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__multi_dimensional_vla.snap @@ -7,9 +7,9 @@ source_filename = "main" %__foo_vla = type { i16*, [4 x i32] } -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai16ai32" -define i16 @foo(%__foo_vla* %0) section "fn-foo:i16[v]" { +define i16 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i16[r2pai16ai32]" { entry: %foo = alloca i16, align 2 %vla = alloca %__foo_vla, align 8 @@ -57,7 +57,7 @@ entry: ret i16 %foo_ret } -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %arr = alloca [20 x i16], align 2 diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__vla_read_access.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__vla_read_access.snap index a804f6e0897..8ec1aaee735 100644 --- a/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__vla_read_access.snap +++ b/src/codegen/tests/snapshots/rusty__codegen__tests__vla_tests__vla_read_access.snap @@ -7,9 +7,9 @@ source_filename = "main" %__foo_vla = type { i16*, [2 x i32] } -@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer +@____foo_vla__init = unnamed_addr constant %__foo_vla zeroinitializer, section "var-$RUSTY$____foo_vla__init:r2pai16ai32" -define i16 @foo(%__foo_vla* %0) section "fn-foo:i16[v]" { +define i16 @foo(%__foo_vla* %0) section "fn-$RUSTY$foo:i16[r2pai16ai32]" { entry: %foo = alloca i16, align 2 %vla = alloca %__foo_vla, align 8 @@ -32,7 +32,7 @@ entry: ret i16 %foo_ret } -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %arr = alloca [2 x i16], align 2 diff --git a/src/parser/tests.rs b/src/parser/tests.rs index 8ee0e295b62..f9879edf508 100644 --- a/src/parser/tests.rs +++ b/src/parser/tests.rs @@ -5,6 +5,7 @@ use plc_ast::{ use plc_source::source_location::SourceLocation; // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder +mod ast_visitor_tests; mod class_parser_tests; mod container_parser_tests; mod control_parser_tests; diff --git a/src/parser/tests/ast_visitor_tests.rs b/src/parser/tests/ast_visitor_tests.rs new file mode 100644 index 00000000000..c97533c520d --- /dev/null +++ b/src/parser/tests/ast_visitor_tests.rs @@ -0,0 +1,628 @@ +use plc_ast::{ + ast::LinkageType, + provider::IdProvider, + visitor::{AstVisitor, Walker}, +}; +use plc_source::source_location::SourceLocationFactory; + +use crate::{lexer, parser}; + +/// This is a simple visitor that collects all identifiers and literals in a given body +/// It is used by unit tests, to easily see if all identifiers (even the deeply nested ones) were visited +/// and therefore that all subtrees of the AST were visited. +/// +/// e.g. if we have a source code like this: +/// ``` +/// PROGRAM prg +/// foo (a := b, c => 4); +/// END_PROGRAM +/// ``` +/// The visitor should collect the following identifiers/literals: "foo", "a", "b", "c" and "4" +#[derive(Default)] +struct IdentifierCollector { + identifiers: Vec, +} + +impl AstVisitor for IdentifierCollector { + fn visit_identifier(&mut self, stmt: &str, _node: &plc_ast::ast::AstNode) { + self.identifiers.push(stmt.to_string()); + } + + fn visit_literal(&mut self, stmt: &plc_ast::literals::AstLiteral, _node: &plc_ast::ast::AstNode) { + self.identifiers.push(stmt.get_literal_value()); + } +} + +/// Helper function to create a vector of strings with all characters in the range from start to end +fn get_character_range(start: char, end: char) -> Vec { + (start as u8..=end as u8).map(|c| c as char).map(|c| c.to_string()).collect() +} + +/// Helper function to collect all identifiers in a given source code +/// using the IdentifierCollector visitor +fn collect_identifiers(src: &str) -> IdentifierCollector { + let mut visitor = IdentifierCollector::default(); + visit(src, &mut visitor); + visitor.identifiers.sort(); + visitor +} + +/// Helper function to visit a given source code with a given visitor +fn visit(src: &str, visitor: &mut impl AstVisitor) { + let id_provider = IdProvider::default(); + let (compilation_unit, _) = parser::parse( + lexer::lex_with_ids(src, id_provider.clone(), SourceLocationFactory::internal(src)), + LinkageType::Internal, + "test.st", + ); + + visitor.visit_compilation_unit(&compilation_unit) +} + +#[test] +fn test_visit_arithmetic_expressions() { + // GIVEN a source code with arithmetic expressions + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a; + b; + c := NOT d; + e := f MOD g; + h := (i / j / k - (l + m)) * n; + END_PROGRAM", + ); + // THEN we expect to also visit subexpressions in binary and unary expressions + assert_eq!(get_character_range('a', 'n'), visitor.identifiers); +} + +#[test] +fn test_visit_expression_list() { + // GIVEN a source code with an expression list + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a,b,c; + END_PROGRAM", + ); + // THEN we expect to visit all identifiers in the expression list + assert_eq!(get_character_range('a', 'c'), visitor.identifiers); +} + +#[test] +fn test_if_statement() { + // GIVEN a source code with an if statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + IF a THEN + b := c; + ELSIF d THEN + e := f; + ELSE + g := h; + END_IF; + END_PROGRAM", + ); + // THEN we expect to visit the condition, the body, the elseif condition and body and the else body + assert_eq!(get_character_range('a', 'h'), visitor.identifiers); +} + +#[test] +fn test_visit_for_loop_statement() { + // GIVEN a source code with a for loop statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + FOR a := b TO c BY d DO + e; + f; + END_FOR; + END_PROGRAM", + ); + // THEN we expect to visit the loop variable, the start, end and step expressions and the loop body + assert_eq!(get_character_range('a', 'f'), visitor.identifiers); +} + +#[test] +fn test_visit_while_loop_statement() { + // GIVEN a source code with a while loop statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + WHILE a < b DO + c; + d; + END_WHILE; + END_PROGRAM", + ); + // THEN we expect to visit the condition and the loop body + assert_eq!(get_character_range('a', 'd'), visitor.identifiers); +} +#[test] +fn test_visit_repeat_loop_statement() { + // GIVEN a source code with a repeat loop statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + REPEAT + a; + b; + UNTIL c > d; + END_PROGRAM", + ); + // THEN we expect to visit the loop body and the condition + assert_eq!(get_character_range('a', 'd'), visitor.identifiers); +} + +#[test] +fn test_visit_case_statement() { + // GIVEN a source code with a case statement + + let visitor = collect_identifiers( + " + PROGRAM prg + CASE a OF + b: + c; + d; + e, f: + g; + h; + ELSE + i; + j; + END_CASE; + END_PROGRAM", + ); + // THEN we expect to visit the case expression, the case labels, their bodies and the else body + assert_eq!(get_character_range('a', 'j'), visitor.identifiers); +} + +#[test] +fn test_visit_multiplied_statement() { + // GIVEN a source code with a multiplied statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + 3(a+b); + END_PROGRAM", + ); + // THEN we expect to visit the multiplied expression and its subexpressions + assert_eq!(get_character_range('a', 'b'), visitor.identifiers); +} + +#[test] +fn test_visist_array_expressions() { + // GIVEN a source code with array expressions + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a[b]; + c[d,e+f]; + g[h+i][j+k]; + END_PROGRAM", + ); + // THEN we expect to visit the array expressions and the array-accessor expressions + assert_eq!(get_character_range('a', 'k'), visitor.identifiers); +} + +#[test] +fn test_visit_range_statement() { + // GIVEN a source code with range statements + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a..b; + END_PROGRAM", + ); + // THEN we expect to visit the start and end expressions of the range + assert_eq!(get_character_range('a', 'b'), visitor.identifiers); +} + +#[test] +fn test_visit_assignment_expressions() { + // GIVEN a source code with assignment expressions + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a := b; + c => d; + e =>; + END_PROGRAM", + ); + // THEN we expect to visit the left and right side of the assignment expressions + assert_eq!(get_character_range('a', 'e'), visitor.identifiers); +} + +#[test] +fn test_visit_direct_access_statement_expressions() { + // GIVEN a source code with direct access expressions + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + %IW1.2.3; + %MD4; + END_PROGRAM", + ); + // THEN we expect to visit all segments of the direct access + assert_eq!(get_character_range('1', '4'), visitor.identifiers); +} + +#[test] +fn test_visit_call_statements() { + // GIVEN a source code with call statements + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a(); + b(c,d); + e(f:=(g), h=>i); + END_PROGRAM", + ); + // THEN we expect to visit the function name and all arguments + assert_eq!(get_character_range('a', 'i'), visitor.identifiers); +} + +#[test] +fn test_visit_return_statement() { + // GIVEN a source code with a return statement + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + FUNCTION prg : INT + RETURN a + b; + END_PROGRAM", + ); + // THEN we expect to visit the return expression + assert_eq!(get_character_range('a', 'b'), visitor.identifiers); +} + +#[test] +fn test_visit_into_var_global() { + // GIVEN a source code with a var_global section + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + VAR_GLOBAL + a : INT := c; + c : INT := d; + END_VAR", + ); + // THEN we expect to visit all initializers (variable names are no AstStatements!) + assert_eq!(get_character_range('c', 'd'), visitor.identifiers); +} + +#[test] +fn test_visit_data_type_declaration() { + // GIVEN a visitor that collects variables, enum elements and range expressions + struct FieldCollector { + fields: Vec, + } + + // This is a simple visitor that collects all field names in a datatype + impl AstVisitor for FieldCollector { + fn visit_variable(&mut self, variable: &plc_ast::ast::Variable) { + self.fields.push(variable.name.clone()); + variable.walk(self); + } + + fn visit_enum_element(&mut self, element: &plc_ast::ast::AstNode) { + if let Some(name) = element.get_flat_reference_name() { + self.fields.push(name.to_string()); + } + element.walk(self); + } + + fn visit_range_statement( + &mut self, + stmt: &plc_ast::ast::RangeStatement, + _node: &plc_ast::ast::AstNode, + ) { + if let Some((start, end)) = + stmt.start.get_flat_reference_name().zip(stmt.end.get_flat_reference_name()) + { + self.fields.push(start.to_string()); + self.fields.push(end.to_string()); + } + stmt.walk(self); + } + } + let mut visitor = FieldCollector { fields: vec![] }; + // WHEN we visit a source code with a complex datatype + visit( + " + TYPE myStruct: STRUCT + a, b, c: DINT; + s: STRING; + e: (enum1, enum2, enum3); + END_STRUCT; + END_TYPE + + TYPE MyEnum: (myEnum1, myEnum2, myEnum3); + END_TYPE + + TYPE MySubRange: INT(max..min); END_TYPE + + TYPE MyArray: ARRAY[start..end] OF INT; END_TYPE + ", + &mut visitor, + ); + + visitor.fields.sort(); + // THEN we expect to visit all fields, enum elements and range expressions + assert_eq!( + vec![ + "a", "b", "c", "e", "end", "enum1", "enum2", "enum3", "max", "min", "myEnum1", "myEnum2", + "myEnum3", "s", "start" + ], + visitor.fields + ); +} + +#[test] +fn test_count_assignments() { + // GIVEN a visitor that counts assignments + struct AssignmentCounter { + count: usize, + } + + impl AstVisitor for AssignmentCounter { + fn visit_assignment(&mut self, stmt: &plc_ast::ast::Assignment, _node: &plc_ast::ast::AstNode) { + self.count += 1; + stmt.walk(self) + } + + fn visit_output_assignment( + &mut self, + stmt: &plc_ast::ast::Assignment, + _node: &plc_ast::ast::AstNode, + ) { + self.count += 1; + stmt.walk(self) + } + } + + let id_provider = IdProvider::default(); + let (compilation_unit, _) = parser::parse( + lexer::lex_with_ids( + " + PROGRAM prg + a := b; + c => d; + e := f; + foo(a := baz(x := 2, z => 3)); + END_PROGRAM", + id_provider.clone(), + SourceLocationFactory::internal(""), + ), + LinkageType::Internal, + "test.st", + ); + + let mut visitor = AssignmentCounter { count: 0 }; + // WHEN we visit a source code with assignments + for st in &compilation_unit.implementations[0].statements { + visitor.visit(st); + } + // THEN we expect to visit all assignments + assert_eq!(6, visitor.count); +} + +#[test] +fn test_visit_datatype_initializers_statement() { + // GIVEN a source code with datatype initializers + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + TYPE MyStruct: STRUCT + field1: DINT := a; + field2: DINT := (b + c); + field3: ARRAY[1..3] OF DINT := 4(d); + field4: ARRAY[4..7] OF DINT := (e, f, g, h); + field5: (i := j, k := l) := m; + + END_STRUCT + END_TYPE", + ); + // THEN we expect to visit all initializers and enum elements + let mut expected = ["1", "3", "4", "7"].iter().map(|c| c.to_string()).collect::>(); + + expected.extend(get_character_range('a', 'm')); + assert_eq!(expected, visitor.identifiers); +} + +#[test] +fn test_visit_array_declaration_statement() { + // GIVEN a source code with array declarations + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + TYPE MyArray: ARRAY[(a+b)..(c+d)] OF INT; END_TYPE", + ); + // THEN we expect to visit the start and end expressions of the array + assert_eq!(get_character_range('a', 'd'), visitor.identifiers); +} + +#[test] +fn test_visit_qualified_expressions() { + // GIVEN a source code with qualified expressions + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + a.b; + c.d^.e; + f.g[h].i; + END_PROGRAM", + ); + // THEN we expect to visit all segments in the qualified expressions + assert_eq!(get_character_range('a', 'i'), visitor.identifiers); +} + +#[test] +fn test_visit_variable_block() { + // GIVEN a source code with a variable block + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + VAR_INPUT + a : INT := X; + END_VAR + VAR_OUTPUT + b : INT := Y; + END_VAR + VAR CONSTANT + c : INT + END_VAR + END_PROGRAM", + ); + // THEN we expect to visit all variables and their initializers + assert_eq!(get_character_range('X', 'Y'), visitor.identifiers); +} + +#[test] +fn test_visit_continue_exit() { + // THIS test is mainly here to cover the default visit implementation of Continue, Exit and EmptyStatement + let visitor = collect_identifiers( + " + PROGRAM prg + CONTINUE; + EXIT; + ; + END_PROGRAM", + ); + assert_eq!(0, visitor.identifiers.len()); +} + +#[test] +fn test_visit_default_value() { + // GIVEN a Visitor that visits default values + struct DefaultValueCollector { + visited: bool, + } + + // This is a simple visitor that collects all field names in a datatype + impl AstVisitor for DefaultValueCollector { + fn visit_default_value(&mut self, _stmt: &plc_ast::ast::DefaultValue, _node: &plc_ast::ast::AstNode) { + self.visited = true; + } + } + + let mut visitor = DefaultValueCollector { visited: false }; + // WHEN we visit a source code with a default value + visit( + " + VAR_GLOBAL CONSTANT + a : INT; + END_VAR + ", + &mut visitor, + ); + // THEN we expect to visit the default value + assert!(visitor.visited); +} + +#[test] +fn test_visit_direct_access() { + // GIVEN a Visitor that visits direct accesses + struct Visited { + visited: bool, + } + + impl AstVisitor for Visited { + fn visit_direct_access(&mut self, _stmt: &plc_ast::ast::DirectAccess, _node: &plc_ast::ast::AstNode) { + self.visited = true; + } + } + + let mut visitor = Visited { visited: false }; + // WHEN we visit a source code with a direct access + visit( + " + PROGRAM prg + x.1; + ", + &mut visitor, + ); + // THEN we expect to visit the direct access + assert!(visitor.visited); + + let v = collect_identifiers( + " + PROGRAM prg + x.1; + ", + ); + assert_eq!(vec!["1", "x"], v.identifiers); +} + +#[test] +fn test_invalid_case_condition() { + // this tests ensures that we visit "invalid" statements. (see parser's behavior in parse_statement) + struct Visited { + visited: bool, + } + + impl AstVisitor for Visited { + fn visit_case_condition(&mut self, _child: &plc_ast::ast::AstNode, _node: &plc_ast::ast::AstNode) { + self.visited = true; + } + } + + let mut visitor = Visited { visited: false }; + + visit( + " + PROGRAM prg + x: + ", + &mut visitor, + ); + assert!(visitor.visited); +} + +#[test] +fn test_visit_string_declaration() { + // GIVEN a source code with a string declaration + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + VAR + str: STRING(X); + END_VAR + ", + ); + // THEN we expect to visit the string length + assert_eq!(vec!["X"], visitor.identifiers); +} + +#[test] +fn test_visit_pointer_declaration() { + // GIVEN a source code with a pointer declaration + // WHEN we visit all nodes in the AST + let visitor = collect_identifiers( + " + PROGRAM prg + VAR + str: POINTER TO ARRAY[a..b] OF INT := c; + END_VAR + ", + ); + // THEN we expect to visit the pointer type and the initializer + assert_eq!(get_character_range('a', 'c'), visitor.identifiers); +} diff --git a/src/resolver.rs b/src/resolver.rs index 3e6a29dcf82..6bf25261a2d 100644 --- a/src/resolver.rs +++ b/src/resolver.rs @@ -11,9 +11,8 @@ use std::hash::Hash; use plc_ast::{ ast::{ self, flatten_expression_list, Assignment, AstFactory, AstId, AstNode, AstStatement, - BinaryExpression, CastStatement, CompilationUnit, DataType, DataTypeDeclaration, DirectAccessType, - JumpStatement, Operator, Pou, ReferenceAccess, ReferenceExpr, TypeNature, UserTypeDeclaration, - Variable, + BinaryExpression, CompilationUnit, DataType, DataTypeDeclaration, DirectAccessType, JumpStatement, + Operator, Pou, ReferenceAccess, ReferenceExpr, TypeNature, UserTypeDeclaration, Variable, }, control_statements::{AstControlStatement, ReturnStatement}, literals::{Array, AstLiteral, StringValue}, @@ -1442,57 +1441,6 @@ impl<'i> TypeAnnotator<'i> { AstStatement::CallStatement(..) => { self.visit_call_statement(statement, ctx); } - AstStatement::CastStatement(CastStatement { target, type_name }, ..) => { - //see if this type really exists - let data_type = self.index.find_effective_type_info(type_name); - let statement_to_annotation = if let Some(DataTypeInformation::Enum { name, .. }) = data_type - { - //enum cast - self.visit_statement(&ctx.with_qualifier(name.to_string()), target); - //use the type of the target - let type_name = self.annotation_map.get_type_or_void(target, self.index).get_name(); - vec![(statement, type_name.to_string())] - } else if let Some(t) = data_type { - // special handling for unlucky casted-strings where caste-type does not match the literal encoding - // ´STRING#"abc"´ or ´WSTRING#'abc'´ - match (t, target.as_ref().get_stmt()) { - ( - DataTypeInformation::String { encoding: StringEncoding::Utf8, .. }, - AstStatement::Literal(AstLiteral::String(StringValue { - value, - is_wide: is_wide @ true, - })), - ) - | ( - DataTypeInformation::String { encoding: StringEncoding::Utf16, .. }, - AstStatement::Literal(AstLiteral::String(StringValue { - value, - is_wide: is_wide @ false, - })), - ) => { - // visit the target-statement as if the programmer used the correct quotes to prevent - // a utf16 literal-global-variable that needs to be casted back to utf8 or vice versa - self.visit_statement( - ctx, - &AstNode::new_literal( - AstLiteral::new_string(value.clone(), !is_wide), - target.get_id(), - target.get_location(), - ), - ); - } - _ => {} - } - vec![(statement, t.get_name().to_string()), (target, t.get_name().to_string())] - } else { - //unknown type? what should we do here? - self.visit_statement(ctx, target); - vec![] - }; - for (stmt, annotation) in statement_to_annotation { - self.annotate(stmt, StatementAnnotation::value(annotation)); - } - } AstStatement::ReferenceExpr(data, ..) => { self.visit_reference_expr(&data.access, data.base.as_deref(), statement, ctx); } diff --git a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_enum_variable_default_value_compile_time_evaluation.snap b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_enum_variable_default_value_compile_time_evaluation.snap index 001b53a48de..eb2eab72b70 100644 --- a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_enum_variable_default_value_compile_time_evaluation.snap +++ b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_enum_variable_default_value_compile_time_evaluation.snap @@ -5,8 +5,8 @@ expression: ir ; ModuleID = 'main' source_filename = "main" -@me = unnamed_addr constant i32 3 -@THREE = unnamed_addr constant i16 3 -@MyEnum.a = unnamed_addr constant i32 3 -@MyEnum.b = unnamed_addr constant i32 4 -@MyEnum.c = unnamed_addr constant i32 5 +@me = unnamed_addr constant i32 3, section "var-$RUSTY$me:e3i32" +@THREE = unnamed_addr constant i16 3, section "var-$RUSTY$THREE:i16" +@MyEnum.a = unnamed_addr constant i32 3, section "var-$RUSTY$a:e3i32" +@MyEnum.b = unnamed_addr constant i32 4, section "var-$RUSTY$b:e3i32" +@MyEnum.c = unnamed_addr constant i32 5, section "var-$RUSTY$c:e3i32" diff --git a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_variables_default_value_compile_time_evaluation.snap b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_variables_default_value_compile_time_evaluation.snap index 1ac4ac6da76..15c2095dad0 100644 --- a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_variables_default_value_compile_time_evaluation.snap +++ b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__const_variables_default_value_compile_time_evaluation.snap @@ -5,12 +5,12 @@ expression: ir ; ModuleID = 'main' source_filename = "main" -@false_bool = unnamed_addr constant i8 0 -@zero_int = unnamed_addr constant i16 0 -@zero_real = unnamed_addr constant double 0.000000e+00 -@empty_string = unnamed_addr constant [81 x i8] zeroinitializer -@null_ptr = unnamed_addr constant i16* null -@zero_enum = unnamed_addr constant i32 0 -@myEnum.a = unnamed_addr constant i32 0 -@myEnum.b = unnamed_addr constant i32 1 -@myEnum.c = unnamed_addr constant i32 2 +@false_bool = unnamed_addr constant i8 0, section "var-$RUSTY$false_bool:u8" +@zero_int = unnamed_addr constant i16 0, section "var-$RUSTY$zero_int:i16" +@zero_real = unnamed_addr constant double 0.000000e+00, section "var-$RUSTY$zero_real:f64" +@empty_string = unnamed_addr constant [81 x i8] zeroinitializer, section "var-$RUSTY$empty_string:s8u81" +@null_ptr = unnamed_addr constant i16* null, section "var-$RUSTY$null_ptr:pi16" +@zero_enum = unnamed_addr constant i32 0, section "var-$RUSTY$zero_enum:e3i32" +@myEnum.a = unnamed_addr constant i32 0, section "var-$RUSTY$a:e3i32" +@myEnum.b = unnamed_addr constant i32 1, section "var-$RUSTY$b:e3i32" +@myEnum.c = unnamed_addr constant i32 2, section "var-$RUSTY$c:e3i32" diff --git a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__default_values_are_transitive_for_range_types.snap b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__default_values_are_transitive_for_range_types.snap index f702fd1b496..810a15dd212 100644 --- a/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__default_values_are_transitive_for_range_types.snap +++ b/src/resolver/tests/snapshots/rusty__resolver__tests__const_resolver_tests__default_values_are_transitive_for_range_types.snap @@ -5,9 +5,8 @@ expression: src ; ModuleID = 'main' source_filename = "main" -@a = global i16 7 -@b = global i16 7 -@aa = unnamed_addr constant i16 7 -@bb = unnamed_addr constant i16 7 -@cc = unnamed_addr constant i16 14 - +@a = global i16 7, section "var-$RUSTY$a:i16" +@b = global i16 7, section "var-$RUSTY$b:i16" +@aa = unnamed_addr constant i16 7, section "var-$RUSTY$aa:i16" +@bb = unnamed_addr constant i16 7, section "var-$RUSTY$bb:i16" +@cc = unnamed_addr constant i16 14, section "var-$RUSTY$cc:i16" diff --git a/src/tests/adr/arrays_adr.rs b/src/tests/adr/arrays_adr.rs index f2bcd2359a6..e5a95bcc6b0 100644 --- a/src/tests/adr/arrays_adr.rs +++ b/src/tests/adr/arrays_adr.rs @@ -18,7 +18,7 @@ fn declaring_an_array() { ; ModuleID = 'main' source_filename = "main" - @d = global [10 x i32] zeroinitializer + @d = global [10 x i32] zeroinitializer, section "var-$RUSTY$d:ai32" "###); } @@ -40,8 +40,8 @@ fn initializing_an_array() { ; ModuleID = 'main' source_filename = "main" - @d = global [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] - @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] + @d = global [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], section "var-$RUSTY$d:ai32" + @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], section "var-$RUSTY$__Data__init:ai32" "###); } @@ -70,10 +70,10 @@ fn assigning_full_arrays() { %prg = type { [10 x i32], [10 x i32] } - @prg_instance = global %prg { [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] } - @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] + @prg_instance = global %prg { [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] }, section "var-$RUSTY$prg_instance:r2ai32ai32" + @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], section "var-$RUSTY$__Data__init:ai32" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -122,11 +122,11 @@ fn accessing_array_elements() { %prg = type { [10 x i32], [3 x i32] } - @prg_instance = global %prg { [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], [3 x i32] [i32 3, i32 4, i32 5] } - @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9] + @prg_instance = global %prg { [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], [3 x i32] [i32 3, i32 4, i32 5] }, section "var-$RUSTY$prg_instance:r2ai32ai32" + @__Data__init = unnamed_addr constant [10 x i32] [i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9], section "var-$RUSTY$__Data__init:ai32" @__prg.b__init = unnamed_addr constant [3 x i32] [i32 3, i32 4, i32 5] - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/tests/adr/enum_adr.rs b/src/tests/adr/enum_adr.rs index 6cca156de81..aa7af6da0fb 100644 --- a/src/tests/adr/enum_adr.rs +++ b/src/tests/adr/enum_adr.rs @@ -22,10 +22,10 @@ fn enums_generate_a_global_constants_for_each_element() { ; ModuleID = 'main' source_filename = "main" - @myColor = global i32 0 - @Color.red = unnamed_addr constant i32 0 - @Color.yellow = unnamed_addr constant i32 1 - @Color.green = unnamed_addr constant i32 2 + @myColor = global i32 0, section "var-$RUSTY$myColor:e3i32" + @Color.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" + @Color.yellow = unnamed_addr constant i32 1, section "var-$RUSTY$yellow:e3i32" + @Color.green = unnamed_addr constant i32 2, section "var-$RUSTY$green:e3i32" "###); } @@ -52,16 +52,16 @@ fn enums_constants_are_automatically_numbered_or_user_defined() { ; ModuleID = 'main' source_filename = "main" - @myColor = global i32 0 - @myState = global i8 0 - @Color.red = unnamed_addr constant i32 1 - @Color.yellow = unnamed_addr constant i32 2 - @Color.green = unnamed_addr constant i32 4 - @Color.blue = unnamed_addr constant i32 8 - @State.open = unnamed_addr constant i8 1 - @State.closed = unnamed_addr constant i8 4 - @State.idle = unnamed_addr constant i8 5 - @State.running = unnamed_addr constant i8 6 + @myColor = global i32 0, section "var-$RUSTY$myColor:e4i32" + @myState = global i8 0, section "var-$RUSTY$myState:e4u8" + @Color.red = unnamed_addr constant i32 1, section "var-$RUSTY$red:e4i32" + @Color.yellow = unnamed_addr constant i32 2, section "var-$RUSTY$yellow:e4i32" + @Color.green = unnamed_addr constant i32 4, section "var-$RUSTY$green:e4i32" + @Color.blue = unnamed_addr constant i32 8, section "var-$RUSTY$blue:e4i32" + @State.open = unnamed_addr constant i8 1, section "var-$RUSTY$open:e4u8" + @State.closed = unnamed_addr constant i8 4, section "var-$RUSTY$closed:e4u8" + @State.idle = unnamed_addr constant i8 5, section "var-$RUSTY$idle:e4u8" + @State.running = unnamed_addr constant i8 6, section "var-$RUSTY$running:e4u8" "###); } @@ -80,14 +80,14 @@ fn inline_declaration_of_enum_types() { ; ModuleID = 'main' source_filename = "main" - @frontColor = global i32 0 - @backColor = global i32 0 - @__global_frontColor.red = unnamed_addr constant i32 0 - @__global_frontColor.green = unnamed_addr constant i32 1 - @__global_frontColor.yellow = unnamed_addr constant i32 2 - @__global_backColor.red = unnamed_addr constant i32 0 - @__global_backColor.green = unnamed_addr constant i32 1 - @__global_backColor.yellow = unnamed_addr constant i32 2 + @frontColor = global i32 0, section "var-$RUSTY$frontColor:e3i32" + @backColor = global i32 0, section "var-$RUSTY$backColor:e3i32" + @__global_frontColor.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" + @__global_frontColor.green = unnamed_addr constant i32 1, section "var-$RUSTY$green:e3i32" + @__global_frontColor.yellow = unnamed_addr constant i32 2, section "var-$RUSTY$yellow:e3i32" + @__global_backColor.red = unnamed_addr constant i32 0, section "var-$RUSTY$red:e3i32" + @__global_backColor.green = unnamed_addr constant i32 1, section "var-$RUSTY$green:e3i32" + @__global_backColor.yellow = unnamed_addr constant i32 2, section "var-$RUSTY$yellow:e3i32" "###); } @@ -121,15 +121,15 @@ fn using_enums() { %prg = type { i32, i32, i32 } - @prg_instance = global %prg zeroinitializer - @ProcessState.open = unnamed_addr constant i32 1 - @ProcessState.closed = unnamed_addr constant i32 4 - @ProcessState.idle = unnamed_addr constant i32 5 - @ProcessState.running = unnamed_addr constant i32 6 - @Door.open = unnamed_addr constant i32 8 - @Door.closed = unnamed_addr constant i32 16 + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r3i32i32i32" + @ProcessState.open = unnamed_addr constant i32 1, section "var-$RUSTY$open:e4i32" + @ProcessState.closed = unnamed_addr constant i32 4, section "var-$RUSTY$closed:e4i32" + @ProcessState.idle = unnamed_addr constant i32 5, section "var-$RUSTY$idle:e4i32" + @ProcessState.running = unnamed_addr constant i32 6, section "var-$RUSTY$running:e4i32" + @Door.open = unnamed_addr constant i32 8, section "var-$RUSTY$open:e2i32" + @Door.closed = unnamed_addr constant i32 16, section "var-$RUSTY$closed:e2i32" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %y = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/tests/adr/pou_adr.rs b/src/tests/adr/pou_adr.rs index 78e8f1359d7..2fbde24ad63 100644 --- a/src/tests/adr/pou_adr.rs +++ b/src/tests/adr/pou_adr.rs @@ -233,9 +233,9 @@ fn codegen_of_a_program_pou() { %main_prg = type { i16, i16*, i16, i16 } - @main_prg_instance = global %main_prg zeroinitializer + @main_prg_instance = global %main_prg zeroinitializer, section "var-$RUSTY$main_prg_instance:r5i16pi16i16i16i16" - define void @main_prg(%main_prg* %0) section "fn-main_prg:v[i16][pi16][i16]" { + define void @main_prg(%main_prg* %0) section "fn-$RUSTY$main_prg:v[i16][pi16][i16]" { entry: %i = getelementptr inbounds %main_prg, %main_prg* %0, i32 0, i32 0 %io = getelementptr inbounds %main_prg, %main_prg* %0, i32 0, i32 1 @@ -271,9 +271,9 @@ fn calling_a_program() { %main_prg = type { i16, i16*, i16, i16 } - @main_prg_instance = global %main_prg zeroinitializer + @main_prg_instance = global %main_prg zeroinitializer, section "var-$RUSTY$main_prg_instance:r5i16pi16i16i16i16" - define i16 @foo() section "fn-foo:i16" { + define i16 @foo() section "fn-$RUSTY$foo:i16" { entry: %foo = alloca i16, align 2 %x = alloca i16, align 2 @@ -290,7 +290,7 @@ fn calling_a_program() { ret i16 %foo_ret } - define void @main_prg(%main_prg* %0) section "fn-main_prg:v[i16][pi16][i16]" { + define void @main_prg(%main_prg* %0) section "fn-$RUSTY$main_prg:v[i16][pi16][i16]" { entry: %i = getelementptr inbounds %main_prg, %main_prg* %0, i32 0, i32 0 %io = getelementptr inbounds %main_prg, %main_prg* %0, i32 0, i32 1 @@ -335,9 +335,9 @@ fn function_blocks_get_a_method_with_a_self_parameter() { %main_fb = type { i16, i16*, i16, i16 } - @__main_fb__init = unnamed_addr constant %main_fb { i16 6, i16* null, i16 0, i16 1 } + @__main_fb__init = unnamed_addr constant %main_fb { i16 6, i16* null, i16 0, i16 1 }, section "var-$RUSTY$__main_fb__init:r5i16pi16i16i16i16" - define void @main_fb(%main_fb* %0) section "fn-main_fb:v[i16][pi16][i16]" { + define void @main_fb(%main_fb* %0) section "fn-$RUSTY$main_fb:v[i16][pi16][i16]" { entry: %i = getelementptr inbounds %main_fb, %main_fb* %0, i32 0, i32 0 %io = getelementptr inbounds %main_fb, %main_fb* %0, i32 0, i32 1 @@ -375,10 +375,10 @@ fn calling_a_function_block() { %foo = type { i16, i16, %main_fb } %main_fb = type { i16, i16*, i16, i16 } - @foo_instance = global %foo { i16 0, i16 0, %main_fb { i16 6, i16* null, i16 0, i16 1 } } - @__main_fb__init = unnamed_addr constant %main_fb { i16 6, i16* null, i16 0, i16 1 } + @foo_instance = global %foo { i16 0, i16 0, %main_fb { i16 6, i16* null, i16 0, i16 1 } }, section "var-$RUSTY$foo_instance:r3i16i16r5i16pi16i16i16i16" + @__main_fb__init = unnamed_addr constant %main_fb { i16 6, i16* null, i16 0, i16 1 }, section "var-$RUSTY$__main_fb__init:r5i16pi16i16i16i16" - define void @foo(%foo* %0) section "fn-foo:v" { + define void @foo(%foo* %0) section "fn-$RUSTY$foo:v" { entry: %x = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0 %y = getelementptr inbounds %foo, %foo* %0, i32 0, i32 1 @@ -394,7 +394,7 @@ fn calling_a_function_block() { ret void } - define void @main_fb(%main_fb* %0) section "fn-main_fb:v[i16][pi16][i16]" { + define void @main_fb(%main_fb* %0) section "fn-$RUSTY$main_fb:v[i16][pi16][i16]" { entry: %i = getelementptr inbounds %main_fb, %main_fb* %0, i32 0, i32 0 %io = getelementptr inbounds %main_fb, %main_fb* %0, i32 0, i32 1 @@ -431,7 +431,7 @@ fn function_get_a_method_with_by_ref_parameters() { ; ModuleID = 'main' source_filename = "main" - define i32 @main_fun(i16 %0, i8* %1, i64* %2) section "fn-main_fun:i32[i16][pi8][pi64]" { + define i32 @main_fun(i16 %0, i8* %1, i64* %2) section "fn-$RUSTY$main_fun:i32[i16][pi8][pi64]" { entry: %main_fun = alloca i32, align 4 %i = alloca i16, align 2 @@ -475,9 +475,9 @@ fn calling_a_function() { %prg = type { i16, i8 } - @prg_instance = global %prg zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2i16i8" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %x = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %z = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -487,7 +487,7 @@ fn calling_a_function() { ret void } - define i32 @main_fun(i16 %0, i8* %1, i64* %2) section "fn-main_fun:i32[i16][pi8][pi64]" { + define i32 @main_fun(i16 %0, i8* %1, i64* %2) section "fn-$RUSTY$main_fun:i32[i16][pi8][pi64]" { entry: %main_fun = alloca i32, align 4 %i = alloca i16, align 2 @@ -537,10 +537,10 @@ fn return_a_complex_type_from_function() { %prg = type { [81 x i8] } - @prg_instance = global %prg zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r1s8u81" @utf08_literal_0 = private unnamed_addr constant [13 x i8] c"hello world!\00" - define void @foo([81 x i8]* %0) section "fn-foo:s8u81" { + define void @foo([81 x i8]* %0) section "fn-$RUSTY$foo:s8u81" { entry: %foo = alloca [81 x i8]*, align 8 store [81 x i8]* %0, [81 x i8]** %foo, align 8 @@ -553,7 +553,7 @@ fn return_a_complex_type_from_function() { ret void } - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %s = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %1 = alloca [81 x i8], align 1 @@ -620,10 +620,10 @@ fn passing_aggregate_types_to_functions_by_value() { %myStruct = type { i32, i32, i32, [81 x i8] } %main = type { [81 x i8], [81 x i16], [30000 x i32], %myStruct } - @__myStruct__init = unnamed_addr constant %myStruct zeroinitializer - @main_instance = global %main zeroinitializer + @__myStruct__init = unnamed_addr constant %myStruct zeroinitializer, section "var-$RUSTY$__myStruct__init:r4i32i32i32s8u81" + @main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r4s8u81s16u81ai32r4i32i32i32s8u81" - define void @foo(i8* %0, i16* %1, i32* %2, %myStruct* %3) section "fn-foo:v[s8u81][s16u81][v][v]" { + define void @foo(i8* %0, i16* %1, i32* %2, %myStruct* %3) section "fn-$RUSTY$foo:v[s8u81][s16u81][ai32][r4i32i32i32s8u81]" { entry: %s = alloca [81 x i8], align 1 %bitcast = bitcast [81 x i8]* %s to i8* @@ -648,7 +648,7 @@ fn passing_aggregate_types_to_functions_by_value() { ret void } - define void @main(%main* %0) section "fn-main:v" { + define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %string1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %string2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 @@ -705,9 +705,9 @@ fn passing_by_ref_to_functions() { %main = type { [81 x i8], [81 x i8] } - @main_instance = global %main zeroinitializer + @main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2s8u81s8u81" - define i8 @StrEqual(i8* %0, i8* %1) section "fn-StrEqual:u8[ps8u81][ps8u81]" { + define i8 @StrEqual(i8* %0, i8* %1) section "fn-$RUSTY$StrEqual:u8[ps8u81][ps8u81]" { entry: %StrEqual = alloca i8, align 1 %o1 = alloca i8*, align 8 @@ -719,7 +719,7 @@ fn passing_by_ref_to_functions() { ret i8 %StrEqual_ret } - define void @main(%main* %0) section "fn-main:v" { + define void @main(%main* %0) section "fn-$RUSTY$main:v" { entry: %str1 = getelementptr inbounds %main, %main* %0, i32 0, i32 0 %str2 = getelementptr inbounds %main, %main* %0, i32 0, i32 1 diff --git a/src/tests/adr/strings_adr.rs b/src/tests/adr/strings_adr.rs index 6a8d00c4844..33dc2b22d25 100644 --- a/src/tests/adr/strings_adr.rs +++ b/src/tests/adr/strings_adr.rs @@ -18,8 +18,8 @@ fn declaring_a_string() { ; ModuleID = 'main' source_filename = "main" - @myUtf8 = global [21 x i8] zeroinitializer - @myUtf16 = global [21 x i16] zeroinitializer + @myUtf8 = global [21 x i8] zeroinitializer, section "var-$RUSTY$myUtf8:s8u21" + @myUtf16 = global [21 x i16] zeroinitializer, section "var-$RUSTY$myUtf16:s16u21" "###); } @@ -41,8 +41,8 @@ fn strings_are_terminated_with_0byte() { ; ModuleID = 'main' source_filename = "main" - @myUtf8 = global [6 x i8] c"Hello\00" - @myUtf16 = global [6 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0] + @myUtf8 = global [6 x i8] c"Hello\00", section "var-$RUSTY$myUtf8:s8u6" + @myUtf16 = global [6 x i16] [i16 87, i16 111, i16 114, i16 108, i16 100, i16 0], section "var-$RUSTY$myUtf16:s16u6" "###); } @@ -68,9 +68,9 @@ fn assigning_strings() { %prg = type { [11 x i8], [11 x i8] } - @prg_instance = global %prg zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u11s8u11" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -109,11 +109,11 @@ fn assigning_string_literals() { %prg = type { [11 x i8], [11 x i8] } - @prg_instance = global %prg zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2s8u11s8u11" @utf08_literal_0 = private unnamed_addr constant [6 x i8] c"hello\00" @utf08_literal_1 = private unnamed_addr constant [6 x i8] c"world\00" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %a = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %b = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/tests/adr/structs_adr.rs b/src/tests/adr/structs_adr.rs index fd1e456a681..23f2b550bf3 100644 --- a/src/tests/adr/structs_adr.rs +++ b/src/tests/adr/structs_adr.rs @@ -24,7 +24,7 @@ fn declaring_a_struct() { %Person = type { [81 x i8], [81 x i8], i16, i8 } - @__Person__init = unnamed_addr constant %Person zeroinitializer + @__Person__init = unnamed_addr constant %Person zeroinitializer, section "var-$RUSTY$__Person__init:r4s8u81s8u81i16u8" "###); } @@ -54,8 +54,8 @@ fn default_values_of_a_struct() { %Person = type { [6 x i8], [6 x i8], i16, i8 } - @p = global %Person { [6 x i8] c"Jane\00\00", [6 x i8] c"Row\00\00\00", i16 1988, i8 0 } - @__Person__init = unnamed_addr constant %Person { [6 x i8] c"Jane\00\00", [6 x i8] c"Row\00\00\00", i16 1988, i8 0 } + @p = global %Person { [6 x i8] c"Jane\00\00", [6 x i8] c"Row\00\00\00", i16 1988, i8 0 }, section "var-$RUSTY$p:r4s8u6s8u6i16u8" + @__Person__init = unnamed_addr constant %Person { [6 x i8] c"Jane\00\00", [6 x i8] c"Row\00\00\00", i16 1988, i8 0 }, section "var-$RUSTY$__Person__init:r4s8u6s8u6i16u8" "###); } @@ -97,13 +97,13 @@ fn initializing_a_struct() { %Rect = type { %Point, %Point } %Point = type { i16, i16 } - @prg_instance = global %prg { %Rect { %Point { i16 1, i16 5 }, %Point { i16 10, i16 15 } }, %Rect { %Point { i16 4, i16 6 }, %Point { i16 16, i16 22 } } } - @__Rect__init = unnamed_addr constant %Rect zeroinitializer - @__Point__init = unnamed_addr constant %Point zeroinitializer + @prg_instance = global %prg { %Rect { %Point { i16 1, i16 5 }, %Point { i16 10, i16 15 } }, %Rect { %Point { i16 4, i16 6 }, %Point { i16 16, i16 22 } } }, section "var-$RUSTY$prg_instance:r2r2r2i16i16r2i16i16r2r2i16i16r2i16i16" + @__Rect__init = unnamed_addr constant %Rect zeroinitializer, section "var-$RUSTY$__Rect__init:r2r2i16i16r2i16i16" + @__Point__init = unnamed_addr constant %Point zeroinitializer, section "var-$RUSTY$__Point__init:r2i16i16" @__prg.rect1__init = unnamed_addr constant %Rect { %Point { i16 1, i16 5 }, %Point { i16 10, i16 15 } } @__prg.rect2__init = unnamed_addr constant %Rect { %Point { i16 4, i16 6 }, %Point { i16 16, i16 22 } } - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %rect1 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %rect2 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -143,10 +143,10 @@ fn assigning_structs() { %prg = type { %Point, %Point } %Point = type { i16, i16 } - @prg_instance = global %prg zeroinitializer - @__Point__init = unnamed_addr constant %Point zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2r2i16i16r2i16i16" + @__Point__init = unnamed_addr constant %Point zeroinitializer, section "var-$RUSTY$__Point__init:r2i16i16" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %p1 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %p2 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 @@ -200,11 +200,11 @@ fn accessing_struct_members() { %Rect = type { %Point, %Point } %Point = type { i16, i16 } - @prg_instance = global %prg zeroinitializer - @__Rect__init = unnamed_addr constant %Rect zeroinitializer - @__Point__init = unnamed_addr constant %Point zeroinitializer + @prg_instance = global %prg zeroinitializer, section "var-$RUSTY$prg_instance:r2r2r2i16i16r2i16i16r2r2i16i16r2i16i16" + @__Rect__init = unnamed_addr constant %Rect zeroinitializer, section "var-$RUSTY$__Rect__init:r2r2i16i16r2i16i16" + @__Point__init = unnamed_addr constant %Point zeroinitializer, section "var-$RUSTY$__Point__init:r2i16i16" - define void @prg(%prg* %0) section "fn-prg:v" { + define void @prg(%prg* %0) section "fn-$RUSTY$prg:v" { entry: %rect1 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 0 %rect2 = getelementptr inbounds %prg, %prg* %0, i32 0, i32 1 diff --git a/src/tests/adr/vla_adr.rs b/src/tests/adr/vla_adr.rs index a4b2d6430b0..e4ba8d75127 100644 --- a/src/tests/adr/vla_adr.rs +++ b/src/tests/adr/vla_adr.rs @@ -316,9 +316,9 @@ fn pass() { %__foo_arr = type { i32*, [2 x i32] } - @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer + @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer, section "var-$RUSTY$____foo_arr__init:r2pai32ai32" - define i32 @main() section "fn-main:i32" { + define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %local = alloca [6 x i32], align 4 @@ -340,7 +340,7 @@ fn pass() { ret i32 %main_ret } - define i32 @foo(%__foo_arr* %0) section "fn-foo:i32[pv]" { + define i32 @foo(%__foo_arr* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %arr = alloca %__foo_arr*, align 8 @@ -382,9 +382,9 @@ fn access() { %__foo_arr = type { i32*, [2 x i32] } - @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer + @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer, section "var-$RUSTY$____foo_arr__init:r2pai32ai32" - define i32 @foo(%__foo_arr* %0) section "fn-foo:i32[pv]" { + define i32 @foo(%__foo_arr* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %arr = alloca %__foo_arr*, align 8 @@ -440,9 +440,9 @@ fn multi_dimensional() { %__foo_arr = type { i32*, [4 x i32] } - @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer + @____foo_arr__init = unnamed_addr constant %__foo_arr zeroinitializer, section "var-$RUSTY$____foo_arr__init:r2pai32ai32" - define i32 @foo(%__foo_arr* %0) section "fn-foo:i32[pv]" { + define i32 @foo(%__foo_arr* %0) section "fn-$RUSTY$foo:i32[pr2pai32ai32]" { entry: %foo = alloca i32, align 4 %arr = alloca %__foo_arr*, align 8 diff --git a/src/validation/statement.rs b/src/validation/statement.rs index 4e6d8af18c3..d995ed440fd 100644 --- a/src/validation/statement.rs +++ b/src/validation/statement.rs @@ -58,18 +58,6 @@ pub fn visit_statement( AstStatement::Literal(AstLiteral::Array(Array { elements: Some(elements) })) => { visit_statement(validator, elements.as_ref(), context); } - AstStatement::CastStatement(data) => { - if let AstStatement::Literal(literal) = data.target.get_stmt() { - validate_cast_literal( - validator, - literal, - statement, - &data.type_name, - &statement.get_location(), - context, - ); - } - } AstStatement::MultipliedStatement(data) => { visit_statement(validator, &data.element, context); } diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__actions_debug.snap b/tests/integration/snapshots/tests__integration__cfc__ir__actions_debug.snap index 9fdb73b521c..b12c6d93a50 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__actions_debug.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__actions_debug.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %main = type { i32, i32 } -@main_instance = global %main zeroinitializer, !dbg !0 +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r2i32i32", !dbg !0 -define void @main(%main* %0) section "fn-main:v" !dbg !12 { +define void @main(%main* %0) section "fn-$RUSTY$main:v" !dbg !12 { entry: call void @llvm.dbg.declare(metadata %main* %0, metadata !16, metadata !DIExpression()), !dbg !17 %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0, !dbg !18 @@ -17,7 +17,7 @@ entry: ret void, !dbg !20 } -define void @main.newAction(%main* %0) section "fn-main.newAction:v" !dbg !21 { +define void @main.newAction(%main* %0) section "fn-$RUSTY$main.newAction:v" !dbg !21 { entry: call void @llvm.dbg.declare(metadata %main* %0, metadata !16, metadata !DIExpression()), !dbg !22 %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0, !dbg !23 @@ -28,7 +28,7 @@ entry: ret void, !dbg !22 } -define void @main.newAction2(%main* %0) section "fn-main.newAction2:v" !dbg !24 { +define void @main.newAction2(%main* %0) section "fn-$RUSTY$main.newAction2:v" !dbg !24 { entry: call void @llvm.dbg.declare(metadata %main* %0, metadata !16, metadata !DIExpression()), !dbg !25 %a = getelementptr inbounds %main, %main* %0, i32 0, i32 0, !dbg !26 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap index 3f3583d9933..f9950133be4 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %conditional_return = type { i32 } -@__conditional_return__init = unnamed_addr constant %conditional_return zeroinitializer +@__conditional_return__init = unnamed_addr constant %conditional_return zeroinitializer, section "var-$RUSTY$__conditional_return__init:r1i32" -define void @conditional_return(%conditional_return* %0) section "fn-conditional_return:v[i32]" { +define void @conditional_return(%conditional_return* %0) section "fn-$RUSTY$conditional_return:v[i32]" { entry: %val = getelementptr inbounds %conditional_return, %conditional_return* %0, i32 0, i32 0 %load_val = load i32, i32* %val, align 4 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_debug.snap b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_debug.snap index 0f4f5bb4d6c..25a2211efc9 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_debug.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_debug.snap @@ -2,7 +2,7 @@ source: tests/integration/cfc.rs expression: output_file_content_without_headers --- -define i32 @foo(i32 %0) section "fn-foo:i32[i32]" !dbg !4 { +define i32 @foo(i32 %0) section "fn-$RUSTY$foo:i32[i32]" !dbg !4 { entry: %foo = alloca i32, align 4, !dbg !9 %val = alloca i32, align 4, !dbg !9 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true.snap b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true.snap index 6a8c2cfb273..1ecce88ccf9 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %conditional_return = type { i32 } -@__conditional_return__init = constant %conditional_return zeroinitializer +@__conditional_return__init = constant %conditional_return zeroinitializer, section "var-$RUSTY$__conditional_return__init:r1i32" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %my_val = alloca i32, align 4 @@ -29,7 +29,7 @@ entry: ; Function Attrs: argmemonly nofree nounwind willreturn declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #0 -define void @conditional_return(%conditional_return* %0) section "fn-conditional_return:v[i32]" { +define void @conditional_return(%conditional_return* %0) section "fn-$RUSTY$conditional_return:v[i32]" { entry: %val = getelementptr inbounds %conditional_return, %conditional_return* %0, i32 0, i32 0 %load_val = load i32, i32* %val, align 4 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true_negated.snap b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true_negated.snap index 168d2152543..46dee4354aa 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true_negated.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return_evaluating_true_negated.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %conditional_return = type { i32 } -@__conditional_return__init = constant %conditional_return zeroinitializer +@__conditional_return__init = constant %conditional_return zeroinitializer, section "var-$RUSTY$__conditional_return__init:r1i32" -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %my_val = alloca i32, align 4 @@ -29,7 +29,7 @@ entry: ; Function Attrs: argmemonly nofree nounwind willreturn declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #0 -define void @conditional_return(%conditional_return* %0) section "fn-conditional_return:v[i32]" { +define void @conditional_return(%conditional_return* %0) section "fn-$RUSTY$conditional_return:v[i32]" { entry: %val = getelementptr inbounds %conditional_return, %conditional_return* %0, i32 0, i32 0 %load_val = load i32, i32* %val, align 4 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__jump_debug.snap b/tests/integration/snapshots/tests__integration__cfc__ir__jump_debug.snap index 85a459500a0..ea666e9a67b 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__jump_debug.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__jump_debug.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %foo = type { i32 } -@foo_instance = global %foo zeroinitializer, !dbg !0 +@foo_instance = global %foo zeroinitializer, section "var-$RUSTY$foo_instance:r1i32", !dbg !0 -define void @foo(%foo* %0) section "fn-foo:v" !dbg !11 { +define void @foo(%foo* %0) section "fn-$RUSTY$foo:v" !dbg !11 { entry: call void @llvm.dbg.declare(metadata %foo* %0, metadata !15, metadata !DIExpression()), !dbg !16 %val = getelementptr inbounds %foo, %foo* %0, i32 0, i32 0, !dbg !17 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_false.snap b/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_false.snap index 03bfcb1c79b..fd0716b3fcd 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_false.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_false.snap @@ -2,7 +2,7 @@ source: tests/integration/cfc.rs expression: output_file_content_without_headers --- -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x = alloca i8, align 1 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_true.snap b/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_true.snap index 4a7dd30341e..9e3f4c97b90 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_true.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__jump_to_label_with_true.snap @@ -2,7 +2,7 @@ source: tests/integration/cfc.rs expression: output_file_content_without_headers --- -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %x = alloca i8, align 1 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__sink_source_debug.snap b/tests/integration/snapshots/tests__integration__cfc__ir__sink_source_debug.snap index 3e6e525f301..79be9a600a3 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__sink_source_debug.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__sink_source_debug.snap @@ -4,9 +4,9 @@ expression: output_file_content_without_headers --- %main = type { i32 } -@main_instance = global %main zeroinitializer, !dbg !0 +@main_instance = global %main zeroinitializer, section "var-$RUSTY$main_instance:r1i32", !dbg !0 -define void @main(%main* %0) section "fn-main:v" !dbg !11 { +define void @main(%main* %0) section "fn-$RUSTY$main:v" !dbg !11 { entry: call void @llvm.dbg.declare(metadata %main* %0, metadata !15, metadata !DIExpression()), !dbg !16 %x = getelementptr inbounds %main, %main* %0, i32 0, i32 0, !dbg !17 diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__variable_source_to_variable_and_block_sink.snap b/tests/integration/snapshots/tests__integration__cfc__ir__variable_source_to_variable_and_block_sink.snap index 707a4124b89..1dcbe82b60d 100644 --- a/tests/integration/snapshots/tests__integration__cfc__ir__variable_source_to_variable_and_block_sink.snap +++ b/tests/integration/snapshots/tests__integration__cfc__ir__variable_source_to_variable_and_block_sink.snap @@ -2,7 +2,7 @@ source: tests/integration/cfc.rs expression: output_file_content_without_headers --- -define i32 @main() section "fn-main:i32" { +define i32 @main() section "fn-$RUSTY$main:i32" { entry: %main = alloca i32, align 4 %value = alloca i32, align 4 @@ -15,7 +15,7 @@ entry: ret i32 %main_ret } -define i32 @myAdd(i32 %0, i32 %1) section "fn-myAdd:i32[i32][i32]" { +define i32 @myAdd(i32 %0, i32 %1) section "fn-$RUSTY$myAdd:i32[i32][i32]" { entry: %myAdd = alloca i32, align 4 %a = alloca i32, align 4 @@ -31,7 +31,7 @@ entry: ret i32 %myAdd_ret } -define i32 @myConnection(i32 %0) section "fn-myConnection:i32[i32]" { +define i32 @myConnection(i32 %0) section "fn-$RUSTY$myConnection:i32[i32]" { entry: %myConnection = alloca i32, align 4 %x = alloca i32, align 4 diff --git a/tests/integration/snapshots/tests__integration__command_line_compile__ir_generation_full_pass.snap b/tests/integration/snapshots/tests__integration__command_line_compile__ir_generation_full_pass.snap index 10c5e319f35..7d5863d39dd 100644 --- a/tests/integration/snapshots/tests__integration__command_line_compile__ir_generation_full_pass.snap +++ b/tests/integration/snapshots/tests__integration__command_line_compile__ir_generation_full_pass.snap @@ -2,4 +2,4 @@ source: tests/integration/command_line_compile.rs expression: content --- -define i32 @myFunc(i32 %0, i32 %1, i32 %2) section "fn-myFunc:i32[i32][i32][i32]" {entry: %myFunc = alloca i32, align 4 %a = alloca i32, align 4 store i32 %0, i32* %a, align 4 %b = alloca i32, align 4 store i32 %1, i32* %b, align 4 %c = alloca i32, align 4 store i32 %2, i32* %c, align 4 store i32 0, i32* %myFunc, align 4 %myFunc_ret = load i32, i32* %myFunc, align 4 ret i32 %myFunc_ret} +define i32 @myFunc(i32 %0, i32 %1, i32 %2) section "fn-$RUSTY$myFunc:i32[i32][i32][i32]" {entry: %myFunc = alloca i32, align 4 %a = alloca i32, align 4 store i32 %0, i32* %a, align 4 %b = alloca i32, align 4 store i32 %1, i32* %b, align 4 %c = alloca i32, align 4 store i32 %2, i32* %c, align 4 store i32 0, i32* %myFunc, align 4 %myFunc_ret = load i32, i32* %myFunc, align 4 ret i32 %myFunc_ret}