Merge pull request #27 from robalb/develop

Fix Displacement renderig in Intel flavour diasssembly

Author: robalb

blink/blink/disarg.c

@@ -88,8 +88,7 @@ static const char *GetAddrReg(struct Dis *d, u64 rde, u8 x, u8 r) {
 
 static char *DisRegister(char *p, const char *s) {
   p = HighStart(p, g_high.reg);
-  if(!INTEL_SYNTAX)
-    *p++ = '$';
+  if (!INTEL_SYNTAX) *p++ = '$';
   p = stpcpy(p, s);
   p = HighEnd(p);
   return p;
@@ -140,8 +139,7 @@ static char *DisSym(struct Dis *d, char *p, i64 value, i64 addr) {
 }
 
 static char *DisSymLiteral(struct Dis *d, u64 rde, char *p, u64 addr, u64 ip) {
-  if(!INTEL_SYNTAX)
-    *p++ = '$';
+  if (!INTEL_SYNTAX) *p++ = '$';
   p = HighStart(p, g_high.literal);
   p = DisSym(d, p, addr, addr);
   p = HighEnd(p);
@@ -192,16 +190,7 @@ static char *DisDisp(struct Dis *d, u64 rde, char *p) {
     } else if (IsRealModrmAbsolute(rde)) {
       disp = Unrelative(rde, disp);
     }
-    if(INTEL_SYNTAX){
-      char* beforeDisSym = p;
-      *p++ = ' ';
-      p = DisSym(d, p, disp, disp);
-      if(beforeDisSym[1] != '-'){
-        *beforeDisSym = '+';
-      }
-    }else{
-      p = DisSym(d, p, disp, disp);
-    }
+    p = DisSym(d, p, disp, disp);
   }
   return p;
 }
@@ -264,7 +253,7 @@ static char *DisBis(struct Dis *d, u64 rde, char *p) {
     }
   }
   if (base || index) {
-    if(INTEL_SYNTAX){
+    if (INTEL_SYNTAX) {
       *p++ = '[';
       if (base) {
         p = DisRegister(p, base);
@@ -274,15 +263,23 @@ static char *DisBis(struct Dis *d, u64 rde, char *p) {
         p = DisRegister(p, index);
         if (scale) {
           p = stpcpy(p, scale);
-          if(scale[0]){
-            *(p-2) = '*';
+          if (scale[0]) {
+            *(p - 2) = '*';
           }
         }
       }
+
+      // TODO(al): remove this hack
+      char *beforeDisDisp = p;
       p = DisDisp(d, rde, p);
+      if (p > beforeDisDisp && *beforeDisDisp != '-') {
+        memmove(beforeDisDisp + 1, beforeDisDisp, p - beforeDisDisp);
+        *beforeDisDisp = '+';
+        p++;
+      }
+
       *p++ = ']';
-    }
-    else{
+    } else {
       *p++ = '(';
       if (base) {
         p = DisRegister(p, base);
@@ -296,15 +293,18 @@ static char *DisBis(struct Dis *d, u64 rde, char *p) {
       }
       *p++ = ')';
     }
+  } else {
+    if (INTEL_SYNTAX) {
+      p = DisDisp(d, rde, p);
+    }
   }
   *p = '\0';
   return p;
 }
 
-
 static char *DisM(struct Dis *d, u64 rde, char *p) {
   p = DisSego(d, rde, p);
-  if(!INTEL_SYNTAX){
+  if (!INTEL_SYNTAX) {
     p = DisDisp(d, rde, p);
   }
   p = DisBis(d, rde, p);
@@ -427,11 +427,11 @@ static char *DisRdx(struct Dis *d, u64 rde, char *p) {
 }
 
 static char *DisPort(struct Dis *d, u64 rde, char *p) {
-  if(INTEL_SYNTAX){
+  if (INTEL_SYNTAX) {
     *p++ = '[';
     p = DisRegister(p, kGreg[1][0][0][2]);
     *p++ = ']';
-  }else{
+  } else {
     *p++ = '(';
     p = DisRegister(p, kGreg[1][0][0][2]);
     *p++ = ')';
@@ -468,8 +468,7 @@ static char *DisRvds(struct Dis *d, u64 rde, char *p) {
 }
 
 static char *DisKpvds(struct Dis *d, u64 rde, char *p, u64 x) {
-  if(!INTEL_SYNTAX)
-    *p++ = '$';
+  if (!INTEL_SYNTAX) *p++ = '$';
   p = HighStart(p, g_high.literal);
   p = DisInt(p, x);
   p = HighEnd(p);
@@ -486,8 +485,7 @@ static char *DisPvds(struct Dis *d, u64 rde, char *p) {
 }
 
 static char *DisOne(struct Dis *d, u64 rde, char *p) {
-  if(!INTEL_SYNTAX)
-    *p++ = '$';
+  if (!INTEL_SYNTAX) *p++ = '$';
   p = HighStart(p, g_high.literal);
   p = stpcpy(p, "1");
   p = HighEnd(p);
@@ -521,11 +519,11 @@ static char *DisSw(struct Dis *d, u64 rde, char *p) {
 }
 
 static char *DisSpecialAddr(struct Dis *d, u64 rde, char *p, int r) {
-  if(INTEL_SYNTAX){
+  if (INTEL_SYNTAX) {
     *p++ = '[';
     p = DisRegister(p, GetAddrReg(d, rde, 0, r));
     *p++ = ']';
-  }else{
+  } else {
     *p++ = '(';
     p = DisRegister(p, GetAddrReg(d, rde, 0, r));
     *p++ = ')';
@@ -584,11 +582,11 @@ static char *DisQq(struct Dis *d, u64 rde, char *p) {
 static char *DisEst(struct Dis *d, u64 rde, char *p) {
   p = DisRegister(p, "st");
   if (ModrmRm(rde) != 0) {
-    if(INTEL_SYNTAX){
+    if (INTEL_SYNTAX) {
       *p++ = '[';
       *p++ = '0' + ModrmRm(rde);
       *p++ = ']';
-    }else{
+    } else {
       *p++ = '(';
       *p++ = '0' + ModrmRm(rde);
       *p++ = ')';

blink/blink/disinst.c

@@ -153,28 +153,28 @@ static char *DisName(struct Dis *d, char *bp, const char *name,
                               !StartsWith(name, "set"))) {
       if (Osz(rde)) {
         if (ambiguous || Mode(rde) != XED_MODE_REAL) {
-          if(INTEL_SYNTAX){
+          if (INTEL_SYNTAX) {
             p = stpcpy(p, " word");
-          }else{
+          } else {
             *p++ = 'w';
           }
         }
       } else if (Rexw(rde)) {
-          if(INTEL_SYNTAX){
-            p = stpcpy(p, " qword");
-          }else{
-            *p++ = 'q';
-          }
+        if (INTEL_SYNTAX) {
+          p = stpcpy(p, " qword");
+        } else {
+          *p++ = 'q';
+        }
       } else if (ambiguous && !notbyte && IsProbablyByteOp(d->xedd)) {
-        if(INTEL_SYNTAX){
+        if (INTEL_SYNTAX) {
           p = stpcpy(p, " byte");
-        }else{
+        } else {
           *p++ = 'b';
         }
       } else if (!notlong) {
-        if(INTEL_SYNTAX){
+        if (INTEL_SYNTAX) {
           p = stpcpy(p, " dword");
-        }else{
+        } else {
           *p++ = 'l';
         }
       }
@@ -190,7 +190,6 @@ static char *DisName(struct Dis *d, char *bp, const char *name,
   return p;
 }
 
-
 /**
  * Disassembles instruction based on string spec.
  * @see DisSpec()
@@ -218,16 +217,15 @@ char *DisInst(struct Dis *d, char *p, const char *spec) {
   p = HighStart(p, g_high.keyword);
   p = DisName(d, p, name, hasarg && !hasregister && hasmemory);
   p = HighEnd(p);
-  if(INTEL_SYNTAX){
+  if (INTEL_SYNTAX) {
     for (i = 0; i < n; ++i) {
       if (i && args[i][0]) {
         *p++ = ',';
         *p++ = ' ';
       }
       p = stpcpy(p, args[i]);
     }
-  }
-  else{
+  } else {
     for (i = 0; i < n; ++i) {
       if (i && args[n - i][0]) {
         *p++ = ',';

field_notes/field-notes.daily2025.md

@@ -0,0 +1,117 @@
+# 4 ott
+
+checking eflags values
+
+
+[ auxiliary sign overflow ]
+0x80001a92
+0b10000000000000000001101010010010
+                      | | |  |  |
+                      | 9 7  4  1
+                      | I S  A
+                      11
+                      O
+                       
+[ auxiliary ]
+0x10001212
+0b10000000000000001001000010010
+                  |  |    |  |
+                  |  9    4  1
+                  |  I    A   
+                  12
+
+0 	CF 	Carry Flag
+1 	1 	Reserved
+2 	PF 	Parity Flag
+3 	0 	Reserved
+4 	AF 	Auxiliary Carry Flag
+5 	0 	Reserved
+6 	ZF 	Zero Flag
+7 	SF 	Sign Flag
+8 	TF 	Trap Flag
+9 	IF 	Interrupt Enable Flag
+10 	DF 	Direction Flag
+11 	OF 	Overflow Flag
+12-13 	IOPL 	I/O Privilege Level
+14 	NT 	Nested Task
+15 	0 	Reserved
+16 	RF 	Resume Flag
+17 	VM 	Virtual-8086 Mode
+18 	AC 	Alignment Check / Access Control
+19 	VIF 	Virtual Interrupt Flag
+20 	VIP 	Virtual Interrupt Pending
+21 	ID 	ID Flag
+22-63 	0 	Reserved 
+
+
+# 5 ott
+
+fixing disass visualization bug
+
+disinst.c
+```
+NOT relevant
+static char *DisSpecialAddr(struct Dis *d, u64 rde, char *p, int r) {
+  if(INTEL_SYNTAX){
+    *p++ = '[';
+    p = DisRegister(p, GetAddrReg(d, rde, 0, r));
+    *p++ = ']';
+  }else{
+    *p++ = '(';
+    p = DisRegister(p, GetAddrReg(d, rde, 0, r));
+    *p++ = ')';
+  }
+  *p = '\0';
+  return p;
+}
+```
+
+# 8 ott
+
+disSymLiteral
+
+
+# 12 ott
+
+
+DisM (at&t operand source Memory)
+  displacement + `(...)`
+   |               /
+   |              /
+ DisDisp         /
+                DisBis (draws [...])
+                    \
+                     \
+                    DisDysp  --------> DisSym
+                    (draws +/-)
+
+
+
+https://sdasgup3.github.io/Intel_Vs_Att_format/
+Intel Syntax
+instr   foo,segreg:[base+index*scale+disp]
+AT&T Syntax
+instr   %segreg:disp(base,index,scale),foo
+
+
+There are a few different forms of indirect operands in x86:
+
+    [reg]
+    [reg + displacement]
+    [displacement]
+    [reg * constant + reg]
+    [reg * constant + reg + displacement]
+
+The "displacement" is just a constant that gets added to the rest of the address. In cases where there is no component of the address other than the constant, it is still called a "displacement". This is mainly for consistency with the other addressing forms.
+
+Another way to look at it is that all addresses are of the form
+
+[reg * constant + reg + displacement]
+
+With each of the components allowing a value of 0.
+
+The [displacement] form is just the encoding where all components other than the displacement are zero.
+
+As a compiler writer the last 2 forms are particularly interesting. They make it easy to encode things like pArray[index]->field + 1in a single instruction.
+
+