Took care of signed immediate values as well as unsigned ones.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@42 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 403 insertions, 133 deletions

diff --git a/src/arch/operand.c b/src/arch/operand.c
index fa43416..6f7cdc4 100644
--- a/src/arch/operand.c
+++ b/src/arch/operand.c
@@ -48,9 +48,9 @@
 bool fill_db_operand(asm_operand *operand, uint8_t value)
 {
     operand->type = AOT_NONE;
-    operand->size = AOS_8_BITS;
+    operand->size = AOS_8_BITS_UNSIGNED;
 
-    operand->value.val8 = value;
+    operand->unsigned_imm.val8 = value;
 
     return true;
 
@@ -77,11 +77,11 @@ void print_db_operand(const asm_operand *operand, char *buffer, size_t len, AsmS
     switch (syntax)
     {
         case ASX_INTEL:
-            snprintf(buffer, len, "0x%02hhx", operand->value.val8);
+            snprintf(buffer, len, "0x%02hhx", operand->unsigned_imm.val8);
             break;
 
         case ASX_ATT:
-            snprintf(buffer, len, "$0x%02hhx", operand->value.val8);
+            snprintf(buffer, len, "$0x%02hhx", operand->unsigned_imm.val8);
             break;
 
     }
@@ -116,16 +116,20 @@ bool read_imm_value(AsmOperandSize size, const uint8_t *data, off_t *pos, off_t
     /* Vérifications sanitaires */
     switch (size)
     {
-        case AOS_8_BITS:
+        case AOS_8_BITS_UNSIGNED:
+        case AOS_8_BITS_SIGNED:
             if ((len - *pos) < 1) return false;
             break;
-        case AOS_16_BITS:
+        case AOS_16_BITS_UNSIGNED:
+        case AOS_16_BITS_SIGNED:
             if ((len - *pos) < 2) return false;
             break;
-        case AOS_32_BITS:
+        case AOS_32_BITS_UNSIGNED:
+        case AOS_32_BITS_SIGNED:
             if ((len - *pos) < 4) return false;
             break;
-        case AOS_64_BITS:
+        case AOS_64_BITS_UNSIGNED:
+        case AOS_64_BITS_SIGNED:
             if ((len - *pos) < 8) return false;
             break;
     }
@@ -134,23 +138,27 @@ bool read_imm_value(AsmOperandSize size, const uint8_t *data, off_t *pos, off_t
 
     switch (size)
     {
-        case AOS_8_BITS:
+        case AOS_8_BITS_UNSIGNED:
+        case AOS_8_BITS_SIGNED:
             val8 = va_arg(ap, uint8_t *);
             *val8 = data[*pos];
             *pos += 1;
             break;
-        case AOS_16_BITS:
+        case AOS_16_BITS_UNSIGNED:
+        case AOS_16_BITS_SIGNED:
             val16 = va_arg(ap, uint16_t *);
             *val16 = data[*pos] | (uint16_t)data[*pos + 1] << 8;
             *pos += 2;
             break;
-        case AOS_32_BITS:
+        case AOS_32_BITS_UNSIGNED:
+        case AOS_32_BITS_SIGNED:
             val32 = va_arg(ap, uint32_t *);
             *val32 = data[*pos] | (uint32_t)data[*pos + 1] << 8
                 | (uint32_t)data[*pos + 2] << 16 | (uint32_t)data[*pos + 3] << 24;
             *pos += 4;
             break;
-        case AOS_64_BITS:
+        case AOS_64_BITS_UNSIGNED:
+        case AOS_64_BITS_SIGNED:
             val64 = va_arg(ap, uint64_t *);
             *val64 = data[*pos] | (uint64_t)data[*pos + 1] << 8 | (uint64_t)data[*pos + 2] << 16
                 | (uint64_t)data[*pos + 3] << 24 | (uint64_t)data[*pos + 4] << 32 | (uint64_t)data[*pos + 5] << 40
@@ -169,65 +177,167 @@ bool read_imm_value(AsmOperandSize size, const uint8_t *data, off_t *pos, off_t
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : operand = structure dont le contenu est à définir.           *
+*                                                                             *
+*  Description : Indique le signe d'une valeur immédiate.                     *
+*                                                                             *
+*  Retour      : true si la valeur est strictement négative, false sinon.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool is_imm_operand_negative(const asm_operand *operand)
+{
+    bool result;                            /* Bilan à renvoyer            */
+
+    result = false;
+
+    switch (operand->size)
+    {
+        case AOS_8_BITS_SIGNED:
+            result = (operand->signed_imm.val8 & 0x80);
+            break;
+        case AOS_16_BITS_SIGNED:
+            result = (operand->signed_imm.val16 & 0x8000);
+            break;
+        case AOS_32_BITS_SIGNED:
+            result = (operand->signed_imm.val32 & 0x80000000);
+            break;
+        case AOS_64_BITS_SIGNED:
+            result = (operand->signed_imm.val64 & 0x8000000000000000ll);
+            break;
+        default:
+            /* Traitement non nécessaire */
+            break;
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = structure dont le contenu est à définir.           *
 *                size    = taille de l'opérande souhaitée.                    *
-*                data    = flux de données à analyser.                        *
-*                pos     = position courante dans ce flux. [OUT]              *
-*                len     = taille totale des données à analyser.              *
 *                                                                             *
-*  Description : Crée une opérande contenant une valeur sur x bits.           *
+*  Description : Précalcule une valeur humaine lisible d'une valeur signée.   *
 *                                                                             *
-*  Retour      : true si l'opération s'est effectuée avec succès, false sinon.*
+*  Retour      : -                                                            *
 *                                                                             *
 *  Remarques   : -                                                            *
 *                                                                             *
 ******************************************************************************/
 
-bool fill_imm_operand(asm_operand *operand, AsmOperandSize size, const uint8_t *data, off_t *pos, off_t len)
+void cache_signed_imm_value(asm_operand *operand, AsmOperandSize size)
 {
-    /* Vérifications sanitaires */
+    int8_t val8;                            /* Valeur sur 8 bits           */
+    int16_t val16;                          /* Valeur sur 16 bits          */
+    int32_t val32;                          /* Valeur sur 32 bits          */
+    int64_t val64;                          /* Valeur sur 64 bits          */
+
     switch (size)
     {
-        case AOS_8_BITS:
-            if ((len - *pos) < 1) return false;
+        case AOS_8_BITS_SIGNED:
+            if (operand->signed_imm.val8 & 0x80)
+            {
+                val8 = operand->signed_imm.val8 - 1;
+                val8 = ~val8;
+                operand->unsigned_imm.val8 = val8;
+            }
+            else operand->unsigned_imm.val8 = operand->signed_imm.val8;
             break;
-        case AOS_16_BITS:
-            if ((len - *pos) < 2) return false;
+        case AOS_16_BITS_SIGNED:
+            if (operand->signed_imm.val16 & 0x8000)
+            {
+                val16 = operand->signed_imm.val16 - 1;
+                val16 = ~val16;
+                operand->unsigned_imm.val16 = val16;
+            }
+            else operand->unsigned_imm.val16 = operand->signed_imm.val16;
             break;
-        case AOS_32_BITS:
-            if ((len - *pos) < 4) return false;
+        case AOS_32_BITS_SIGNED:
+            if (operand->signed_imm.val32 & 0x80000000)
+            {
+                val32 = operand->signed_imm.val32 - 1;
+                val32 = ~val32;
+                operand->unsigned_imm.val32 = val32;
+            }
+            else operand->unsigned_imm.val32 = operand->signed_imm.val32;
             break;
-        case AOS_64_BITS:
-            if ((len - *pos) < 8) return false;
+        case AOS_64_BITS_SIGNED:
+            if (operand->signed_imm.val64 & 0x8000000000000000ll)
+            {
+                val64 = operand->signed_imm.val64 - 1;
+                val64 = ~val64;
+                operand->unsigned_imm.val64 = val64;
+            }
+            else operand->unsigned_imm.val64 = operand->signed_imm.val64;
+            break;
+        default:
+            /* Traitement non nécessaire */
             break;
     }
 
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : operand = structure dont le contenu est à définir.           *
+*                size    = taille de l'opérande souhaitée.                    *
+*                data    = flux de données à analyser.                        *
+*                pos     = position courante dans ce flux. [OUT]              *
+*                len     = taille totale des données à analyser.              *
+*                                                                             *
+*  Description : Crée une opérande contenant une valeur sur x bits.           *
+*                                                                             *
+*  Retour      : true si l'opération s'est effectuée avec succès, false sinon.*
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool fill_imm_operand(asm_operand *operand, AsmOperandSize size, const uint8_t *data, off_t *pos, off_t len)
+{
+    bool result;                            /* Bilan à retourner           */
+
     operand->type = AOT_IMM;
     operand->size = size;
 
     switch (size)
     {
-        case AOS_8_BITS:
-            operand->value.val8 = data[*pos];
-            *pos += 1;
+        case AOS_8_BITS_UNSIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->unsigned_imm.val8);
             break;
-        case AOS_16_BITS:
-            operand->value.val16 = data[*pos] | (uint16_t)data[*pos + 1] << 8;
-            *pos += 2;
+        case AOS_16_BITS_UNSIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->unsigned_imm.val16);
             break;
-        case AOS_32_BITS:
-            operand->value.val32 = data[*pos] | (uint32_t)data[*pos + 1] << 8
-                | (uint32_t)data[*pos + 2] << 16 | (uint32_t)data[*pos + 3] << 24;
-            *pos += 4;
+        case AOS_32_BITS_UNSIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->unsigned_imm.val32);
             break;
-        case AOS_64_BITS:
-            operand->value.val64 = data[*pos] | (uint64_t)data[*pos + 1] << 8 | (uint64_t)data[*pos + 2] << 16
-                | (uint64_t)data[*pos + 3] << 24 | (uint64_t)data[*pos + 4] << 32 | (uint64_t)data[*pos + 5] << 40
-                | (uint64_t)data[*pos + 6] << 48 | (uint64_t)data[*pos + 7] << 56;
-            *pos += 8;
+        case AOS_64_BITS_UNSIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->unsigned_imm.val64);
+            break;
+        case AOS_8_BITS_SIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->signed_imm.val8);
+            cache_signed_imm_value(operand, size);
+            break;
+        case AOS_16_BITS_SIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->signed_imm.val16);
+            cache_signed_imm_value(operand, size);
+            break;
+        case AOS_32_BITS_SIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->signed_imm.val32);
+            cache_signed_imm_value(operand, size);
+            break;
+        case AOS_64_BITS_SIGNED:
+            result = read_imm_value(size, data, pos, len, &operand->signed_imm.val64);
+            cache_signed_imm_value(operand, size);
             break;
     }
 
-    return true;
+    return result;
 
 }
 
@@ -249,10 +359,14 @@ bool fill_imm_operand(asm_operand *operand, AsmOperandSize size, const uint8_t *
 bool fill_imm_operand_with_value(asm_operand *operand, AsmOperandSize size, ...)
 {
     va_list ap;                             /* Récupération d'argument     */
-    const uint8_t *val8;                    /* Valeur sur 8 bits           */
-    const uint16_t *val16;                  /* Valeur sur 16 bits          */
-    const uint32_t *val32;                  /* Valeur sur 32 bits          */
-    const uint64_t *val64;                  /* Valeur sur 64 bits          */
+    const uint8_t *us_val8;                 /* Valeur sur 8 bits n.-s.     */
+    const uint16_t *us_val16;               /* Valeur sur 16 bits n.-s.    */
+    const uint32_t *us_val32;               /* Valeur sur 32 bits n.-s.    */
+    const uint64_t *us_val64;               /* Valeur sur 64 bits n.-s.    */
+    const int8_t *s_val8;                   /* Valeur sur 8 bits signés    */
+    const int16_t *s_val16;                 /* Valeur sur 16 bits signés   */
+    const int32_t *s_val32;                 /* Valeur sur 32 bits signés   */
+    const int64_t *s_val64;                 /* Valeur sur 64 bits signés   */
 
     operand->type = AOT_IMM;
     operand->size = size;
@@ -261,21 +375,41 @@ bool fill_imm_operand_with_value(asm_operand *operand, AsmOperandSize size, ...)
 
     switch (size)
     {
-        case AOS_8_BITS:
-            val8 = va_arg(ap, const uint8_t *);
-            operand->value.val8 = *val8;
+        case AOS_8_BITS_UNSIGNED:
+            us_val8 = va_arg(ap, const uint8_t *);
+            operand->unsigned_imm.val8 = *us_val8;
+            break;
+        case AOS_16_BITS_UNSIGNED:
+            us_val16 = va_arg(ap, const uint16_t *);
+            operand->unsigned_imm.val16 = *us_val16;
+            break;
+        case AOS_32_BITS_UNSIGNED:
+            us_val32 = va_arg(ap, const uint32_t *);
+            operand->unsigned_imm.val32 = *us_val32;
+            break;
+        case AOS_64_BITS_UNSIGNED:
+            us_val64 = va_arg(ap, const uint64_t *);
+            operand->unsigned_imm.val64 = *us_val64;
+            break;
+        case AOS_8_BITS_SIGNED:
+            s_val8 = va_arg(ap, const uint8_t *);
+            operand->signed_imm.val8 = *s_val8;
+            cache_signed_imm_value(operand, size);
             break;
-        case AOS_16_BITS:
-            val16 = va_arg(ap, const uint16_t *);
-            operand->value.val16 = *val16;
+        case AOS_16_BITS_SIGNED:
+            s_val16 = va_arg(ap, const uint16_t *);
+            operand->signed_imm.val16 = *s_val16;
+            cache_signed_imm_value(operand, size);
             break;
-        case AOS_32_BITS:
-            val32 = va_arg(ap, const uint32_t *);
-            operand->value.val32 = *val32;
+        case AOS_32_BITS_SIGNED:
+            s_val32 = va_arg(ap, const uint32_t *);
+            operand->signed_imm.val32 = *s_val32;
+            cache_signed_imm_value(operand, size);
             break;
-        case AOS_64_BITS:
-            val64 = va_arg(ap, const uint64_t *);
-            operand->value.val64 = *val64;
+        case AOS_64_BITS_SIGNED:
+            s_val64 = va_arg(ap, const uint64_t *);
+            operand->signed_imm.val64 = *s_val64;
+            cache_signed_imm_value(operand, size);
             break;
     }
 
@@ -319,44 +453,44 @@ bool fill_relimm_operand(asm_operand *operand, AsmOperandSize size, const uint8_
         switch (size)
         {
             case AOS_8_BITS:
-                if (operand->value.val8 & 0x80)
+                if (operand->unsigned_imm.val8 & 0x80)
                 {
-                    val8 = operand->value.val8 - 1;
+                    val8 = operand->unsigned_imm.val8 - 1;
                     val8 = ~val8;
-                    operand->value.val8 = ref + (*pos - old_pos);
-                    operand->value.val8 -= val8;
+                    operand->unsigned_imm.val8 = ref + (*pos - old_pos);
+                    operand->unsigned_imm.val8 -= val8;
                 }
-                else operand->value.val8 += ref + (*pos - old_pos);
+                else operand->unsigned_imm.val8 += ref + (*pos - old_pos);
                 break;
             case AOS_16_BITS:
-                if (operand->value.val16 & 0x8000)
+                if (operand->unsigned_imm.val16 & 0x8000)
                 {
-                    val16 = operand->value.val16 - 1;
+                    val16 = operand->unsigned_imm.val16 - 1;
                     val16 = ~val16;
-                    operand->value.val16 = ref + (*pos - old_pos);
-                    operand->value.val16 -= val16;
+                    operand->unsigned_imm.val16 = ref + (*pos - old_pos);
+                    operand->unsigned_imm.val16 -= val16;
                 }
-                else operand->value.val16 += ref + (*pos - old_pos);
+                else operand->unsigned_imm.val16 += ref + (*pos - old_pos);
                 break;
             case AOS_32_BITS:
-                if (operand->value.val32 & 0x80000000)
+                if (operand->unsigned_imm.val32 & 0x80000000)
                 {
-                    val32 = operand->value.val32 - 1;
+                    val32 = operand->unsigned_imm.val32 - 1;
                     val32 = ~val32;
-                    operand->value.val32 = ref + (*pos - old_pos);
-                    operand->value.val32 -= val32;
+                    operand->unsigned_imm.val32 = ref + (*pos - old_pos);
+                    operand->unsigned_imm.val32 -= val32;
                 }
-                else operand->value.val32 += ref + (*pos - old_pos);
+                else operand->unsigned_imm.val32 += ref + (*pos - old_pos);
                 break;
             case AOS_64_BITS:
-                if (operand->value.val64 & 0x8000000000000000ull)
+                if (operand->unsigned_imm.val64 & 0x8000000000000000ull)
                 {
-                    val64 = operand->value.val64 - 1;
+                    val64 = operand->unsigned_imm.val64 - 1;
                     val64 = ~val64;
-                    operand->value.val64 = ref + (*pos - old_pos);
-                    operand->value.val64 -= val64;
+                    operand->unsigned_imm.val64 = ref + (*pos - old_pos);
+                    operand->unsigned_imm.val64 -= val64;
                 }
-                else operand->value.val64 += ref + (*pos - old_pos);
+                else operand->unsigned_imm.val64 += ref + (*pos - old_pos);
                 break;
         }
 
@@ -383,10 +517,14 @@ bool get_imm_operand_value(asm_operand *operand, AsmOperandSize size, ...)
 {
     bool result;                            /* Bilan à retourner           */
     va_list ap;                             /* Récupération d'argument     */
-    uint8_t *val8;                          /* Valeur sur 8 bits           */
-    uint16_t *val16;                        /* Valeur sur 16 bits          */
-    uint32_t *val32;                        /* Valeur sur 32 bits          */
-    uint64_t *val64;                        /* Valeur sur 64 bits          */
+    uint8_t *us_val8;                       /* Valeur sur 8 bits n.-s.     */
+    uint16_t *us_val16;                     /* Valeur sur 16 bits n.-s.    */
+    uint32_t *us_val32;                     /* Valeur sur 32 bits n.-s.    */
+    uint64_t *us_val64;                     /* Valeur sur 64 bits n.-s.    */
+    int8_t *s_val8;                         /* Valeur sur 8 bits signés    */
+    int16_t *s_val16;                       /* Valeur sur 16 bits signés   */
+    int32_t *s_val32;                       /* Valeur sur 32 bits signés   */
+    int64_t *s_val64;                       /* Valeur sur 64 bits signés   */
 
     result = true;
 
@@ -394,78 +532,202 @@ bool get_imm_operand_value(asm_operand *operand, AsmOperandSize size, ...)
 
     switch (size)
     {
-        case AOS_8_BITS:
-            val8 = va_arg(ap, uint8_t *);
+        case AOS_8_BITS_UNSIGNED:
+            us_val8 = va_arg(ap, uint8_t *);
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    *val8 = operand->value.val8;
+                case AOS_8_BITS_UNSIGNED:
+                    *us_val8 = operand->unsigned_imm.val8;
                     break;
-                case AOS_16_BITS:
+                case AOS_8_BITS_SIGNED:
+                    *us_val8 = operand->signed_imm.val8;
+                    break;
+                default:
                     result = false;
                     break;
-                case AOS_32_BITS:
+            }
+            break;
+
+        case AOS_16_BITS_UNSIGNED:
+            us_val16 = va_arg(ap, uint16_t *);
+            switch (operand->size)
+            {
+                case AOS_8_BITS_UNSIGNED:
+                    *us_val16 = operand->unsigned_imm.val8;
+                    break;
+                case AOS_16_BITS_UNSIGNED:
+                    *us_val16 = operand->unsigned_imm.val16;
+                    break;
+                case AOS_8_BITS_SIGNED:
+                    *us_val16 = operand->signed_imm.val8;
+                    break;
+                case AOS_16_BITS_SIGNED:
+                    *us_val16 = operand->signed_imm.val16;
+                    break;
+                default:
                     result = false;
                     break;
-                case AOS_64_BITS:
+            }
+            break;
+
+        case AOS_32_BITS_UNSIGNED:
+            us_val32 = va_arg(ap, uint32_t *);
+            switch (operand->size)
+            {
+                case AOS_8_BITS_UNSIGNED:
+                    *us_val32 = operand->unsigned_imm.val8;
+                    break;
+                case AOS_16_BITS_UNSIGNED:
+                    *us_val32 = operand->unsigned_imm.val16;
+                    break;
+                case AOS_32_BITS_UNSIGNED:
+                    *us_val32 = operand->unsigned_imm.val32;
+                    break;
+                case AOS_8_BITS_SIGNED:
+                    *us_val32 = operand->signed_imm.val8;
+                    break;
+                case AOS_16_BITS_SIGNED:
+                    *us_val32 = operand->signed_imm.val16;
+                    break;
+                case AOS_32_BITS_SIGNED:
+                    *us_val32 = operand->signed_imm.val32;
+                    break;
+                default:
                     result = false;
                     break;
             }
             break;
 
-        case AOS_16_BITS:
-            val16 = va_arg(ap, uint16_t *);
+        case AOS_64_BITS_UNSIGNED:
+            us_val64 = va_arg(ap, uint64_t *);
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    *val16 = operand->value.val8;
+                case AOS_8_BITS_UNSIGNED:
+                    *us_val64 = operand->unsigned_imm.val8;
+                    break;
+                case AOS_16_BITS_UNSIGNED:
+                    *us_val64 = operand->unsigned_imm.val16;
+                    break;
+                case AOS_32_BITS_UNSIGNED:
+                    *us_val64 = operand->unsigned_imm.val32;
                     break;
-                case AOS_16_BITS:
-                    *val16 = operand->value.val16;
+                case AOS_64_BITS_UNSIGNED:
+                    *us_val64 = operand->unsigned_imm.val64;
                     break;
-                case AOS_32_BITS:
+                case AOS_8_BITS_SIGNED:
+                    *us_val64 = operand->signed_imm.val8;
+                    break;
+                case AOS_16_BITS_SIGNED:
+                    *us_val64 = operand->signed_imm.val16;
+                    break;
+                case AOS_32_BITS_SIGNED:
+                    *us_val64 = operand->signed_imm.val32;
+                    break;
+                case AOS_64_BITS_SIGNED:
+                    *us_val64 = operand->signed_imm.val64;
+                    break;
+                default:
                     result = false;
                     break;
-                case AOS_64_BITS:
+            }
+            break;
+
+        case AOS_8_BITS_SIGNED:
+            s_val8 = va_arg(ap, int8_t *);
+            switch (operand->size)
+            {
+                case AOS_8_BITS_UNSIGNED:
+                    *s_val8 = operand->unsigned_imm.val8;
+                    break;
+                case AOS_8_BITS_SIGNED:
+                    *s_val8 = operand->signed_imm.val8;
+                    break;
+                default:
                     result = false;
                     break;
             }
             break;
 
-        case AOS_32_BITS:
-            val32 = va_arg(ap, uint32_t *);
+        case AOS_16_BITS_SIGNED:
+            s_val16 = va_arg(ap, int16_t *);
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    *val32 = operand->value.val8;
+                case AOS_8_BITS_UNSIGNED:
+                    *s_val16 = operand->unsigned_imm.val8;
                     break;
-                case AOS_16_BITS:
-                    *val32 = operand->value.val16;
+                case AOS_16_BITS_UNSIGNED:
+                    *s_val16 = operand->unsigned_imm.val16;
                     break;
-                case AOS_32_BITS:
-                    *val32 = operand->value.val32;
+                case AOS_8_BITS_SIGNED:
+                    *s_val16 = operand->signed_imm.val8;
                     break;
-                case AOS_64_BITS:
+                case AOS_16_BITS_SIGNED:
+                    *s_val16 = operand->signed_imm.val16;
+                    break;
+                default:
                     result = false;
                     break;
             }
             break;
 
-        case AOS_64_BITS:
-            val64 = va_arg(ap, uint64_t *);
+        case AOS_32_BITS_SIGNED:
+            s_val32 = va_arg(ap, int32_t *);
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    *val64 = operand->value.val8;
+                case AOS_8_BITS_UNSIGNED:
+                    *s_val32 = operand->unsigned_imm.val8;
                     break;
-                case AOS_16_BITS:
-                    *val64 = operand->value.val16;
+                case AOS_16_BITS_UNSIGNED:
+                    *s_val32 = operand->unsigned_imm.val16;
                     break;
-                case AOS_32_BITS:
-                    *val64 = operand->value.val32;
+                case AOS_32_BITS_UNSIGNED:
+                    *s_val32 = operand->unsigned_imm.val32;
                     break;
-                case AOS_64_BITS:
-                    *val64 = operand->value.val64;
+                case AOS_8_BITS_SIGNED:
+                    *s_val32 = operand->signed_imm.val8;
+                    break;
+                case AOS_16_BITS_SIGNED:
+                    *s_val32 = operand->signed_imm.val16;
+                    break;
+                case AOS_32_BITS_SIGNED:
+                    *s_val32 = operand->signed_imm.val32;
+                    break;
+                default:
+                    result = false;
+                    break;
+            }
+            break;
+
+        case AOS_64_BITS_SIGNED:
+            s_val64 = va_arg(ap, int64_t *);
+            switch (operand->size)
+            {
+                case AOS_8_BITS_UNSIGNED:
+                    *s_val64 = operand->unsigned_imm.val8;
+                    break;
+                case AOS_16_BITS_UNSIGNED:
+                    *s_val64 = operand->unsigned_imm.val16;
+                    break;
+                case AOS_32_BITS_UNSIGNED:
+                    *s_val64 = operand->unsigned_imm.val32;
+                    break;
+                case AOS_64_BITS_UNSIGNED:
+                    *s_val64 = operand->unsigned_imm.val64;
+                    break;
+                case AOS_8_BITS_SIGNED:
+                    *s_val64 = operand->signed_imm.val8;
+                    break;
+                case AOS_16_BITS_SIGNED:
+                    *s_val64 = operand->signed_imm.val16;
+                    break;
+                case AOS_32_BITS_SIGNED:
+                    *s_val64 = operand->signed_imm.val32;
+                    break;
+                case AOS_64_BITS_SIGNED:
+                    *s_val64 = operand->signed_imm.val64;
+                    break;
+                default:
+                    result = false;
                     break;
             }
             break;
@@ -505,17 +767,21 @@ void print_imm_operand(const asm_operand *operand, char *buffer, size_t len, Asm
         case ASX_INTEL:
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    snprintf(buffer, len, "0x%hhx", operand->value.val8);
+                case AOS_8_BITS_UNSIGNED:
+                case AOS_8_BITS_SIGNED:
+                    snprintf(buffer, len, "0x%hhx", operand->unsigned_imm.val8);
                     break;
-                case AOS_16_BITS:
-                    snprintf(buffer, len, "0x%hx", operand->value.val16);
+                case AOS_16_BITS_UNSIGNED:
+                case AOS_16_BITS_SIGNED:
+                    snprintf(buffer, len, "0x%hx", operand->unsigned_imm.val16);
                     break;
-                case AOS_32_BITS:
-                    snprintf(buffer, len, "0x%x", operand->value.val32);
+                case AOS_32_BITS_UNSIGNED:
+                case AOS_32_BITS_SIGNED:
+                    snprintf(buffer, len, "0x%x", operand->unsigned_imm.val32);
                     break;
-                case AOS_64_BITS:
-                    snprintf(buffer, len, "0x%llx", operand->value.val64);
+                case AOS_64_BITS_UNSIGNED:
+                case AOS_64_BITS_SIGNED:
+                    snprintf(buffer, len, "0x%llx", operand->unsigned_imm.val64);
                     break;
             }
             break;
@@ -523,17 +789,21 @@ void print_imm_operand(const asm_operand *operand, char *buffer, size_t len, Asm
         case ASX_ATT:
             switch (operand->size)
             {
-                case AOS_8_BITS:
-                    snprintf(buffer, len, "$0x%hhx", operand->value.val8);
+                case AOS_8_BITS_UNSIGNED:
+                case AOS_8_BITS_SIGNED:
+                    snprintf(buffer, len, "$0x%hhx", operand->unsigned_imm.val8);
                     break;
-                case AOS_16_BITS:
-                    snprintf(buffer, len, "$0x%hx", operand->value.val16);
+                case AOS_16_BITS_UNSIGNED:
+                case AOS_16_BITS_SIGNED:
+                    snprintf(buffer, len, "$0x%hx", operand->unsigned_imm.val16);
                     break;
-                case AOS_32_BITS:
-                    snprintf(buffer, len, "$0x%x", operand->value.val32);
+                case AOS_32_BITS_UNSIGNED:
+                case AOS_32_BITS_SIGNED:
+                    snprintf(buffer, len, "$0x%x", operand->unsigned_imm.val32);
                     break;
-                case AOS_64_BITS:
-                    snprintf(buffer, len, "$0x%llx", operand->value.val64);
+                case AOS_64_BITS_UNSIGNED:
+                case AOS_64_BITS_SIGNED:
+                    snprintf(buffer, len, "$0x%llx", operand->unsigned_imm.val64);
                     break;
             }
             break;