Properly namespace function local constants
a48b03753b7ffcc4a10a1a76f951b0c3cb34d1f810c46214167f43c6b33bf310
Previously, it was possible to have overlap if two functions had the same constant name.
1 parent
9f542472
lib/std/lang/lower.rad
+59 -14
| 642 | 642 | // ~ Counters ~ // |
|
| 643 | 643 | ||
| 644 | 644 | /// Counter for generating unique block labels like `then#0`, `loop#1`, etc. |
|
| 645 | 645 | labelCounter: u32, |
|
| 646 | 646 | /// Counter for generating unique data names within this function. |
|
| 647 | - | /// Each literal gets a name like `fnName#N`. |
|
| 647 | + | /// Each literal gets a name like `fnName$literal$N`. |
|
| 648 | 648 | dataCounter: u32, |
|
| 649 | 649 | /// Counter for generating SSA register numbers. |
|
| 650 | 650 | regCounter: u32, |
|
| 651 | 651 | /// When the function returns an aggregate type, the caller passes a hidden |
|
| 652 | 652 | /// pointer as the first parameter. The callee writes the return value into |
| 1597 | 1597 | } |
|
| 1598 | 1598 | } |
|
| 1599 | 1599 | return nil; |
|
| 1600 | 1600 | } |
|
| 1601 | 1601 | ||
| 1602 | - | /// Generate a unique name for declaration-local backing data entries. |
|
| 1603 | - | fn nextDeclDataName(self: *mut Lowerer, prefix: *[u8], count: u32) -> *[u8] { |
|
| 1604 | - | let mut digits: [u8; fmt::U32_STR_LEN] = undefined; |
|
| 1605 | - | let suffix = fmt::formatU32(count, &mut digits[..]); |
|
| 1606 | - | let suffixStart = prefix.len + 1; |
|
| 1607 | - | let totalLen = suffixStart + suffix.len; |
|
| 1602 | + | /// Compose a segmented symbol name from a list of path segments. |
|
| 1603 | + | /// Example: `["func", "nominal", "VALUE"]` -> `func$nominal$VALUE`. |
|
| 1604 | + | fn buildSegmentedName( |
|
| 1605 | + | self: *mut Lowerer, |
|
| 1606 | + | segments: *[*[u8]] |
|
| 1607 | + | ) -> *[u8] throws (LowerError) { |
|
| 1608 | + | assert segments.len > 0; |
|
| 1609 | + | ||
| 1610 | + | let mut totalLen: u32 = 0; |
|
| 1611 | + | for segment in segments { |
|
| 1612 | + | set totalLen += segment.len; |
|
| 1613 | + | } |
|
| 1614 | + | if segments.len > 1 { |
|
| 1615 | + | set totalLen += segments.len - 1; |
|
| 1616 | + | } |
|
| 1608 | 1617 | let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8]; |
|
| 1618 | + | let mut pos: u32 = 0; |
|
| 1609 | 1619 | ||
| 1610 | - | try! mem::copy(&mut buf[..prefix.len], prefix); |
|
| 1611 | - | set buf[prefix.len] = '$'; |
|
| 1612 | - | try! mem::copy(&mut buf[suffixStart..], suffix); |
|
| 1620 | + | for segment, i in segments { |
|
| 1621 | + | set pos += try! mem::copy(&mut buf[pos..], segment); |
|
| 1622 | + | if i + 1 <> segments.len { |
|
| 1623 | + | set buf[pos] = '$'; |
|
| 1624 | + | set pos += 1; |
|
| 1625 | + | } |
|
| 1626 | + | } |
|
| 1627 | + | assert pos == totalLen; |
|
| 1613 | 1628 | ||
| 1614 | 1629 | return &buf[..totalLen]; |
|
| 1615 | 1630 | } |
|
| 1616 | 1631 | ||
| 1617 | - | /// Append a data entry using a declaration-scoped name (`prefix$N`). |
|
| 1632 | + | /// Generate a unique name for declaration-local backing data entries. |
|
| 1633 | + | fn nextDeclDataName( |
|
| 1634 | + | self: *mut Lowerer, |
|
| 1635 | + | prefix: *[u8], |
|
| 1636 | + | count: u32, |
|
| 1637 | + | namespace: *[u8] |
|
| 1638 | + | ) -> *[u8] throws (LowerError) { |
|
| 1639 | + | let mut digits: [u8; fmt::U32_STR_LEN] = undefined; |
|
| 1640 | + | let suffix = fmt::formatU32(count, &mut digits[..]); |
|
| 1641 | + | let segments: *mut [*[u8]] = &mut [prefix, namespace, suffix]; |
|
| 1642 | + | ||
| 1643 | + | return try buildSegmentedName(self, segments); |
|
| 1644 | + | } |
|
| 1645 | + | ||
| 1646 | + | /// Append a data entry using a function-local literal namespace (`prefix$literal$N`). |
|
| 1618 | 1647 | fn pushDeclData( |
|
| 1619 | 1648 | self: *mut Lowerer, |
|
| 1620 | 1649 | size: u32, |
|
| 1621 | 1650 | alignment: u32, |
|
| 1622 | 1651 | readOnly: bool, |
|
| 1623 | 1652 | values: *[il::DataValue], |
|
| 1624 | 1653 | dataPrefix: *[u8] |
|
| 1625 | 1654 | ) -> *[u8] throws (LowerError) { |
|
| 1626 | - | let name = nextDeclDataName(self, dataPrefix, self.data.len); |
|
| 1655 | + | let name = try nextDeclDataName(self, dataPrefix, self.data.len, "literal"); |
|
| 1627 | 1656 | self.data.append(il::Data { name, size, alignment, readOnly, isUndefined: false, values }, self.allocator); |
|
| 1628 | 1657 | ||
| 1629 | 1658 | return name; |
|
| 1630 | 1659 | } |
|
| 1631 | 1660 |
| 1759 | 1788 | return try buildSliceValue( |
|
| 1760 | 1789 | self, elemTy, mutable, il::Val::Reg(ptrReg), il::Val::Imm(length as i64), il::Val::Imm(length as i64) |
|
| 1761 | 1790 | ); |
|
| 1762 | 1791 | } |
|
| 1763 | 1792 | ||
| 1764 | - | /// Generate a unique data name for inline literals, eg. `fnName/N` |
|
| 1793 | + | /// Generate a unique data name for inline literals, eg. `fnName$literal$N`. |
|
| 1765 | 1794 | fn nextDataName(self: *mut FnLowerer) -> *[u8] throws (LowerError) { |
|
| 1766 | 1795 | let counter = self.dataCounter; |
|
| 1767 | 1796 | set self.dataCounter += 1; |
|
| 1768 | - | return try labelWithSuffix(self, self.fnName, counter); |
|
| 1797 | + | return try nextDeclDataName(self.low, self.fnName, counter, "literal"); |
|
| 1798 | + | } |
|
| 1799 | + | ||
| 1800 | + | /// Assign a unique function-local data symbol name. |
|
| 1801 | + | fn registerLocalDataDeclName(self: *mut FnLowerer, node: *ast::Node) throws (LowerError) { |
|
| 1802 | + | let sym = resolver::nodeData(self.low.resolver, node).sym |
|
| 1803 | + | else throw LowerError::MissingSymbol(node); |
|
| 1804 | + | ||
| 1805 | + | let prefix = self.fnName; |
|
| 1806 | + | let segments: *mut [*[u8]] = &mut [prefix, "nominal", sym.name]; |
|
| 1807 | + | let name = try buildSegmentedName(self.low, segments); |
|
| 1808 | + | ||
| 1809 | + | set sym.name = name; |
|
| 1769 | 1810 | } |
|
| 1770 | 1811 | ||
| 1771 | 1812 | /// Get the next available SSA register. |
|
| 1772 | 1813 | fn nextReg(self: *mut FnLowerer) -> il::Reg { |
|
| 1773 | 1814 | let reg = il::Reg { n: self.regCounter }; |
| 3722 | 3763 | case ast::NodeValue::Let(l) => { |
|
| 3723 | 3764 | try lowerLet(self, node, l); |
|
| 3724 | 3765 | } |
|
| 3725 | 3766 | case ast::NodeValue::ConstDecl(decl) => { |
|
| 3726 | 3767 | // Local constants lower to data declarations and emit no runtime code. |
|
| 3768 | + | try registerLocalDataDeclName(self, node); |
|
| 3727 | 3769 | try lowerDataDecl(self.low, node, decl.value, true); |
|
| 3728 | 3770 | } |
|
| 3729 | 3771 | case ast::NodeValue::StaticDecl(decl) => { |
|
| 3730 | 3772 | // Local statics lower to data declarations and emit no runtime code. |
|
| 3773 | + | try registerLocalDataDeclName(self, node); |
|
| 3731 | 3774 | try lowerDataDecl(self.low, node, decl.value, false); |
|
| 3732 | 3775 | } |
|
| 3733 | 3776 | case ast::NodeValue::If(i) => { |
|
| 3734 | 3777 | try lowerIf(self, i); |
|
| 3735 | 3778 | } |
| 6959 | 7002 | let _ = expr; |
|
| 6960 | 7003 | set val = il::Val::Undef; |
|
| 6961 | 7004 | } |
|
| 6962 | 7005 | // Lower these as statements. |
|
| 6963 | 7006 | case ast::NodeValue::ConstDecl(decl) => { |
|
| 7007 | + | try registerLocalDataDeclName(self, node); |
|
| 6964 | 7008 | try lowerDataDecl(self.low, node, decl.value, true); |
|
| 6965 | 7009 | set val = il::Val::Undef; |
|
| 6966 | 7010 | } |
|
| 6967 | 7011 | case ast::NodeValue::StaticDecl(decl) => { |
|
| 7012 | + | try registerLocalDataDeclName(self, node); |
|
| 6968 | 7013 | try lowerDataDecl(self.low, node, decl.value, false); |
|
| 6969 | 7014 | set val = il::Val::Undef; |
|
| 6970 | 7015 | } |
|
| 6971 | 7016 | case ast::NodeValue::Throw { .. }, |
|
| 6972 | 7017 | ast::NodeValue::Return { .. }, |
test/tests/const.array.strings.slice.ril
+5 -5
| 1 | - | data $WORDS$0 align 1 { |
|
| 1 | + | data $WORDS$literal$0 align 1 { |
|
| 2 | 2 | str "apple"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $WORDS$1 align 1 { |
|
| 5 | + | data $WORDS$literal$1 align 1 { |
|
| 6 | 6 | str "pencil"; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | 9 | data $WORDS align 8 { |
|
| 10 | - | sym $WORDS$0; |
|
| 10 | + | sym $WORDS$literal$0; |
|
| 11 | 11 | w32 5; |
|
| 12 | 12 | w32 5; |
|
| 13 | - | sym $WORDS$1; |
|
| 13 | + | sym $WORDS$literal$1; |
|
| 14 | 14 | w32 6; |
|
| 15 | 15 | w32 6; |
|
| 16 | - | sym $WORDS$0; |
|
| 16 | + | sym $WORDS$literal$0; |
|
| 17 | 17 | w32 5; |
|
| 18 | 18 | w32 5; |
|
| 19 | 19 | } |
|
| 20 | 20 | ||
| 21 | 21 | fn w32 $totalLen() { |
test/tests/const.local.duplicate.rad
added
+23 -0
| 1 | + | //! returns: 0 |
|
| 2 | + | //! Function-local aggregate constants with the same name in different |
|
| 3 | + | //! functions must not alias the same lowered data symbol. |
|
| 4 | + | ||
| 5 | + | fn left() -> i32 { |
|
| 6 | + | constant VALUE: [i32; 2] = [11, 13]; |
|
| 7 | + | return VALUE[0] + VALUE[1]; |
|
| 8 | + | } |
|
| 9 | + | ||
| 10 | + | fn right() -> i32 { |
|
| 11 | + | constant VALUE: [i32; 2] = [29, 31]; |
|
| 12 | + | return VALUE[0] + VALUE[1]; |
|
| 13 | + | } |
|
| 14 | + | ||
| 15 | + | @default fn main() -> i32 { |
|
| 16 | + | if left() <> 24 { |
|
| 17 | + | return 1; |
|
| 18 | + | } |
|
| 19 | + | if right() <> 60 { |
|
| 20 | + | return 2; |
|
| 21 | + | } |
|
| 22 | + | return 0; |
|
| 23 | + | } |
test/tests/const.local.duplicate.ril
added
+48 -0
| 1 | + | data $left$nominal$VALUE align 4 { |
|
| 2 | + | w32 11; |
|
| 3 | + | w32 13; |
|
| 4 | + | } |
|
| 5 | + | ||
| 6 | + | data $right$nominal$VALUE align 4 { |
|
| 7 | + | w32 29; |
|
| 8 | + | w32 31; |
|
| 9 | + | } |
|
| 10 | + | ||
| 11 | + | fn w32 $left() { |
|
| 12 | + | @entry0 |
|
| 13 | + | copy %0 $left$nominal$VALUE; |
|
| 14 | + | sload w32 %1 %0 0; |
|
| 15 | + | copy %2 $left$nominal$VALUE; |
|
| 16 | + | mul w64 %3 1 4; |
|
| 17 | + | add w64 %4 %2 %3; |
|
| 18 | + | sload w32 %5 %4 0; |
|
| 19 | + | add w32 %6 %1 %5; |
|
| 20 | + | ret %6; |
|
| 21 | + | } |
|
| 22 | + | ||
| 23 | + | fn w32 $right() { |
|
| 24 | + | @entry0 |
|
| 25 | + | copy %0 $right$nominal$VALUE; |
|
| 26 | + | sload w32 %1 %0 0; |
|
| 27 | + | copy %2 $right$nominal$VALUE; |
|
| 28 | + | mul w64 %3 1 4; |
|
| 29 | + | add w64 %4 %2 %3; |
|
| 30 | + | sload w32 %5 %4 0; |
|
| 31 | + | add w32 %6 %1 %5; |
|
| 32 | + | ret %6; |
|
| 33 | + | } |
|
| 34 | + | ||
| 35 | + | fn w32 $main() { |
|
| 36 | + | @entry0 |
|
| 37 | + | call w32 %0 $left(); |
|
| 38 | + | br.ne w32 %0 24 @then1 @merge2; |
|
| 39 | + | @then1 |
|
| 40 | + | ret 1; |
|
| 41 | + | @merge2 |
|
| 42 | + | call w32 %1 $right(); |
|
| 43 | + | br.ne w32 %1 60 @then3 @merge4; |
|
| 44 | + | @then3 |
|
| 45 | + | ret 2; |
|
| 46 | + | @merge4 |
|
| 47 | + | ret 0; |
|
| 48 | + | } |
test/tests/const.record.union.ril
+6 -6
| 1 | - | data $KEYWORDS$0 align 1 { |
|
| 1 | + | data $KEYWORDS$literal$0 align 1 { |
|
| 2 | 2 | str "fn"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $KEYWORDS$1 align 1 { |
|
| 5 | + | data $KEYWORDS$literal$1 align 1 { |
|
| 6 | 6 | str "let"; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | - | data $KEYWORDS$2 align 1 { |
|
| 9 | + | data $KEYWORDS$literal$2 align 1 { |
|
| 10 | 10 | str "if"; |
|
| 11 | 11 | } |
|
| 12 | 12 | ||
| 13 | 13 | data $KEYWORDS align 8 { |
|
| 14 | - | sym $KEYWORDS$0; |
|
| 14 | + | sym $KEYWORDS$literal$0; |
|
| 15 | 15 | w32 2; |
|
| 16 | 16 | w32 2; |
|
| 17 | 17 | w8 0; |
|
| 18 | 18 | undef * 7; |
|
| 19 | - | sym $KEYWORDS$1; |
|
| 19 | + | sym $KEYWORDS$literal$1; |
|
| 20 | 20 | w32 3; |
|
| 21 | 21 | w32 3; |
|
| 22 | 22 | w8 1; |
|
| 23 | 23 | undef * 7; |
|
| 24 | - | sym $KEYWORDS$2; |
|
| 24 | + | sym $KEYWORDS$literal$2; |
|
| 25 | 25 | w32 2; |
|
| 26 | 26 | w32 2; |
|
| 27 | 27 | w8 2; |
|
| 28 | 28 | undef * 7; |
|
| 29 | 29 | } |
test/tests/const.slice.of.slices.ril
+10 -10
| 1 | - | data $GROUPS$0 align 1 { |
|
| 1 | + | data $GROUPS$literal$0 align 1 { |
|
| 2 | 2 | str "ab"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $GROUPS$1 align 1 { |
|
| 5 | + | data $GROUPS$literal$1 align 1 { |
|
| 6 | 6 | str "cd"; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | - | data $GROUPS$2 align 8 { |
|
| 10 | - | sym $GROUPS$0; |
|
| 9 | + | data $GROUPS$literal$2 align 8 { |
|
| 10 | + | sym $GROUPS$literal$0; |
|
| 11 | 11 | w32 2; |
|
| 12 | 12 | w32 2; |
|
| 13 | - | sym $GROUPS$1; |
|
| 13 | + | sym $GROUPS$literal$1; |
|
| 14 | 14 | w32 2; |
|
| 15 | 15 | w32 2; |
|
| 16 | 16 | } |
|
| 17 | 17 | ||
| 18 | - | data $GROUPS$3 align 1 { |
|
| 18 | + | data $GROUPS$literal$3 align 1 { |
|
| 19 | 19 | str "efg"; |
|
| 20 | 20 | } |
|
| 21 | 21 | ||
| 22 | - | data $GROUPS$4 align 8 { |
|
| 23 | - | sym $GROUPS$3; |
|
| 22 | + | data $GROUPS$literal$4 align 8 { |
|
| 23 | + | sym $GROUPS$literal$3; |
|
| 24 | 24 | w32 3; |
|
| 25 | 25 | w32 3; |
|
| 26 | 26 | } |
|
| 27 | 27 | ||
| 28 | 28 | data $GROUPS align 8 { |
|
| 29 | - | sym $GROUPS$2; |
|
| 29 | + | sym $GROUPS$literal$2; |
|
| 30 | 30 | w32 2; |
|
| 31 | 31 | w32 2; |
|
| 32 | - | sym $GROUPS$4; |
|
| 32 | + | sym $GROUPS$literal$4; |
|
| 33 | 33 | w32 1; |
|
| 34 | 34 | w32 1; |
|
| 35 | 35 | } |
|
| 36 | 36 | ||
| 37 | 37 | fn w32 $totalLen() { |
test/tests/const.string.ril
+3 -3
| 1 | - | data $HELLO$0 align 1 { |
|
| 1 | + | data $HELLO$literal$0 align 1 { |
|
| 2 | 2 | str "hello"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | 5 | data $HELLO align 8 { |
|
| 6 | - | sym $HELLO$0; |
|
| 6 | + | sym $HELLO$literal$0; |
|
| 7 | 7 | w32 5; |
|
| 8 | 8 | w32 5; |
|
| 9 | 9 | } |
|
| 10 | 10 | ||
| 11 | 11 | fn w32 $getLen() { |
|
| 12 | 12 | @entry0 |
|
| 13 | - | copy %0 $HELLO$0; |
|
| 13 | + | copy %0 $HELLO$literal$0; |
|
| 14 | 14 | reserve %1 16 8; |
|
| 15 | 15 | store w64 %0 %1 0; |
|
| 16 | 16 | store w32 5 %1 8; |
|
| 17 | 17 | store w32 5 %1 12; |
|
| 18 | 18 | load w32 %2 %1 8; |
test/tests/const.string.scoped.names.ril
+8 -8
| 1 | - | data $HELLO1$0 align 1 { |
|
| 1 | + | data $HELLO1$literal$0 align 1 { |
|
| 2 | 2 | str "hello"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | 5 | data $HELLO1 align 8 { |
|
| 6 | - | sym $HELLO1$0; |
|
| 6 | + | sym $HELLO1$literal$0; |
|
| 7 | 7 | w32 5; |
|
| 8 | 8 | w32 5; |
|
| 9 | 9 | } |
|
| 10 | 10 | ||
| 11 | 11 | data $HELLO2 align 8 { |
|
| 12 | - | sym $HELLO1$0; |
|
| 12 | + | sym $HELLO1$literal$0; |
|
| 13 | 13 | w32 5; |
|
| 14 | 14 | w32 5; |
|
| 15 | 15 | } |
|
| 16 | 16 | ||
| 17 | - | data $MSGS$3 align 1 { |
|
| 17 | + | data $MSGS$literal$3 align 1 { |
|
| 18 | 18 | str "world"; |
|
| 19 | 19 | } |
|
| 20 | 20 | ||
| 21 | 21 | data $MSGS align 8 { |
|
| 22 | - | sym $HELLO1$0; |
|
| 22 | + | sym $HELLO1$literal$0; |
|
| 23 | 23 | w32 5; |
|
| 24 | 24 | w32 5; |
|
| 25 | - | sym $MSGS$3; |
|
| 25 | + | sym $MSGS$literal$3; |
|
| 26 | 26 | w32 5; |
|
| 27 | 27 | w32 5; |
|
| 28 | 28 | } |
|
| 29 | 29 | ||
| 30 | 30 | fn w32 $totalLen() { |
|
| 31 | 31 | @entry0 |
|
| 32 | - | copy %0 $HELLO1$0; |
|
| 32 | + | copy %0 $HELLO1$literal$0; |
|
| 33 | 33 | reserve %1 16 8; |
|
| 34 | 34 | store w64 %0 %1 0; |
|
| 35 | 35 | store w32 5 %1 8; |
|
| 36 | 36 | store w32 5 %1 12; |
|
| 37 | 37 | load w32 %2 %1 8; |
|
| 38 | - | copy %3 $HELLO1$0; |
|
| 38 | + | copy %3 $HELLO1$literal$0; |
|
| 39 | 39 | reserve %4 16 8; |
|
| 40 | 40 | store w64 %3 %4 0; |
|
| 41 | 41 | store w32 5 %4 8; |
|
| 42 | 42 | store w32 5 %4 12; |
|
| 43 | 43 | load w32 %5 %4 8; |
test/tests/literal.slice.bytes.ril
+2 -2
| 1 | - | data $byteSlice0 align 1 { |
|
| 1 | + | data $byteSlice$literal$0 align 1 { |
|
| 2 | 2 | w8 65; |
|
| 3 | 3 | w8 66; |
|
| 4 | 4 | w8 67; |
|
| 5 | 5 | } |
|
| 6 | 6 | ||
| 7 | 7 | fn w32 $byteSlice() { |
|
| 8 | 8 | @entry0 |
|
| 9 | - | copy %0 $byteSlice0; |
|
| 9 | + | copy %0 $byteSlice$literal$0; |
|
| 10 | 10 | reserve %1 16 8; |
|
| 11 | 11 | store w64 %0 %1 0; |
|
| 12 | 12 | store w32 3 %1 8; |
|
| 13 | 13 | store w32 3 %1 12; |
|
| 14 | 14 | load w32 %2 %1 8; |
test/tests/literal.slice.dedup.ril
+3 -3
| 1 | - | data $dedupSlice0 align 4 { |
|
| 1 | + | data $dedupSlice$literal$0 align 4 { |
|
| 2 | 2 | w32 1; |
|
| 3 | 3 | w32 2; |
|
| 4 | 4 | w32 3; |
|
| 5 | 5 | } |
|
| 6 | 6 | ||
| 7 | 7 | fn w32 $dedupSlice() { |
|
| 8 | 8 | @entry0 |
|
| 9 | - | copy %0 $dedupSlice0; |
|
| 9 | + | copy %0 $dedupSlice$literal$0; |
|
| 10 | 10 | reserve %1 16 8; |
|
| 11 | 11 | store w64 %0 %1 0; |
|
| 12 | 12 | store w32 3 %1 8; |
|
| 13 | 13 | store w32 3 %1 12; |
|
| 14 | - | copy %2 $dedupSlice0; |
|
| 14 | + | copy %2 $dedupSlice$literal$0; |
|
| 15 | 15 | reserve %3 16 8; |
|
| 16 | 16 | store w64 %2 %3 0; |
|
| 17 | 17 | store w32 3 %3 8; |
|
| 18 | 18 | store w32 3 %3 12; |
|
| 19 | 19 | load w32 %4 %1 8; |
test/tests/literal.slice.multi.ril
+4 -4
| 1 | - | data $multiSlice0 align 4 { |
|
| 1 | + | data $multiSlice$literal$0 align 4 { |
|
| 2 | 2 | w32 1; |
|
| 3 | 3 | w32 2; |
|
| 4 | 4 | } |
|
| 5 | 5 | ||
| 6 | - | data $multiSlice1 align 4 { |
|
| 6 | + | data $multiSlice$literal$1 align 4 { |
|
| 7 | 7 | w32 3; |
|
| 8 | 8 | w32 4; |
|
| 9 | 9 | w32 5; |
|
| 10 | 10 | } |
|
| 11 | 11 | ||
| 12 | 12 | fn w32 $multiSlice() { |
|
| 13 | 13 | @entry0 |
|
| 14 | - | copy %0 $multiSlice0; |
|
| 14 | + | copy %0 $multiSlice$literal$0; |
|
| 15 | 15 | reserve %1 16 8; |
|
| 16 | 16 | store w64 %0 %1 0; |
|
| 17 | 17 | store w32 2 %1 8; |
|
| 18 | 18 | store w32 2 %1 12; |
|
| 19 | - | copy %2 $multiSlice1; |
|
| 19 | + | copy %2 $multiSlice$literal$1; |
|
| 20 | 20 | reserve %3 16 8; |
|
| 21 | 21 | store w64 %2 %3 0; |
|
| 22 | 22 | store w32 3 %3 8; |
|
| 23 | 23 | store w32 3 %3 12; |
|
| 24 | 24 | load w32 %4 %1 8; |
test/tests/literal.slice.record.ril
+2 -2
| 1 | - | data $localSliceOfRecords0 align 4 { |
|
| 1 | + | data $localSliceOfRecords$literal$0 align 4 { |
|
| 2 | 2 | w32 5; |
|
| 3 | 3 | w32 6; |
|
| 4 | 4 | w32 7; |
|
| 5 | 5 | w32 8; |
|
| 6 | 6 | } |
|
| 7 | 7 | ||
| 8 | 8 | fn w32 $localSliceOfRecords() { |
|
| 9 | 9 | @entry0 |
|
| 10 | - | copy %0 $localSliceOfRecords0; |
|
| 10 | + | copy %0 $localSliceOfRecords$literal$0; |
|
| 11 | 11 | reserve %1 16 8; |
|
| 12 | 12 | store w64 %0 %1 0; |
|
| 13 | 13 | store w32 2 %1 8; |
|
| 14 | 14 | store w32 2 %1 12; |
|
| 15 | 15 | load w32 %2 %1 8; |
test/tests/literal.slice.ril
+2 -2
| 1 | - | data $sliceLiteral0 align 4 { |
|
| 1 | + | data $sliceLiteral$literal$0 align 4 { |
|
| 2 | 2 | w32 1; |
|
| 3 | 3 | w32 2; |
|
| 4 | 4 | w32 3; |
|
| 5 | 5 | } |
|
| 6 | 6 | ||
| 7 | 7 | fn w32 $sliceLiteral() { |
|
| 8 | 8 | @entry0 |
|
| 9 | - | copy %0 $sliceLiteral0; |
|
| 9 | + | copy %0 $sliceLiteral$literal$0; |
|
| 10 | 10 | reserve %1 16 8; |
|
| 11 | 11 | store w64 %0 %1 0; |
|
| 12 | 12 | store w32 3 %1 8; |
|
| 13 | 13 | store w32 3 %1 12; |
|
| 14 | 14 | load w32 %2 %1 8; |
test/tests/literal.string.dedup.ril
+3 -3
| 1 | - | data $dedupString0 align 1 { |
|
| 1 | + | data $dedupString$literal$0 align 1 { |
|
| 2 | 2 | str "hello"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | 5 | fn w32 $dedupString() { |
|
| 6 | 6 | @entry0 |
|
| 7 | - | copy %0 $dedupString0; |
|
| 7 | + | copy %0 $dedupString$literal$0; |
|
| 8 | 8 | reserve %1 16 8; |
|
| 9 | 9 | store w64 %0 %1 0; |
|
| 10 | 10 | store w32 5 %1 8; |
|
| 11 | 11 | store w32 5 %1 12; |
|
| 12 | - | copy %2 $dedupString0; |
|
| 12 | + | copy %2 $dedupString$literal$0; |
|
| 13 | 13 | reserve %3 16 8; |
|
| 14 | 14 | store w64 %2 %3 0; |
|
| 15 | 15 | store w32 5 %3 8; |
|
| 16 | 16 | store w32 5 %3 12; |
|
| 17 | 17 | load w32 %4 %1 8; |
test/tests/literal.string.empty.ril
+2 -2
| 1 | - | data $emptyString0 align 1 { |
|
| 1 | + | data $emptyString$literal$0 align 1 { |
|
| 2 | 2 | str ""; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | 5 | fn w32 $emptyString() { |
|
| 6 | 6 | @entry0 |
|
| 7 | - | copy %0 $emptyString0; |
|
| 7 | + | copy %0 $emptyString$literal$0; |
|
| 8 | 8 | reserve %1 16 8; |
|
| 9 | 9 | store w64 %0 %1 0; |
|
| 10 | 10 | store w32 0 %1 8; |
|
| 11 | 11 | store w32 0 %1 12; |
|
| 12 | 12 | load w32 %2 %1 8; |
test/tests/literal.string.fns.ril
+4 -4
| 1 | - | data $first0 align 1 { |
|
| 1 | + | data $first$literal$0 align 1 { |
|
| 2 | 2 | str "foo"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $second0 align 1 { |
|
| 5 | + | data $second$literal$0 align 1 { |
|
| 6 | 6 | str "bar"; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | 9 | fn w32 $first() { |
|
| 10 | 10 | @entry0 |
|
| 11 | - | copy %0 $first0; |
|
| 11 | + | copy %0 $first$literal$0; |
|
| 12 | 12 | reserve %1 16 8; |
|
| 13 | 13 | store w64 %0 %1 0; |
|
| 14 | 14 | store w32 3 %1 8; |
|
| 15 | 15 | store w32 3 %1 12; |
|
| 16 | 16 | load w32 %2 %1 8; |
|
| 17 | 17 | ret %2; |
|
| 18 | 18 | } |
|
| 19 | 19 | ||
| 20 | 20 | fn w32 $second() { |
|
| 21 | 21 | @entry0 |
|
| 22 | - | copy %0 $second0; |
|
| 22 | + | copy %0 $second$literal$0; |
|
| 23 | 23 | reserve %1 16 8; |
|
| 24 | 24 | store w64 %0 %1 0; |
|
| 25 | 25 | store w32 3 %1 8; |
|
| 26 | 26 | store w32 3 %1 12; |
|
| 27 | 27 | load w32 %2 %1 8; |
test/tests/literal.string.multi.ril
+4 -4
| 1 | - | data $multiString0 align 1 { |
|
| 1 | + | data $multiString$literal$0 align 1 { |
|
| 2 | 2 | str "hello"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $multiString1 align 1 { |
|
| 5 | + | data $multiString$literal$1 align 1 { |
|
| 6 | 6 | str "world"; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | 9 | fn w32 $multiString() { |
|
| 10 | 10 | @entry0 |
|
| 11 | - | copy %0 $multiString0; |
|
| 11 | + | copy %0 $multiString$literal$0; |
|
| 12 | 12 | reserve %1 16 8; |
|
| 13 | 13 | store w64 %0 %1 0; |
|
| 14 | 14 | store w32 5 %1 8; |
|
| 15 | 15 | store w32 5 %1 12; |
|
| 16 | - | copy %2 $multiString1; |
|
| 16 | + | copy %2 $multiString$literal$1; |
|
| 17 | 17 | reserve %3 16 8; |
|
| 18 | 18 | store w64 %2 %3 0; |
|
| 19 | 19 | store w32 5 %3 8; |
|
| 20 | 20 | store w32 5 %3 12; |
|
| 21 | 21 | load w32 %4 %1 8; |
test/tests/literal.string.ril
+2 -2
| 1 | - | data $stringLen0 align 1 { |
|
| 1 | + | data $stringLen$literal$0 align 1 { |
|
| 2 | 2 | str "hello"; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | 5 | fn w32 $stringLen() { |
|
| 6 | 6 | @entry0 |
|
| 7 | - | copy %0 $stringLen0; |
|
| 7 | + | copy %0 $stringLen$literal$0; |
|
| 8 | 8 | reserve %1 16 8; |
|
| 9 | 9 | store w64 %0 %1 0; |
|
| 10 | 10 | store w32 5 %1 8; |
|
| 11 | 11 | store w32 5 %1 12; |
|
| 12 | 12 | load w32 %2 %1 8; |
test/tests/lower.const.record.ident.ril
added
+35 -0
| 1 | + | data $A0 align 1 { |
|
| 2 | + | w8 10; |
|
| 3 | + | } |
|
| 4 | + | ||
| 5 | + | data $A1 align 1 { |
|
| 6 | + | w8 11; |
|
| 7 | + | } |
|
| 8 | + | ||
| 9 | + | data $ENTRIES$literal$2 align 1 { |
|
| 10 | + | str "a0"; |
|
| 11 | + | } |
|
| 12 | + | ||
| 13 | + | data $ENTRIES$literal$3 align 1 { |
|
| 14 | + | str "a1"; |
|
| 15 | + | } |
|
| 16 | + | ||
| 17 | + | data $ENTRIES align 8 { |
|
| 18 | + | sym $ENTRIES$literal$2; |
|
| 19 | + | w32 2; |
|
| 20 | + | w32 2; |
|
| 21 | + | w8 10; |
|
| 22 | + | undef * 7; |
|
| 23 | + | undef * 7; |
|
| 24 | + | sym $ENTRIES$literal$3; |
|
| 25 | + | w32 2; |
|
| 26 | + | w32 2; |
|
| 27 | + | w8 11; |
|
| 28 | + | undef * 7; |
|
| 29 | + | undef * 7; |
|
| 30 | + | } |
|
| 31 | + | ||
| 32 | + | fn w32 $main() { |
|
| 33 | + | @entry0 |
|
| 34 | + | ret 2; |
|
| 35 | + | } |
test/tests/lower.private.union.const.ril
added
+25 -0
| 1 | + | data $ENTRIES$literal$0 align 1 { |
|
| 2 | + | str "a"; |
|
| 3 | + | } |
|
| 4 | + | ||
| 5 | + | data $ENTRIES$literal$1 align 1 { |
|
| 6 | + | str "b"; |
|
| 7 | + | } |
|
| 8 | + | ||
| 9 | + | data $ENTRIES align 8 { |
|
| 10 | + | sym $ENTRIES$literal$0; |
|
| 11 | + | w32 1; |
|
| 12 | + | w32 1; |
|
| 13 | + | w8 0; |
|
| 14 | + | undef * 7; |
|
| 15 | + | sym $ENTRIES$literal$1; |
|
| 16 | + | w32 1; |
|
| 17 | + | w32 1; |
|
| 18 | + | w8 1; |
|
| 19 | + | undef * 7; |
|
| 20 | + | } |
|
| 21 | + | ||
| 22 | + | fn w32 $main() { |
|
| 23 | + | @entry0 |
|
| 24 | + | ret 2; |
|
| 25 | + | } |
test/tests/lower.record.scalar.record.const.ril
added
+25 -0
| 1 | + | data $ENTRIES$literal$0 align 1 { |
|
| 2 | + | str "a0"; |
|
| 3 | + | } |
|
| 4 | + | ||
| 5 | + | data $ENTRIES$literal$1 align 1 { |
|
| 6 | + | str "a1"; |
|
| 7 | + | } |
|
| 8 | + | ||
| 9 | + | data $ENTRIES align 8 { |
|
| 10 | + | sym $ENTRIES$literal$0; |
|
| 11 | + | w32 2; |
|
| 12 | + | w32 2; |
|
| 13 | + | w8 10; |
|
| 14 | + | undef * 7; |
|
| 15 | + | sym $ENTRIES$literal$1; |
|
| 16 | + | w32 2; |
|
| 17 | + | w32 2; |
|
| 18 | + | w8 11; |
|
| 19 | + | undef * 7; |
|
| 20 | + | } |
|
| 21 | + | ||
| 22 | + | fn w32 $main() { |
|
| 23 | + | @entry0 |
|
| 24 | + | ret 2; |
|
| 25 | + | } |
test/tests/ptr.deref.ril
+2 -2
| 1 | - | data $main0 align 4 { |
|
| 1 | + | data $main$literal$0 align 4 { |
|
| 2 | 2 | w32 2; |
|
| 3 | 3 | w32 4; |
|
| 4 | 4 | w32 6; |
|
| 5 | 5 | } |
|
| 6 | 6 |
| 48 | 48 | reserve %3 12 4; |
|
| 49 | 49 | store w32 7 %3 0; |
|
| 50 | 50 | store w32 8 %3 4; |
|
| 51 | 51 | store w32 9 %3 8; |
|
| 52 | 52 | call w32 %4 $derefArrayIndex(%3); |
|
| 53 | - | copy %5 $main0; |
|
| 53 | + | copy %5 $main$literal$0; |
|
| 54 | 54 | reserve %6 16 8; |
|
| 55 | 55 | store w64 %5 %6 0; |
|
| 56 | 56 | store w32 3 %6 8; |
|
| 57 | 57 | store w32 3 %6 12; |
|
| 58 | 58 | call w32 %7 $derefSliceIndex(%6); |
test/tests/static.local.decl.ril
+5 -5
| 1 | - | data mut $LOCAL align 4 { |
|
| 1 | + | data mut $localStaticAndConst$nominal$LOCAL align 4 { |
|
| 2 | 2 | w32 7; |
|
| 3 | 3 | } |
|
| 4 | 4 | ||
| 5 | - | data $ADD align 4 { |
|
| 5 | + | data $localStaticAndConst$nominal$ADD align 4 { |
|
| 6 | 6 | w32 5; |
|
| 7 | 7 | } |
|
| 8 | 8 | ||
| 9 | 9 | fn w32 $localStaticAndConst() { |
|
| 10 | 10 | @entry0 |
|
| 11 | - | copy %0 $LOCAL; |
|
| 11 | + | copy %0 $localStaticAndConst$nominal$LOCAL; |
|
| 12 | 12 | sload w32 %1 %0 0; |
|
| 13 | 13 | add w32 %2 %1 5; |
|
| 14 | - | copy %3 $LOCAL; |
|
| 14 | + | copy %3 $localStaticAndConst$nominal$LOCAL; |
|
| 15 | 15 | store w32 %2 %3 0; |
|
| 16 | - | copy %4 $LOCAL; |
|
| 16 | + | copy %4 $localStaticAndConst$nominal$LOCAL; |
|
| 17 | 17 | sload w32 %5 %4 0; |
|
| 18 | 18 | ret %5; |
|
| 19 | 19 | } |
test/tests/trait.supertrait.ril
+2 -2
| 10 | 10 | fn $"Socket::read"; |
|
| 11 | 11 | fn $"Socket::write"; |
|
| 12 | 12 | fn $"Socket::flush"; |
|
| 13 | 13 | } |
|
| 14 | 14 | ||
| 15 | - | data $main0 align 1 { |
|
| 15 | + | data $main$literal$0 align 1 { |
|
| 16 | 16 | str "abc"; |
|
| 17 | 17 | } |
|
| 18 | 18 | ||
| 19 | 19 | fn w32 $"Socket::read"(w64 %0, w64 %1) { |
|
| 20 | 20 | @entry0 |
| 125 | 125 | store w64 %0 %5 0; |
|
| 126 | 126 | store w64 $"vtable::Socket::ReadWriter" %5 8; |
|
| 127 | 127 | load w64 %6 %5 0; |
|
| 128 | 128 | load w64 %7 %5 8; |
|
| 129 | 129 | load w64 %8 %7 8; |
|
| 130 | - | copy %9 $main0; |
|
| 130 | + | copy %9 $main$literal$0; |
|
| 131 | 131 | reserve %10 16 8; |
|
| 132 | 132 | store w64 %9 %10 0; |
|
| 133 | 133 | store w32 3 %10 8; |
|
| 134 | 134 | store w32 3 %10 12; |
|
| 135 | 135 | call w32 %11 %8(%6, %10); |