all: reduce generated C size significantly

cmd/tools/fast/fast.v

@@ -74,6 +74,11 @@ fn main() {
 		ret := lsystem('${vdir}/v up')
 		if ret != 0 {
 			elog('failed to update V, exit_code: ${ret}')
+			// A failed `git pull --rebase` (e.g. on a shallow CI checkout)
+			// leaves the worktree with conflict markers in source files,
+			// which would break any subsequent V compilation step. Restore
+			// a clean state before returning.
+			lsystem('cd ${vdir} && git rebase --abort')
 			return
 		}
 	}

vlib/builtin/backtraces_nix.c.v

@@ -31,52 +31,56 @@ fn print_backtrace_skipping_top_frames_bsd(skipframes int) bool {
 				eprintln('C.backtrace returned less than 2 frames')
 				return false
 			}
-			nr_actual_frames := nr_ptrs - skipframes
-			csymbols := C.backtrace_symbols(voidptr(&buffer[skipframes]), nr_actual_frames)
-			atos_lines := bsd_backtrace_resolve_atos(&buffer[skipframes], nr_actual_frames)
-			for i in 0 .. nr_actual_frames {
-				sframe := unsafe { tos2(&u8(csymbols[i])) }
-				mut file_line := ''
-				if i < atos_lines.len {
-					file_line = atos_lines[i]
-				}
-				// macOS format: `0   main   0x00000001047232f8 veb__run_T_main__App_main__Context + 356`
-				symbol_start := sframe.index('0x') or { -1 }
-				if symbol_start < 0 {
-					continue
-				}
-				rest := sframe[symbol_start..]
-				space_after_addr := rest.index(' ') or { -1 }
-				if space_after_addr < 0 {
-					continue
-				}
-				symbol_and_offset := rest[space_after_addr + 1..]
-				plus_pos := symbol_and_offset.index(' + ') or { -1 }
-				mut raw_symbol := symbol_and_offset
-				if plus_pos >= 0 {
-					raw_symbol = symbol_and_offset[..plus_pos]
-				}
-				// Skip C runtime frames that are not V functions:
-				if raw_symbol in ['main', 'start', '_main'] {
-					continue
-				}
-				mut demangled := ''
-				if plus_pos >= 0 {
-					demangled = demangle_v_symbol(raw_symbol) + symbol_and_offset[plus_pos..]
-				} else {
-					demangled = demangle_v_symbol(raw_symbol)
+			$if detailed_backtraces ? {
+				nr_actual_frames := nr_ptrs - skipframes
+				csymbols := C.backtrace_symbols(voidptr(&buffer[skipframes]), nr_actual_frames)
+				atos_lines := bsd_backtrace_resolve_atos(&buffer[skipframes], nr_actual_frames)
+				for i in 0 .. nr_actual_frames {
+					sframe := unsafe { tos2(&u8(csymbols[i])) }
+					mut file_line := ''
+					if i < atos_lines.len {
+						file_line = atos_lines[i]
+					}
+					// macOS format: `0   main   0x00000001047232f8 veb__run_T_main__App_main__Context + 356`
+					symbol_start := sframe.index('0x') or { -1 }
+					if symbol_start < 0 {
+						continue
+					}
+					rest := sframe[symbol_start..]
+					space_after_addr := rest.index(' ') or { -1 }
+					if space_after_addr < 0 {
+						continue
+					}
+					symbol_and_offset := rest[space_after_addr + 1..]
+					plus_pos := symbol_and_offset.index(' + ') or { -1 }
+					mut raw_symbol := symbol_and_offset
+					if plus_pos >= 0 {
+						raw_symbol = symbol_and_offset[..plus_pos]
+					}
+					// Skip C runtime frames that are not V functions:
+					if raw_symbol in ['main', 'start', '_main'] {
+						continue
+					}
+					mut demangled := ''
+					if plus_pos >= 0 {
+						demangled = demangle_v_symbol(raw_symbol) + symbol_and_offset[plus_pos..]
+					} else {
+						demangled = demangle_v_symbol(raw_symbol)
+					}
+					if file_line.len > 0 {
+						eprint(file_line)
+						eprint_space_padding(file_line, 45)
+						eprint(' | ')
+						eprintln(demangled)
+					} else {
+						eprintln(demangled)
+					}
 				}
-				if file_line.len > 0 {
-					eprint(file_line)
-					eprint_space_padding(file_line, 45)
-					eprint(' | ')
-					eprintln(demangled)
-				} else {
-					eprintln(demangled)
+				if nr_actual_frames > 0 {
+					unsafe { C.free(csymbols) }
 				}
-			}
-			if nr_actual_frames > 0 {
-				unsafe { C.free(csymbols) }
+			} $else {
+				C.backtrace_symbols_fd(&buffer[skipframes], nr_ptrs - skipframes, 2)
 			}
 		}
 		return true

vlib/builtin/chan_option_result.v

@@ -180,6 +180,13 @@ fn _option_clone(current &_option, mut option _option, size int) {
 	}
 }
 
+@[markused]
+fn _result_ok_markused() {
+	mut res := _result{}
+	// Keep _result_ok emitted for code that constructs Result directly.
+	_result_ok(unsafe { nil }, mut res, 0)
+}
+
 //
 
 const none__ = IError(&None__{})

vlib/crypto/sha3/sha3.v

@@ -77,7 +77,8 @@ struct HashSizeError {
 }
 
 fn (err HashSizeError) msg() string {
-	return 'Hash size ${err.size} must be ${size_224}, ${size_256}, ${size_384}, or ${size_512}'
+	return 'Hash size ' + err.size.str() + ' must be ' + size_224.str() + ', ' + size_256.str() +
+		', ' + size_384.str() + ', or ' + size_512.str()
 }
 
 struct AbsorptionRateError {
@@ -87,7 +88,8 @@ struct AbsorptionRateError {
 }
 
 fn (err AbsorptionRateError) msg() string {
-	return 'Absorption rate ${err.rate} is not compatible with a hash size of ${err.size}'
+	return 'Absorption rate ' + err.rate.str() + ' is not compatible with a hash size of ' +
+		err.size.str()
 }
 
 struct XOFRateError {
@@ -96,7 +98,8 @@ struct XOFRateError {
 }
 
 fn (err XOFRateError) msg() string {
-	return 'Extended output rate ${err.rate} must be ${xof_rate_128} or ${xof_rate_256}'
+	return 'Extended output rate ' + err.rate.str() + ' must be ' + xof_rate_128.str() + ' or ' +
+		xof_rate_256.str()
 }
 
 struct XOFSizeError {
@@ -105,7 +108,7 @@ struct XOFSizeError {
 }
 
 fn (err XOFSizeError) msg() string {
-	return 'Extended output size ${err.size} must be > 0'
+	return 'Extended output size ' + err.size.str() + ' must be > 0'
 }
 
 struct Digest {
@@ -146,9 +149,13 @@ pub fn new_digest(absorption_rate int, hash_size int, config PaddingConfig) !&Di
 		.xof { validate_xof(absorption_rate, hash_size)! }
 	}
 
+	return new_digest_unchecked(absorption_rate, hash_size, config.padding)
+}
+
+fn new_digest_unchecked(absorption_rate int, hash_size int, padding Padding) &Digest {
 	d := Digest{
 		rate:       absorption_rate
-		suffix:     u8(config.padding)
+		suffix:     u8(padding)
 		output_len: hash_size
 		s:          State{}
 	}
@@ -232,6 +239,10 @@ fn validate_xof(absorption_rate int, hash_size int) ! {
 //
 // This is the absorption phase of the computation.
 pub fn (mut d Digest) write(data []u8) ! {
+	d.write_bytes(data)
+}
+
+fn (mut d Digest) write_bytes(data []u8) {
 	// if no data is being added to the hash,
 	// just return
 	if data.len == 0 {
@@ -279,10 +290,10 @@ pub fn (mut d Digest) write(data []u8) ! {
 
 // checksum finalizes the hash and returns the generated bytes.
 pub fn (mut d Digest) checksum() []u8 {
-	return d.checksum_internal() or { panic(err) }
+	return d.checksum_internal()
 }
 
-fn (mut d Digest) checksum_internal() ![]u8 {
+fn (mut d Digest) checksum_internal() []u8 {
 	// pad the last input bytes to have rate bytes
 	if d.input_buffer.len == d.rate - 1 {
 		// a single byte pad needs to be handled specially
@@ -338,56 +349,56 @@ fn (mut d Digest) checksum_internal() ![]u8 {
 
 // sum512 returns the sha3 512 bit checksum of the data.
 pub fn sum512(data []u8) []u8 {
-	mut d := new512() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_512, size_512, .sha3)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // sum384 returns the sha3 384 bit checksum of the data.
 pub fn sum384(data []u8) []u8 {
-	mut d := new384() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_384, size_384, .sha3)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // sum256 returns the sha3 256 bit checksum of the data.
 pub fn sum256(data []u8) []u8 {
-	mut d := new256() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_256, size_256, .sha3)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // sum224 returns the sha3 224 bit checksum of the data.
 pub fn sum224(data []u8) []u8 {
-	mut d := new224() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_224, size_224, .sha3)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // keccak256 returns the keccak 256 bit checksum of the data.
 pub fn keccak256(data []u8) []u8 {
-	mut d := new256keccak() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_256, size_256, .keccak)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // keccak512 returns the keccak 512 bit checksum of the data.
 pub fn keccak512(data []u8) []u8 {
-	mut d := new512keccak() or { panic(err) }
-	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	mut d := new_digest_unchecked(rate_512, size_512, .keccak)
+	d.write_bytes(data)
+	return d.checksum_internal()
 }
 
 // shake256 returns the sha3 shake256 bit extended output
 pub fn shake256(data []u8, output_len int) []u8 {
 	mut d := new256xof(output_len) or { panic(err) }
 	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	return d.checksum_internal()
 }
 
 // shake128 returns the sha3 shake128 bit extended output
 pub fn shake128(data []u8, output_len int) []u8 {
 	mut d := new128xof(output_len) or { panic(err) }
 	d.write(data) or { panic(err) }
-	return d.checksum_internal() or { panic(err) }
+	return d.checksum_internal()
 }

vlib/crypto/sha3/sha3_state_generic.v

@@ -8,7 +8,6 @@
 // Last updated: August 2015
 module sha3
 
-import encoding.binary
 import math.bits
 
 // when the state is 1600 bits, a lane is 64 bits
@@ -20,6 +19,29 @@ mut:
 	a [5][5]Lane
 }
 
+@[direct_array_access; inline]
+fn read_u64_le_at(b []u8, offset int) u64 {
+	_ = b[offset]
+	_ = b[offset + 7]
+	return u64(b[offset]) | (u64(b[offset + 1]) << 8) | (u64(b[offset + 2]) << 16) | (u64(b[
+		offset + 3]) << 24) | (u64(b[offset + 4]) << 32) | (u64(b[offset + 5]) << 40) | (u64(b[
+		offset + 6]) << 48) | (u64(b[offset + 7]) << 56)
+}
+
+@[direct_array_access; inline]
+fn put_u64_le_at(mut b []u8, value u64, offset int) {
+	_ = b[offset]
+	_ = b[offset + 7]
+	b[offset] = u8(value)
+	b[offset + 1] = u8(value >> 8)
+	b[offset + 2] = u8(value >> 16)
+	b[offset + 3] = u8(value >> 24)
+	b[offset + 4] = u8(value >> 32)
+	b[offset + 5] = u8(value >> 40)
+	b[offset + 6] = u8(value >> 48)
+	b[offset + 7] = u8(value >> 56)
+}
+
 // to_bytes converts the state into a byte array
 //
 // A 1600 bit state fits into 200 bytes.
@@ -35,9 +57,7 @@ fn (s State) to_bytes() []u8 {
 
 	for y in 0 .. 5 {
 		for x in 0 .. 5 {
-			unsafe {
-				binary.little_endian_put_u64_at(mut byte_array, s.a[x][y], index)
-			}
+			put_u64_le_at(mut byte_array, s.a[x][y], index)
 			index += 8
 		}
 	}
@@ -57,7 +77,7 @@ fn (mut s State) from_bytes(byte_array []u8) {
 
 	for y in 0 .. 5 {
 		for x in 0 .. 5 {
-			s.a[x][y] = binary.little_endian_u64_at(byte_array, index)
+			s.a[x][y] = read_u64_le_at(byte_array, index)
 			index += 8
 		}
 	}
@@ -79,7 +99,7 @@ fn (mut s State) xor_bytes(byte_array []u8, rate int) {
 
 	for y in 0 .. 5 {
 		for x in 0 .. 5 {
-			s.a[x][y] ^= binary.little_endian_u64_at(byte_array, index)
+			s.a[x][y] ^= read_u64_le_at(byte_array, index)
 			index += 8
 
 			if index >= rate {
@@ -175,12 +195,3 @@ const iota_round_constants = [u64(0x0000000000000001), 0x0000000000008082, 0x800
 	0x8000000000008003, 0x8000000000008002, 0x8000000000000080, 0x000000000000800a,
 	0x800000008000000a, 0x8000000080008081, 0x8000000000008080, 0x0000000080000001,
 	0x8000000080008008]
-
-fn (s State) str() string {
-	mut output := '\n             y = 0            y = 1            y = 2            y = 3            y = 4\n'
-	for x in 0 .. 5 {
-		output += 'x = ${x}: ${s.a[x][0]:016x} ${s.a[x][1]:016x} ${s.a[x][2]:016x} ${s.a[x][3]:016x} ${s.a[x][4]:016x}\n'
-	}
-
-	return output
-}

vlib/strconv/atof.c.v

@@ -429,14 +429,13 @@ fn converter(mut pn PrepNumber) u64 {
 	return result
 }
 
-@[markused; params]
+@[params]
 pub struct AtoF64Param {
 pub:
 	allow_extra_chars bool // allow extra characters after number
 }
 
 // atof64 parses the string `s`, and if possible, converts it into a f64 number
-@[markused]
 pub fn atof64(s string, param AtoF64Param) !f64 {
 	if s.len == 0 {
 		return error('expected a number found an empty string')