Clang error: empty symbolic operand name in inline assembly string (err_asm_empty_symbolic_operand_name)

Text	error: empty symbolic operand name in inline assembly string
Type	Error
Category	Inline Assembly Issue
Internal Id	err_asm_empty_symbolic_operand_name
Internal Message	empty symbolic operand name in inline assembly string
Regular Expression	(?:error|fatal error)\: empty symbolic operand name in inline assembly string
First Commit	2009-03-14 5a8987ca5113 Update tablegen diagnostic files to be in sync with the def files.

Description

The error is issued by the Clang compiler when it encounters an inline assembly statement that specifies an empty symbolic operand name. Inline assembly allows embedding assembler code within C/C++ programs for direct access to the processor and hardware control or to perform tasks that cannot be accomplished in C/C++ alone. One way to pass information between the C/C++ program and the assembler code is by using symbolic operands, which are placeholders in the assembly string that are replaced by actual values or addresses when the code is executed. Symbolic operands are named by enclosing a name within the square brackets, for example, %[operandName]. This mechanism enables the reuse of C/C++ variables in the assembly code, enhancing readability and maintainability. However, the name of the symbolic operand cannot be left empty, as it serves as an essential link between the assembly code and the high-level language constructs. The compiler expects a valid identifier for each symbolic operand, which is then used to match against the parameters provided to the __asm__ statement, allowing for the correct interpretation and translation of the inline assembly. When the symbolic operand name is missing, the compiler cannot perform this matching, leading to an unclear association between the inline assembly code and the surrounding C/C++ code. This results in the compiler issuing this error to alert the programmer of the incomplete inline assembly syntax and prevent potential runtime errors or undefined behavior that could stem from the ambiguous assembler instruction. To resolve this error, the programmer must ensure that all symbolic operands in inline assembly statements are properly named, following the syntactical rules prescribed by the compiler for inline assembly. This includes providing a valid identifier within the square brackets immediately after the percent sign, ensuring the inline assembly code can be correctly integrated and executed within the C/C++ program.

AI Generated

Example

In the following example, a function named f is defined, which illustrates improper use of inline assembly within a C++ program, leading to the discussed error. The function declares an integer variable v and initializes it to 1. Then, it attempts to use inline assembly to move the value of v into the EAX register of the processor, which is a typical operation when needing direct control over processor-specific features or when optimizing code for performance. The first inline assembly statement demonstrates correct usage, where v is passed as an input operand, and its value is moved into the EAX register. This statement adheres to the syntax rules for inline assembly in C/C++, correctly specifying the input operand. However, the issue arises in the second inline assembly statement, which attempts to move the value of the EAX register to a destination operand. Importantly, this statement includes an empty symbolic operand name within the square brackets. This syntax is incorrect as symbolic operands in inline assembly must be named, serving as placeholders for actual values or addresses when the assembly code is executed. The lack of an operand name leads to ambiguity, preventing the compiler from correctly associating the inline assembly code with the corresponding C/C++ constructs. Consequently, the compiler emits an error message, signaling the need for a valid identifier within the square brackets to resolve the syntax issue. The output included in the example demonstrates the compiler's response to this issue, specifically pointing out the line and character position where the empty symbolic operand name is detected. This guidance helps the programmer identify the source of the error for correction.

AI Generated

Flags	-xc -O2	[Try out in Compiler Explorer]
Source	int f() { int v = 1; __asm__ volatile("mov %0, %%eax" : : "r"(v) : "%eax"); // Inline assembly __asm__ volatile("mov %%eax, %[]" : : : ); // Empty symbolic operand return 0; }
Compiler Output	<source>:4:33: error: empty symbolic operand name in inline assembly string

Clang Internals (17.0.6)

Git Commit Message

Update tablegen diagnostic files to be in sync with the def files.

llvm-svn: 67004

Used in Clang Sources

This section lists all occurrences of the diagnostic within the Clang's codebase. For each occurrence, an auto-extracted snipped from the source code is listed including key elements like control structures, functions, or classes. It should illustrate the conditions under which the diagnostic is activated.

clang/lib/AST/Stmt.cpp (line 749)

/// AnalyzeAsmString - Analyze the asm string of the current asm, decomposing
/// it into pieces.  If the asm string is erroneous, emit errors and return
/// true, otherwise return false.
unsigned GCCAsmStmt::AnalyzeAsmString(SmallVectorImpl<AsmStringPiece> &Pieces, const ASTContext &C, unsigned &DiagOffs) const {
  // ...
  while (true) {
    // ...
    // Handle operands that have asmSymbolicName (e.g., %x[foo]).
    if (EscapedChar == '[') {
      // ...
      if (NameEnd == CurPtr)
        return diag::err_asm_empty_symbolic_operand_name;

Triggered in Clang Tests

This section lists all internal Clang test cases that trigger the diagnostic.

clang/test/Sema/asm.c

• clang/test/Sema/asm.c:81:10: error: empty symbolic operand name in inline assembly string