asmatt

Author: radare

libr/arch/p/x86_nz/att2intel.c

@@ -3,7 +3,8 @@
 #include <r_asm.h>
 
 // x86-specific AT&T to Intel parser plugin
-// Uses the generic r_str_att2intel() from libr/util/str_att.c
+// Uses the x86-specific r_str_att2intel() from libr/util/str_att.c
+// This plugin is used as a pseudo-disassembler parser to convert AT&T output to Intel
 
 static char *parse(RAsmPluginSession *aps, const char *data) {
 	return r_str_att2intel (data);

libr/asm/asm.c

@@ -619,13 +619,26 @@ static int r_asm_assemble_single(RAsm *a, RAnalOp *op, const char *buf) {
 	if (!b) {
 		return 0;
 	}
-	// convert AT&T syntax to Intel if needed
-	const char *arch = R_UNWRAP3 (a, config, arch);
-	if (a->config->syntax == R_ARCH_SYNTAX_ATT && arch && r_str_startswith (arch, "x86")) {
-		char *intel = r_str_att2intel (b);
-		if (intel) {
-			free (b);
-			b = intel;
+	// convert AT&T syntax to Intel if needed, but only if the encoder doesn't support ATT natively
+	// The r_str_att2intel function is x86-specific, so only use it for x86 architectures
+	if (a->config->syntax == R_ARCH_SYNTAX_ATT) {
+		const char *arch = R_UNWRAP3 (a, config, arch);
+		// Get the encoder plugin to check its syntax support
+		RArchSession *as = R_UNWRAP4 (a, analb.anal, arch, session);
+		RArchPlugin *encoder_plugin = NULL;
+		if (as) {
+			// If encoder is separate, use that
+			encoder_plugin = as->encoder ? as->encoder->plugin : as->plugin;
+		}
+		// Check if encoder supports ATT syntax natively
+		bool encoder_supports_att = encoder_plugin && (encoder_plugin->encode_syntax & R_ARCH_SYNTAX_MASK_ATT);
+		// Only convert for x86 if encoder doesn't support ATT natively
+		if (!encoder_supports_att && arch && r_str_startswith (arch, "x86")) {
+			char *intel = r_str_att2intel (b);
+			if (intel) {
+				free (b);
+				b = intel;
+			}
 		}
 	}
 	r_str_case (b, false); // to-lower

libr/include/r_arch.h

@@ -151,6 +151,11 @@ typedef bool (*RArchPluginInitCallback)(RArchSession *s);
 typedef bool (*RArchPluginFiniCallback)(RArchSession *s);
 typedef bool (*RArchPluginEsilCallback)(RArchSession *s, RArchEsilAction action);
 
+// Bitmask for supported syntax modes in arch plugins
+#define R_ARCH_SYNTAX_MASK_INTEL (1 << R_ARCH_SYNTAX_INTEL)
+#define R_ARCH_SYNTAX_MASK_ATT   (1 << R_ARCH_SYNTAX_ATT)
+#define R_ARCH_SYNTAX_MASK_MASM  (1 << R_ARCH_SYNTAX_MASM)
+
 // TODO: use `const char *const` instead of `char*`
 typedef struct r_arch_plugin_t {
 	RPluginMeta meta;
@@ -161,6 +166,7 @@ typedef struct r_arch_plugin_t {
 	ut32 endian;
 	RSysBits bits;
 	RSysBits addr_bits;
+	ut32 encode_syntax; // bitmask of R_ARCH_SYNTAX_MASK_* for encoder-supported syntaxes (0 = Intel only, default)
 
 	const RArchPluginInitCallback init;
 	const RArchPluginFiniCallback fini;

libr/util/str_att.c

@@ -2,12 +2,18 @@
 
 #include <r_util.h>
 
-// Generic AT&T to Intel syntax conversion
-// This handles the common cases that work across architectures:
+// x86-specific AT&T to Intel syntax conversion
+// This handles x86 AT&T syntax conversion to Intel syntax for assemblers that
+// only support Intel syntax. The conversion includes:
 // - Remove % prefix from registers
 // - Remove $ prefix from immediates
 // - Swap operand order (AT&T: src, dst -> Intel: dst, src)
 // - Convert memory addressing ( ) to [ ]
+// - Strip AT&T size suffixes (l, q, b, w) from instructions
+//
+// Note: This is NOT generic across architectures. Most non-x86 architectures
+// use their own syntax and don't have AT&T/Intel distinction. The encoder
+// plugin's encode_syntax field should indicate if it supports ATT natively.
 
 // instructions that take 2 operands and need swap (src, dst -> dst, src)
 static const char *ops_2swap[] = {