GCC内联汇编asm volatile

// 基本内联汇编 —— 最基本的形式asm("nop"); // 使用 __asm__ 关键字（等效写法）__asm__("nop"); // 多行指令asm(    "movl %eax, %ebx\n\t"    "addl $1, %ebx\n\t");

// volatile 内联汇编 —— 禁止编译器优化/重排asm volatile("rdtsc" : "=a"(lo), "=d"(hi)); // __volatile__ 等效写法__asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));

// 典型扩展内联汇编示例：两数相加int a = 10, b = 20, result; asm volatile(    "addl %[in], %[out]"    : [out] "=r"(result)        // 输出操作数    : [in] "r"(b), "0"(a)        // 输入操作数    : "cc"                        // 条件码寄存器被修改);// result = a + b = 30

// 约束字符串示例// "r"  —— 通用寄存器// "m"  —— 内存操作数// "i"  —— 立即数// "=&r" —— 早期clobber输出寄存器// "+r" —— 读写操作数 int x = 5;asm volatile("incl %0" : "+r"(x));  // x += 1

// 1. 基本内联汇编asm("nop"); // 2. 扩展内联汇编int out;asm("movl $42, %0" : "=r"(out)); // 3. volatile 内联汇编asm volatile("" : : : "memory");  // 内存屏障 // 4. goto 内联汇编asm goto(    "btl %1, %0\n\t"    "jc %l[carry]"    : : "r"(flags), "i"(bit)    : "cc"    : carry);carry:    // 进位处理

// 常见约束类型速查// r: 通用寄存器asm("movl %0, %%eax" : : "r"(val)); // m: 内存操作数asm("lock; addl $1, %0" : "=m"(counter)); // i: 立即数asm("shll %1, %0" : "=r"(result) : "i"(shift), "0"(value)); // n: 已知数值立即数asm("addl %1, %0" : "=r"(x) : "r"(y), "n"(42));

// 场景1: 读取时间戳计数器 (RDTSC)static inline uint64_t rdtsc(void) {    uint32_t lo, hi;    asm volatile("rdtsc" : "=a"(lo), "=d"(hi));    return ((uint64_t)hi << 32) | lo;} // 场景2: 内存屏障 (MFENCE)static inline void smp_mb(void) {    asm volatile("mfence" ::: "memory");} // 场景3: CAS 原子操作static inline int cas(volatile int *ptr, int old, int new) {    int prev;    asm volatile(        "lock; cmpxchgl %[new], %[mem]"        : "=a"(prev), [mem] "+m"(*ptr)        : [new] "r"(new), "0"(old)        : "cc", "memory"    );    return prev;}

// 最佳实践：使用宏封装内联汇编#define RDTSC(low, high) \    asm volatile("rdtsc" : "=a"(low), "=d"(high)) // 最佳实践：提供多个架构的实现#ifdef __x86_64__#define MB() asm volatile("mfence" ::: "memory")#elif defined(__aarch64__)#define MB() asm volatile("dmb ish" ::: "memory")#else#define MB() asm volatile("" ::: "memory")#endif // 最佳实践：使用命名操作数#define ADD_CONST(x, c)                               \    ({                                                \        typeof(x) _x = (x);                           \        asm volatile(                                 \            "addl %[const], %[val]"                   \            : [val] "+r"(_x)                          \            : [const] "i"(c)                          \            : "cc"                                    \        );                                            \        _x;                                           \    })

#!/usr/bin/env python3# -*- coding: utf-8 -*-"""GCC 内联汇编模板解析器解析 asm volatile 模板字符串，提取操作数、约束和 Clobber 信息。""" import re class InlineAsmParser:    """GCC 扩展内联汇编模板解析器"""     # 常见约束分类    CONSTRAINT_TYPES = {        'r': '通用寄存器',        'm': '内存操作数',        'i': '立即数',        'n': '已知数值立即数',        'g': '通用操作数(r/m/i)',        'X': '任意操作数',        'p': '合法内存地址',        'a': 'eax/rax 寄存器(x86)',        'b': 'ebx/rbx 寄存器(x86)',        'c': 'ecx/rcx 寄存器(x86)',        'd': 'edx/rdx 寄存器(x86)',        'S': 'esi/rsi 寄存器(x86)',        'D': 'edi/rdi 寄存器(x86)',    }     def __init__(self, template: str):        self.template = template.strip()        self.is_volatile = False        self.assembler_template = ""        self.output_operands = []        self.input_operands = []        self.clobbers = []        self.goto_labels = []     def parse(self):        """解析内联汇编模板"""        self._detect_volatile()        self._extract_assembler_template()        self._extract_operands()        self._extract_clobbers_and_labels()        return self     def _detect_volatile(self):        """检测 volatile 修饰符"""        self.is_volatile = 'volatile' in self.template.split('(')[0]     def _extract_assembler_template(self):        """提取汇编指令模板"""        # 匹配第一个引号字符串        match = re.search(r'"([^"]*)"', self.template)        if match:            self.assembler_template = match.group(1)     def _extract_operands(self):        """提取输出和输入操作数"""        # 提取冒号分隔的部分        parts = self._split_by_colons(self.template)        # parts[0] = "asm volatile(...模板...)"        # parts[1] = 输出操作数        # parts[2] = 输入操作数        if len(parts) > 1 and parts[1].strip():            self.output_operands = self._parse_operand_list(parts[1], is_output=True)        if len(parts) > 2 and parts[2].strip():            self.input_operands = self._parse_operand_list(parts[2], is_output=False)     def _split_by_colons(self, text: str):        """按冒号分割，但忽略引号内和括号内的冒号"""        parts = []        current = []        in_quote = False        depth = 0        for ch in text:            if ch == '"':                in_quote = not in_quote            elif ch in '([{':                depth += 1            elif ch in ')]}':                depth -= 1            if ch == ':' and not in_quote and depth == 0:                parts.append(''.join(current))                current = []            else:                current.append(ch)        parts.append(''.join(current))        return parts     def _parse_operand_list(self, text: str, is_output: bool):        """解析操作数列表"""        operands = []        items = self._split_operands(text)        for item in items:            op = self._parse_single_operand(item.strip(), is_output)            if op:                operands.append(op)        return operands     def _split_operands(self, text: str):        """按逗号分割操作数，忽略括号内的逗号"""        items = []        current = []        depth = 0        for ch in text:            if ch in '([{':                depth += 1            elif ch in ')]}':                depth -= 1            if ch == ',' and depth == 0:                items.append(''.join(current))                current = []            else:                current.append(ch)        if current:            items.append(''.join(current))        return items     def _parse_single_operand(self, text: str, is_output: bool):        """解析单个操作数"""        if not text:            return None         op = {'raw': text, 'is_output': is_output, 'constraint': '', 'modifier': '', 'name': '', 'expression': ''}         # 检测命名操作数 [name]        name_match = re.match(r'\s*\[([^\]]+)\]', text)        if name_match:            op['name'] = name_match.group(1)            text = text[name_match.end():].strip()         # 提取约束字符串 (在引号内)        constraint_match = re.search(r'"([^"]*)"', text)        if constraint_match:            constraint = constraint_match.group(1)            # 解析修饰符            if constraint.startswith('='):                op['modifier'] = '= (仅写)'                constraint = constraint[1:]            elif constraint.startswith('+'):                op['modifier'] = '+ (读写)'                constraint = constraint[1:]            elif constraint.startswith('&'):                op['modifier'] = '& (早期clobber)'                constraint = constraint[1:]            op['constraint'] = constraint            op['constraint_desc'] = self.CONSTRAINT_TYPES.get(constraint, '未知约束')         # 提取表达式 (在括号内)        expr_match = re.search(r'\(([^)]*)\)', text)        if expr_match:            op['expression'] = expr_match.group(1).strip()         return op     def _extract_clobbers_and_labels(self):        """提取 Clobber 列表和 Goto 标签"""        parts = self._split_by_colons(self.template)        if len(parts) > 3 and parts[3].strip():            raw = parts[3].strip()            # 检测是否包含标签（goto内联汇编）            if '(' in raw:                # 包含 goto 标签                clobber_part = raw[:raw.index('(')].strip() if '(' in raw else ''                label_part = raw[raw.index('('):]                self.clobbers = [c.strip().strip('"') for c in self._split_operands(clobber_part) if c.strip()]                # 提取标签名                self.goto_labels = re.findall(r'\b([a-zA-Z_]\w*)\b', label_part)            else:                self.clobbers = [c.strip().strip('"') for c in self._split_operands(raw) if c.strip()]     def report(self) -> str:        """生成解析报告"""        lines = []        lines.append("=" * 60)        lines.append("GCC 内联汇编模板解析报告")        lines.append("=" * 60)        lines.append(f"Volatile: {'是' if self.is_volatile else '否'}")        lines.append(f"汇编模板: {self.assembler_template}")        lines.append(f"")        lines.append(f"输出操作数 ({len(self.output_operands)} 个):")        for i, op in enumerate(self.output_operands):            lines.append(f"  [{i}] {op['raw']}")            lines.append(f"      约束: {op['constraint']} ({op['constraint_desc']})")            lines.append(f"      修饰符: {op['modifier'] or '无'}")            lines.append(f"      表达式: {op['expression']}")        lines.append(f"")        lines.append(f"输入操作数 ({len(self.input_operands)} 个):")        for i, op in enumerate(self.input_operands):            lines.append(f"  [{i}] {op['raw']}")            lines.append(f"      约束: {op['constraint']} ({op['constraint_desc']})")            lines.append(f"      修饰符: {op['modifier'] or '无'}")            lines.append(f"      表达式: {op['expression']}")        lines.append(f"")        lines.append(f"Clobber 列表 ({len(self.clobbers)} 个): {self.clobbers}")        if self.goto_labels:            lines.append(f"Goto 标签 ({len(self.goto_labels)} 个): {self.goto_labels}")        lines.append("=" * 60)        return "\n".join(lines)  # ========== 测试用例 ==========if __name__ == "__main__":    test_cases = [        # 测试1: 基本扩展内联汇编        'asm volatile("addl %[in], %[out]" : [out] "=r"(result) : [in] "r"(b), "0"(a) : "cc")',        # 测试2: 带 memory clobber        'asm volatile("mfence" ::: "memory")',        # 测试3: 多输出操作数        'asm volatile("rdtsc" : "=a"(lo), "=d"(hi))',        # 测试4: 早期 clobber        'asm volatile("movl $1, %0; addl %1, %0" : "=&r"(x) : "r"(y) : "cc")',        # 测试5: 读写操作数        'asm volatile("incl %0" : "+r"(counter))',    ]     for i, tc in enumerate(test_cases, 1):        print(f"\n{'='*60}")        print(f"测试用例 {i}:")        print(f"{tc}")        print(f"{'='*60}")        parser = InlineAsmParser(tc)        parser.parse()        print(parser.report())