Reorganize and commit all the modified TACLeBench code and run scripts

1 files changed, 1384 insertions, 0 deletions

diff --git a/all_pairs/source/ammunition/arithm.c b/all_pairs/source/ammunition/arithm.c
new file mode 100644
index 0000000..9480846
--- /dev/null
+++ b/all_pairs/source/ammunition/arithm.c
@@ -0,0 +1,1384 @@
+/*
+  FILE NAME:   arithm.c
+
+  TITLE:       Package for arbitrary precision integer arithmetic
+
+  DESCRIPTION: This abstract data implements arbitrary precision
+      integer and unsigned integer numbers by machine independent
+      way.  The implementation of the package functions are not
+      sufficiently efficient in order to use for run-time.  The
+      package functions are oriented to implement constant-folding in
+      compilers.  This package is necessary because host machine may
+      not support such arithmetic for target machine.  For example,
+      VAX does not support does not support more 32-bits integer
+      numbers arithmetic.  The numbers are represented by bytes in
+      big endian mode, negative integer numbers are represented in
+      complementary code.  All sizes are given in bytes and must be
+      positive.  Results of executions of all functions can coincide
+      with a operand(s).  All functions of addition, subtraction,
+      multiplication, division, evaluation of remainder, shift,
+      changing size and transformation of string into number fix
+      overflow.  The overflow is fixed when result can not be
+      represented by number of given size.
+
+*/
+
+#include "arithm.h"
+#include "ammunition_string.h"
+
+
+/* This variable can have only two values 0 or 1.  The value `1'
+   corresponds to overflow.  The variable value are modified by all
+   functions of addition, subtract, multiplication, division,
+   evaluation of remainder, shift, changing size and transformation of
+   string into number fix overflow. */
+
+int ammunition_overflow_bit;
+
+
+/* The following function adds unsigned integers.  The function
+   returns 1 if unsigned integer overflow is fixed, 0 otherwise.
+   Result can be placed in any operand. */
+
+int ammunition_add_unsigned_integer_without_overflow_reaction
+( int size, const void *op1, const void *op2, void *result )
+{
+  int digit_num;
+  int carry;
+  unsigned int sum;
+
+  _Pragma( "loopbound min 4 max 4" )
+  for ( digit_num = size - 1, carry = 0; digit_num >= 0; digit_num-- ) {
+    sum = ( ( ( unsigned char * ) op1 ) [digit_num]
+            + ( ( unsigned char * ) op2 ) [digit_num] + carry );
+    if ( sum > UCHAR_MAX ) {
+      sum -= UCHAR_MAX + 1;
+      carry = 1;
+    } else
+      carry = 0;
+    ( ( unsigned char * ) result ) [digit_num] = sum;
+  }
+  return carry != 0;
+}
+
+/* The following function adds unsigned integers.  The function
+   returns 1 if unsigned integer overflow (the first operand is less
+   than the second) is fixed, 0 otherwise.  Result can be placed in
+   any operand. */
+
+int ammunition_subtract_unsigned_integer_without_overflow_reaction
+( int size, const void *op1, const void *op2, void *result )
+{
+  int digit_num;
+  int carry;
+  int subtraction;
+
+  _Pragma( "loopbound min 4 max 4" )
+  for ( digit_num = size - 1, carry = 0; digit_num >= 0; digit_num-- ) {
+    subtraction = ( ( ( unsigned char * ) op1 ) [digit_num]
+                    - ( ( unsigned char * ) op2 ) [digit_num] - carry );
+    if ( subtraction < 0 ) {
+      subtraction += UCHAR_MAX + 1;
+      carry = 1;
+    } else
+      carry = 0;
+    ( ( unsigned char * ) result ) [digit_num] = subtraction;
+  }
+  return carry != 0;
+}
+
+/* The following function makes complementary code of number.  Result
+   can be placed in operand. */
+
+void ammunition_make_complementary_code
+( int size, const void *operand, void *result )
+{
+  int digit_num;
+  int carry;
+  int subtraction;
+
+  _Pragma( "loopbound min 2 max 6" )
+  for ( digit_num = size - 1, carry = 0; digit_num >= 0; digit_num-- ) {
+    subtraction = ( 0 - ( ( unsigned char * ) operand ) [digit_num] - carry );
+    if ( subtraction != 0 ) {
+      subtraction += UCHAR_MAX + 1;
+      carry = 1;
+    } else
+      carry = 0;
+    ( ( unsigned char * ) result ) [digit_num] = subtraction;
+  }
+}
+
+/* The following function multiplys unsigned integer by digit (byte
+   size).  The function returns 1 if unsigned integer overflow is
+   fixed, 0 otherwise. */
+
+int ammunition_multiply_unsigned_integer_by_digit_without_overflow_reaction
+( int size, void *operand, unsigned int digit )
+{
+  int digit_num;
+  unsigned int carry;
+  unsigned int sum;
+
+  _Pragma( "loopbound min 4 max 4" )
+  for ( digit_num = size - 1, carry = 0; digit_num >= 0; digit_num-- ) {
+    sum = ( ( ( unsigned char * ) operand ) [digit_num] * digit + carry );
+    if ( sum > UCHAR_MAX ) {
+      carry = sum / ( UCHAR_MAX + 1 );
+      sum %= UCHAR_MAX + 1;
+    } else
+      carry = 0;
+    ( ( unsigned char * ) operand ) [digit_num] = sum;
+  }
+  return carry != 0;
+}
+
+
+/* Originally reaction on all integer and unsigned integer overflow is
+   equal to the following function.  The function does nothing. */
+
+void
+ammunition_arithmetic_overflow_reaction ( void )
+{}
+
+
+/* Originally reaction on all integer and unsigned integer overflow is
+   equal to the following function.  The function does nothing. */
+
+void
+ammunition_arithmetic_unsigned_overflow_reaction ( void )
+{}
+
+
+/* This page contains functions for arbitrary precision addition. */
+
+/* The function adds unsigned integers and fixes overflow reaction if
+   it is needed.  The function makes this with the aid of function
+   `add_unsigned_integer_without_overflow_reaction'.  Result can be
+   placed in any operand. */
+
+void
+ammunition_add_unsigned_integer ( int size, const void *op1, const void *op2,
+                                  void *result )
+{
+  ammunition_overflow_bit
+    = ammunition_add_unsigned_integer_without_overflow_reaction (
+        size,  op1, op2, result );
+  if ( ammunition_overflow_bit != 0 )
+    ammunition_arithmetic_unsigned_overflow_reaction();
+}
+
+/* The function adds integers and fixes overflow reaction if it is
+   needed.  The function makes this with the aid of function
+   `add_unsigned_integer_without_overflow_reaction'.  Result can be
+   placed in any operand. */
+
+void
+ammunition_add_integer ( int size, const void *op1, const void *op2,
+                         void *result )
+{
+  int op1_sign;
+  int sign_equality;
+
+  op1_sign = INTEGER_SIGN ( op1 );
+  sign_equality = INTEGER_SIGN ( op1 ) == INTEGER_SIGN ( op2 );
+  ammunition_add_unsigned_integer_without_overflow_reaction (
+        size, op1, op2, result );
+  ammunition_overflow_bit = sign_equality &&
+                            ( op1_sign != INTEGER_SIGN ( result ) );
+  if ( ammunition_overflow_bit != 0 )
+    ammunition_arithmetic_overflow_reaction();
+}
+
+