BugFix:

[libfirm] / ir / tv / strcalc.c

diff --git a/ir/tv/strcalc.c b/ir/tv/strcalc.c
index d1ca023..dd2e6a3 100644 (file)
--- a/ir/tv/strcalc.c
+++ b/ir/tv/strcalc.c
@@ -32,6 +32,7 @@
 #include <limits.h>   /* definition of LONG_MIN, used in sc_get_val_from_long */
 
 #include "strcalc.h"
+#include "xmalloc.h"
 
 /*
  * local definitions and macros
@@ -76,6 +77,7 @@ static int carry_flag;              /**< some computation set the carry_flag:
                                          However, the meaning of carry is machine dependent
                                          and often defined in other ways! */
 
+static const char sex_digit[4] = { SC_E, SC_C, SC_8, SC_0 };
 static const char max_digit[4] = { SC_0, SC_1, SC_3, SC_7 };
 static const char min_digit[4] = { SC_F, SC_E, SC_C, SC_8 };
 
@@ -952,13 +954,34 @@ const void *sc_get_buffer(void)
   return (void*)calc_buffer;
 }
 
-const int sc_get_buffer_length(void)
+int sc_get_buffer_length(void)
 {
   return calc_buffer_size;
 }
 
+/**
+ * Do sign extension if the mode is signed, expects all upper bits
+ * cleared.
+ */
+void sign_extend(char *calc_buffer, ir_mode *mode) {
+  if (mode_is_signed(mode)) {
+    int bits    = get_mode_size_bits(mode) - 1;
+    int ofs     = bits >> 2;
+    int max     = max_digit[bits & 3];
+    int i;
+
+    if (calc_buffer[ofs] > max) {
+      /* sign bit is set, we need sign expansion */
+
+      for (i = ofs + 1; i < calc_buffer_size; ++i)
+        calc_buffer[i] = SC_F;
+      calc_buffer[ofs] = or_table[calc_buffer[ofs]][sex_digit[bits & 3]];
+    }
+  }
+}
+
 /* FIXME doesn't check for overflows */
-void sc_val_from_str(const char *str, unsigned int len, void *buffer)
+void sc_val_from_str(const char *str, unsigned int len, void *buffer, ir_mode *mode)
 {
   const char *orig_str = str;
   unsigned int orig_len = len;
@@ -977,8 +1000,8 @@ void sc_val_from_str(const char *str, unsigned int len, void *buffer)
   if (buffer == NULL) buffer = calc_buffer;
 
   CLEAR_BUFFER(buffer);
-  memset(base, SC_0, calc_buffer_size);
-  memset(val, SC_0, calc_buffer_size);
+  CLEAR_BUFFER(base);
+  CLEAR_BUFFER(val);
 
   /* strip leading spaces */
   while ((len > 0) && (*str == ' ')) { len--; str++; }
@@ -1101,9 +1124,10 @@ void sc_val_from_str(const char *str, unsigned int len, void *buffer)
   } /* while (len > 0 ) */
 
   if (sign)
-  {
     _negate(calc_buffer, calc_buffer);
-  }
+
+  /* beware: even if hex numbers have no sign, we need sign extension here */
+  sign_extend(calc_buffer, mode);
 }
 
 void sc_val_from_long(long value, void *buffer)
@@ -1117,7 +1141,7 @@ void sc_val_from_long(long value, void *buffer)
   sign = (value < 0);
   is_minlong = value == LONG_MIN;
 
-  /* use absolute value, special treatment of MIN_LONG */
+  /* use absolute value, special treatment of MIN_LONG to avoid overflow */
   if (sign) {
     if (is_minlong)
       value = -(value+1);
@@ -1133,7 +1157,6 @@ void sc_val_from_long(long value, void *buffer)
     value >>= 4;
   }
 
-
   if (sign) {
     if (is_minlong)
       _inc(buffer, buffer);
@@ -1144,14 +1167,14 @@ void sc_val_from_long(long value, void *buffer)
 
 void sc_val_from_ulong(unsigned long value, void *buffer)
 {
-  char *pos;
+  unsigned char *pos;
 
   if (buffer == NULL) buffer = calc_buffer;
   pos = buffer;
 
-  while (pos < (char*)buffer + calc_buffer_size)
+  while (pos < (unsigned char *)buffer + calc_buffer_size)
   {
-    *pos++ = _digit(value & 0xf);
+    *pos++ = (unsigned char)_digit(value & 0xf);
     value >>= 4;
   }
 }
@@ -1403,8 +1426,8 @@ int sc_had_carry(void)
 
 unsigned char sc_sub_bits(const void *value, int len, unsigned byte_ofs)
 {
-  const char *val     = (const char *)value;
-  unsigned nibble_ofs = 2 * byte_ofs;
+  const char *val = (const char *)value;
+  int nibble_ofs  = 2 * byte_ofs;
   unsigned char res;
 
   /* the current scheme uses one byte to store a nibble */
@@ -1578,13 +1601,8 @@ void init_strcalc(int precision)
     calc_buffer_size = (precision / 2);
     max_value_size   = (precision / 4);
 
-    calc_buffer   = malloc(calc_buffer_size+1 * sizeof(char));
-    output_buffer = malloc(bit_pattern_size+1 * sizeof(char));
-
-    if (calc_buffer == NULL || output_buffer == NULL) {
-      assert(0 && "malloc failed");
-      exit(-1);
-    }
+    calc_buffer   = xmalloc(calc_buffer_size+1 * sizeof(char));
+    output_buffer = xmalloc(bit_pattern_size+1 * sizeof(char));
 
     DEBUGPRINTF(("init strcalc: \n\tPRECISION: %d\n\tCALC_BUFFER_SIZE = %d\n\tMAX_VALUE_SIZE = %d\n\tbuffer pointer: %p\n", precision, calc_buffer_size, max_value_size, calc_buffer));
   }