在Go语言中处理负数十六进制补码表示的教程

// lbladdr 存储目标标签地址
// address 存储当前内存地址
// label[x] 存储计算出的偏移量
if address > lbladdr {
    lbladdr -= address // 此时 lbladdr 可能为负数
}
// 尝试将 lbladdr 格式化为十六进制字符串
label[x] = strconv.FormatInt(int64(lbladdr), 16)

package main

import (
    "fmt"
    "strconv"
)

// formatTwosComplementHex 将带符号整数格式化为指定位宽的补码十六进制字符串。
// val: 待格式化的整数。
// bitWidth: 目标位宽 (例如 8, 16, 32, 64)。
// 返回: 补码十六进制字符串。
func formatTwosComplementHex(val int64, bitWidth int) (string, error) {
    if bitWidth <= 0 || bitWidth > 64 || bitWidth%4 != 0 {
        return "", fmt.Errorf("无效的位宽: %d。位宽必须是4的倍数且在1到64之间", bitWidth)
    }

    // 创建一个掩码，用于截取指定位宽的补码表示。
    // 例如，8位宽的掩码是 0xFF (2^8 - 1)。
    // 注意：这里使用 uint(bitWidth) 来避免左移操作符对负数位移的未定义行为。
    mask := (uint64(1) << uint(bitWidth)) - 1

    // 将带符号整数转换为无符号整数。
    // Go会自动处理负数的补码转换，例如 int64(-1) 转换为 uint64 得到一个非常大的正数，
    // 其低64位就是 -1 的64位补码表示。
    unsignedVal := uint64(val)

    // 与掩码进行按位与操作，以确保只保留指定位宽的值。
    // 这样，无论原始 int64 是多少位，我们都只取其低 bitWidth 位的补码。
    resultVal := unsignedVal & mask

    // 使用 fmt.Sprintf 格式化为大写十六进制字符串。
    // %0*X 表示用0填充到指定宽度，*表示宽度由参数提供。
    // bitWidth/4 是十六进制数字的宽度，因为一个十六进制数字代表4位。
    return fmt.Sprintf("%0*X", bitWidth/4, resultVal), nil
}

func main() {
    // 原始问题场景模拟
    lbladdr := int64(0x10) // 假设目标地址
    address := int64(0x12) // 假设当前地址

    fmt.Println("--- 原始问题情境示例 ---")
    fmt.Printf("目标地址 lbladdr: %d (0x%X)\n", lbladdr, lbladdr)
    fmt.Printf("当前地址 address: %d (0x%X)\n", address, address)

    offset := lbladdr - address // 计算偏移量，结果为 -2
    fmt.Printf("计算出的偏移量: %d\n", offset)

    // 使用 strconv.FormatInt 格式化
    fmt.Printf("使用 strconv.FormatInt(offset, 16): %s (这不是8位补码)\n", strconv.FormatInt(offset, 16))

    // 使用自定义函数格式化为8位补码十六进制
    hex8Bit, err := formatTwosComplementHex(offset, 8)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("使用 formatTwosComplementHex(offset, 8): %s (8位补码)\n", hex8Bit) // 期望输出 FE
    }

    // 使用自定义函数格式化为16位补码十六进制
    hex16Bit, err := formatTwosComplementHex(offset, 16)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Printf("使用 formatTwosComplementHex(offset, 16): %s (16位补码)\n", hex16Bit) // 期望输出 FFFE
    }

    fmt.Println("\n--- 更多示例 ---")
    // 8位补码示例
    fmt.Println("--- 8位补码 ---")
    printFormattedHex(1, 8)    // 01
    printFormattedHex(-1, 8)   // FF
    printFormattedHex(-128, 8) // 80 (8位有符号数的最小值)
    printFormattedHex(127, 8)  // 7F (8位有符号数的最大值)

    // 16位补码示例
    fmt.Println("\n--- 16位补码 ---")
    printFormattedHex(1, 16)     // 0001
    printFormattedHex(-1, 16)    // FFFF
    printFormattedHex(-32768, 16) // 8000 (16位有符号数的最小值)
    printFormattedHex(32767, 16)  // 7FFF (16位有符号数的最大值)

    // 32位补码示例
    fmt.Println("\n--- 32位补码 ---")
    printFormattedHex(-1, 32) // FFFFFFFF
    printFormattedHex(-2, 32) // FFFFFFFE

    // 64位补码示例
    fmt.Println("\n--- 64位补码 ---")
    printFormattedHex(-1, 64) // FFFFFFFFFFFFFFFF

    // 错误处理示例
    fmt.Println("\n--- 错误处理 ---")
    printFormattedHex(10, 7) // 无效位宽
    printFormattedHex(10, 0) // 无效位宽
    printFormattedHex(10, 68) // 无效位宽
}

// 辅助函数，用于打印格式化结果
func printFormattedHex(val int64, bitWidth int) {
    res, err := formatTwosComplementHex(val, bitWidth)
    if err != nil {
        fmt.Printf("formatTwosComplementHex(%d, %d): %v\n", val, bitWidth, err)
    } else {
        fmt.Printf("formatTwosComplementHex(%d, %d): %s\n", val, bitWidth, res)
    }
}