Cpp.GnuAsmExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the gnu_asm_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.GnuAsmExpression represents the node gnu_asm_expression in the syntax tree of your code.

void foo(int input, int result) {
  asm("mov %0, %1" : "=r"(result) : "r"(input) : "memory");
  asm volatile("nop");
  asm goto("jmp %l0" : : : : mylabel);
mylabel:
  return;
}

The example contains three GNU inline-assembly expressions and each asm(...) occurrence corresponds to a gnu_asm_expression node matched by Cpp.GnuAsmExpression.

Predicates

expand all

Type

Type	Raisable	Printable
`GnuAsmExpression`	Yes	No

Syntaxes

This class defines these predicates that act on the objects of this class. In addition, objects of this class can access the predicates defined by the base class AstNodeProperties. An object of this class is an object of AstNodeProperties class.

Predicates	Description	Example
`is(required GnuAsmExpression &gae)`	Matches a `gnu_asm_expression` and binds it to `gae` for further queries on that assembly expression.	This PQL defect checks for any GNU inline-assembly expressions in the source. defect has_asm = when Cpp.GnuAsmExpression.is(&gae) and gae.nodeText(&txt) raise "Found asm: \"{txt}\"" on gae In this C++ code, the defect finds each `asm("...")` expression. void f() { asm("nop"); }
`cast(Cpp.Node.Node node, required GnuAsmExpression &cast)`	Checks whether a `Cpp.Node.Node` instance is a `gnu_asm_expression` and if so binds it to `cast` for GnuAsmExpression-specific predicates.	This PQL defect checks whether a generic node represents a GNU inline-assembly expression. defect node_to_asm = when Cpp.ExpressionStatement.is(&expr) and expr.getADescendant(&node) and Cpp.GnuAsmExpression.cast(node, &gae) and gae.nodeText(&txt) raise "Node cast to GnuAsmExpression: \"{txt}\"" on gae In this C++ code, the defect finds a gnu asm expression node within an expression statement. void g() { asm volatile("nop"); }
`isa(Cpp.Node.Node node)`	Returns true when the given `Cpp.Node.Node` is a `gnu_asm_expression` enabling boolean checks or negation.	This PQL defect checks for nodes that are specifically `gnu_asm_expression`. defect node_to_asm = when Cpp.ExpressionStatement.is(&expr) and expr.getADescendant(&node) and Cpp.GnuAsmExpression.isa(node) and node.nodeText(&txt) raise "Node cast to GnuAsmExpression: \"{txt}\"" on node In this C++ code, the defect finds asm nodes within expression statements. void h() { asm("mov %0, %1" : "=r"(0) : "r"(1)); }
`assemblyCode(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches the assembly template string portion of the `asm(...)` expression and binds that child node to `child`.	This PQL defect checks for the assembly template (the quoted instruction string) inside a `gnu_asm_expression`. defect check_assembly_code = when Cpp.GnuAsmExpression.is(&gae) and gae.assemblyCode(&ac) and ac.nodeText(&txt) raise "Assembly template: \"{txt}\"" on gae In this C++ code, the defect extracts the `"mov %0, %1"` template from the asm expression. void f2(int in, int &out) { asm("mov %0, %1" : "=r"(out) : "r"(in)); }
`clobbers(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches each clobber-list entry in the `asm` expression and binds that entry to `child`.	This PQL defect checks for clobber entries such as `"memory"` in a `gnu_asm_expression`. defect check_clobber = when Cpp.GnuAsmExpression.is(&gae) and gae.clobbers(&cl) and cl.nodeText(&txt) raise "Clobber: \"{txt}\"" on gae In this C++ code, the defect finds the `"memory"` clobber declared in the asm. void f3() { asm("mov %0, %1" : : : "memory"); }
`gotoLabels(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches label identifiers listed in an `asm goto(...)` expression and binds each label to `child`.	This PQL defect checks for goto labels referenced by an `asm goto` expression. defect check_goto_label = when Cpp.GnuAsmExpression.is(&gae) and gae.gotoLabels(&gl) and gl.nodeText(&txt) raise "Goto label: \"{txt}\"" on gae In this C++ code, the defect detects the `mylabel` target used by `asm goto`. void f4() { asm goto("jmp %l0" : : : : mylabel); mylabel: return; }
`inputOperands(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches each input operand (constraint plus expression) in the `asm(...)` input operand list and binds it to `child`.	This PQL defect checks for input operand expressions like `"r"(input)` inside an assembly expression. defect check_input_operand = when Cpp.GnuAsmExpression.is(&gae) and gae.inputOperands(&io) and io.nodeText(&txt) raise "Input operand: \"{txt}\"" on gae In this C++ code, the defect finds the `"r"(input)` operand passed to the asm template. void f5(int input) { int out; asm("mov %0, %1" : "=r"(out) : "r"(input)); }
`outputOperands(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches each output operand (constraint plus lvalue) in the `asm(...)` output list and binds it to `child`.	This PQL defect checks for output operands such as `=r(result)` in an assembly expression. defect check_output_operand = when Cpp.GnuAsmExpression.is(&gae) and gae.outputOperands(&oo) and oo.nodeText(&txt) raise "Output operand: \"{txt}\"" on gae In this C++ code, the defect captures the `=r(result)` output operand used to return a value from asm. void f6(int input, int &result) { asm("mov %0, %1" : "=r"(result) : "r"(input)); }
`gnuAsmQualifier(GnuAsmExpression self, Cpp.Node.Node &child)`	Matches qualifiers applied to the `asm` keyword such as `volatile` or `inline` and binds the qualifier token to `child`.	This PQL defect checks for qualifiers like `volatile` attached to an `asm` expression. defect check_qualifier = when Cpp.GnuAsmExpression.is(&gae) and gae.gnuAsmQualifier(&q) and q.nodeText(&txt) raise "Gnu asm qualifier: \"{txt}\"" on gae In this C++ code, the defect identifies the `volatile` qualifier on the asm expression. void f7() { asm volatile("nop"); }
`getEnclosingGnuAsmExpression(Cpp.Node.Node child, required GnuAsmExpression &parent)`	Finds the nearest ancestor `gnu_asm_expression` node that encloses the given `child` node and binds it to `parent`.	This PQL defect checks for the closest enclosing `gnu_asm_expression` around a string literal. defect enclosing_asm = when Cpp.StringLiteral.is(&SL) and SL.toNode(&inner) and Cpp.GnuAsmExpression.getEnclosingGnuAsmExpression(inner, &gae) and gae.nodeText(&txt) raise "Enclosing asm: \"{txt}\"" on gae In this C++ code, the defect locates the asm expression that contains the string literal `"mov %0, %1"`. void f8(int in, int &out) { asm("mov %0, %1" : "=r"(out) : "r"(in)); }
`isEnclosedInGnuAsmExpression(Cpp.Node.Node child)`	Returns true when the provided `child` node has any ancestor that is a `gnu_asm_expression`.	This PQL defect checks whether a atring literal node is located anywhere inside a `gnu_asm_expression`. defect inside_asm = when Cpp.StringLiteral.is(&SL) and SL.toNode(&tok) and Cpp.GnuAsmExpression.isEnclosedInGnuAsmExpression(tok) raise "String literal is inside an asm expression" on tok In this C++ code, the defect flags string literals inside the asm expression. void f9() { asm("nop"); }

Version History

Introduced in R2026a