[llvm-commits] CVS: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/COPYRIGHT INSTALL LICENSE Makefile README add.c code.c config.h debug.c decode.c gsm.h gsm_create.c gsm_decode.c gsm_destroy.c gsm_encode.c gsm_explode.c gsm_implode.c gsm_option.c gsm_print.c large.au.run.gsm long_term.c lpc.c preprocess.c private.h proto.h rpe.c short_term.c table.c toast.c toast.h toast_alaw.c toast_audio.c toast_lin.c toast_ulaw.c unproto.h
Chris Lattner
sabre at nondot.org
Tue Jan 9 15:45:03 PST 2007
Changes in directory llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm:
COPYRIGHT added (r1.1)
INSTALL added (r1.1)
LICENSE added (r1.1)
Makefile added (r1.1)
README added (r1.1)
add.c added (r1.1)
code.c added (r1.1)
config.h added (r1.1)
debug.c added (r1.1)
decode.c added (r1.1)
gsm.h added (r1.1)
gsm_create.c added (r1.1)
gsm_decode.c added (r1.1)
gsm_destroy.c added (r1.1)
gsm_encode.c added (r1.1)
gsm_explode.c added (r1.1)
gsm_implode.c added (r1.1)
gsm_option.c added (r1.1)
gsm_print.c added (r1.1)
large.au.run.gsm added (r1.1)
long_term.c added (r1.1)
lpc.c added (r1.1)
preprocess.c added (r1.1)
private.h added (r1.1)
proto.h added (r1.1)
rpe.c added (r1.1)
short_term.c added (r1.1)
table.c added (r1.1)
toast.c added (r1.1)
toast.h added (r1.1)
toast_alaw.c added (r1.1)
toast_audio.c added (r1.1)
toast_lin.c added (r1.1)
toast_ulaw.c added (r1.1)
unproto.h added (r1.1)
---
Log message:
Readd mibench
---
Diffs of the changes: (+6199 -0)
COPYRIGHT | 16 +
INSTALL | 92 ++++++
LICENSE | 16 +
Makefile | 7
README | 37 ++
add.c | 235 ++++++++++++++++
code.c | 99 ++++++
config.h | 34 ++
debug.c | 76 +++++
decode.c | 63 ++++
gsm.h | 68 ++++
gsm_create.c | 55 +++
gsm_decode.c | 125 ++++++++
gsm_destroy.c | 26 +
gsm_encode.c | 207 ++++++++++++++
gsm_explode.c | 197 +++++++++++++
gsm_implode.c | 280 +++++++++++++++++++
gsm_option.c | 38 ++
gsm_print.c | 167 +++++++++++
large.au.run.gsm | 0
long_term.c | 603 ++++++++++++++++++++++++++++++++++++++++++
lpc.c | 341 +++++++++++++++++++++++
preprocess.c | 113 +++++++
private.h | 263 ++++++++++++++++++
proto.h | 65 ++++
rpe.c | 488 ++++++++++++++++++++++++++++++++++
short_term.c | 429 +++++++++++++++++++++++++++++
table.c | 63 ++++
toast.c | 787 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
toast.h | 105 +++++++
toast_alaw.c | 333 +++++++++++++++++++++++
toast_audio.c | 103 +++++++
toast_lin.c | 24 +
toast_ulaw.c | 621 +++++++++++++++++++++++++++++++++++++++++++
unproto.h | 23 +
35 files changed, 6199 insertions(+)
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/COPYRIGHT
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/COPYRIGHT:1.1
*** /dev/null Tue Jan 9 17:44:45 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/COPYRIGHT Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,16 ----
+ Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
+ Technische Universitaet Berlin
+
+ Any use of this software is permitted provided that this notice is not
+ removed and that neither the authors nor the Technische Universitaet Berlin
+ are deemed to have made any representations as to the suitability of this
+ software for any purpose nor are held responsible for any defects of
+ this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+
+ As a matter of courtesy, the authors request to be informed about uses
+ this software has found, about bugs in this software, and about any
+ improvements that may be of general interest.
+
+ Berlin, 28.11.1994
+ Jutta Degener
+ Carsten Bormann
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/INSTALL
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/INSTALL:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/INSTALL Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,92 ----
+
+ /*
+ * Copyright 1992, 1993, 1994, by Jutta Degener and Carsten Bormann,
+ * Technische Universitaet Berlin. See the accompanying file "COPYRIGHT"
+ * for details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ How to get started:
+
+ Edit the Makefile.
+
+ You should configure a few machine-dependencies and what
+ compiler you want to use.
+
+ The code works both with ANSI and K&R-C. Use
+ -DNeedFunctionPrototypes to compile with, or
+ -UNeedFunctionPrototypes to compile without, function
+ prototypes in the header files.
+
+ Make addtst
+
+ The "add" program that will be compiled and run checks whether
+ the basic math functions of the gsm library work with your
+ compiler. If it prints anything to stderr, complain (to us).
+
+ Edit inc/config.h.
+
+ Make
+
+ Local versions of the gsm library and the "compress"-like filters
+ toast, untoast and tcat will be generated.
+
+ If the compilation aborts because of a missing function,
+ declaration, or header file, see if there's something in
+ inc/config.h to work around it. If not, complain.
+
+ Try it
+
+ Grab an audio file from somewhere (raw u-law or Sun .au is fine,
+ linear 16-bit in host byte order will do), copy it, toast it,
+ untoast it, and listen to the result.
+
+ If it doesn't sound anything like the original, read the manual.
+ If it still doesn't sound anything like the original, complain.
+
+
+ Installation
+
+ You can install the gsm library interface, or the toast binaries,
+ or both.
+
+ Edit the Makefile
+
+ Fill in the directories where you want to install the
+ library, header files, manual pages, and binaries.
+
+ Turn off the installation of one half of the distribution
+ (i.e., gsm library or toast binaries) by not setting the
+ corresponding directory root Makefile macro.
+
+
+ make install
+
+ will install the programs "toast" with two links named
+ "tcat" and "untoast", and the gsm library "libgsm.a" with
+ a "gsm.h" header file, and their respective manual pages.
+
+
+ Optimizing
+
+ This code was developed on a machine without an integer
+ multiplication instruction, where we obtained the fastest result by
+ replacing some of the integer multiplications with floating point
+ multiplications.
+
+ Another possibility is the use of a lookup table; you can turn on
+ this feature by replacing -DUSE_FLOAT_MUL by -DUSE_TABLE_MUL.
+
+ If your machine does multiply integers fast, define neither.
+
+
+
+ Bug Reports
+
+ Please direct bug reports to jutta at cs.tu-berlin.de and
+ cabo at cs.tu-berlin.de .
+
+
+ Good luck,
+
+ Jutta Degener,
+ Carsten Bormann
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/LICENSE
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/LICENSE:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/LICENSE Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,16 ----
+ Copyright 1992, 1993, 1994 by Jutta Degener and Carsten Bormann,
+ Technische Universitaet Berlin
+
+ Any use of this software is permitted provided that this notice is not
+ removed and that neither the authors nor the Technische Universitaet Berlin
+ are deemed to have made any representations as to the suitability of this
+ software for any purpose nor are held responsible for any defects of
+ this software. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+
+ As a matter of courtesy, the authors request to be informed about uses
+ this software has found, about bugs in this software, and about any
+ improvements that may be of general interest.
+
+ Berlin, 28.11.1994
+ Jutta Degener
+ Carsten Bormann
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/Makefile
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/Makefile:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/Makefile Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,7 ----
+ LEVEL = ../../../..
+
+ PROG = telecomm-gsm
+ CPPFLAGS = -DSTUPID_COMPILER -DNeedFunctionPrototypes=1 -DSASR
+ LDFLAGS = -lm
+ RUN_OPTIONS = -fps -c large.au.run.gsm
+ include $(LEVEL)/MultiSource/Makefile.multisrc
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/README
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/README:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/README Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,37 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ GSM 06.10 13 kbit/s RPE/LTP speech compression available
+ --------------------------------------------------------
+
+ The Communications and Operating Systems Research Group (KBS) at the
+ Technische Universitaet Berlin is currently working on a set of
+ UNIX-based tools for computer-mediated telecooperation that will be
+ made freely available.
+
+ As part of this effort we are publishing an implementation of the
+ European GSM 06.10 provisional standard for full-rate speech
+ transcoding, prI-ETS 300 036, which uses RPE/LTP (residual pulse
+ excitation/long term prediction) coding at 13 kbit/s.
+
+ GSM 06.10 compresses frames of 160 13-bit samples (8 kHz sampling
+ rate, i.e. a frame rate of 50 Hz) into 260 bits; for compatibility
+ with typical UNIX applications, our implementation turns frames of 160
+ 16-bit linear samples into 33-byte frames (1650 Bytes/s).
+ The quality of the algorithm is good enough for reliable speaker
+ recognition; even music often survives transcoding in recognizable
+ form (given the bandwidth limitations of 8 kHz sampling rate).
+
+ The interfaces offered are a front end modelled after compress(1), and
+ a library API. Compression and decompression run faster than realtime
+ on most SPARCstations. The implementation has been verified against the
+ ETSI standard test patterns.
+
+ Jutta Degener (jutta at cs.tu-berlin.de)
+ Carsten Bormann (cabo at cs.tu-berlin.de)
+
+ Communications and Operating Systems Research Group, TU Berlin
+ Fax: +49.30.31425156, Phone: +49.30.31424315
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/add.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/add.c:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/add.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,235 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/add.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ /*
+ * See private.h for the more commonly used macro versions.
+ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ #define saturate(x) \
+ ((x) < MIN_WORD ? MIN_WORD : (x) > MAX_WORD ? MAX_WORD: (x))
+
+ word gsm_add P2((a,b), word a, word b)
+ {
+ longword sum = (longword)a + (longword)b;
+ return saturate(sum);
+ }
+
+ word gsm_sub P2((a,b), word a, word b)
+ {
+ longword diff = (longword)a - (longword)b;
+ return saturate(diff);
+ }
+
+ word gsm_mult P2((a,b), word a, word b)
+ {
+ if (a == MIN_WORD && b == MIN_WORD) return MAX_WORD;
+ else return SASR( (longword)a * (longword)b, 15 );
+ }
+
+ word gsm_mult_r P2((a,b), word a, word b)
+ {
+ if (b == MIN_WORD && a == MIN_WORD) return MAX_WORD;
+ else {
+ longword prod = (longword)a * (longword)b + 16384;
+ prod >>= 15;
+ return prod & 0xFFFF;
+ }
+ }
+
+ word gsm_abs P1((a), word a)
+ {
+ return a < 0 ? (a == MIN_WORD ? MAX_WORD : -a) : a;
+ }
+
+ longword gsm_L_mult P2((a,b),word a, word b)
+ {
+ assert( a != MIN_WORD || b != MIN_WORD );
+ return ((longword)a * (longword)b) << 1;
+ }
+
+ longword gsm_L_add P2((a,b), longword a, longword b)
+ {
+ if (a < 0) {
+ if (b >= 0) return a + b;
+ else {
+ ulongword A = (ulongword)-(a + 1) + (ulongword)-(b + 1);
+ return A >= MAX_LONGWORD ? MIN_LONGWORD :-(longword)A-2;
+ }
+ }
+ else if (b <= 0) return a + b;
+ else {
+ ulongword A = (ulongword)a + (ulongword)b;
+ return A > MAX_LONGWORD ? MAX_LONGWORD : A;
+ }
+ }
+
+ longword gsm_L_sub P2((a,b), longword a, longword b)
+ {
+ if (a >= 0) {
+ if (b >= 0) return a - b;
+ else {
+ /* a>=0, b<0 */
+
+ ulongword A = (ulongword)a + -(b + 1);
+ return A >= MAX_LONGWORD ? MAX_LONGWORD : (A + 1);
+ }
+ }
+ else if (b <= 0) return a - b;
+ else {
+ /* a<0, b>0 */
+
+ ulongword A = (ulongword)-(a + 1) + b;
+ return A >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)A - 1;
+ }
+ }
+
+ static unsigned char bitoff[ 256 ] = {
+ 8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+
+ word gsm_norm P1((a), longword a )
+ /*
+ * the number of left shifts needed to normalize the 32 bit
+ * variable L_var1 for positive values on the interval
+ *
+ * with minimum of
+ * minimum of 1073741824 (01000000000000000000000000000000) and
+ * maximum of 2147483647 (01111111111111111111111111111111)
+ *
+ *
+ * and for negative values on the interval with
+ * minimum of -2147483648 (-10000000000000000000000000000000) and
+ * maximum of -1073741824 ( -1000000000000000000000000000000).
+ *
+ * in order to normalize the result, the following
+ * operation must be done: L_norm_var1 = L_var1 << norm( L_var1 );
+ *
+ * (That's 'ffs', only from the left, not the right..)
+ */
+ {
+ assert(a != 0);
+
+ if (a < 0) {
+ if (a <= -1073741824) return 0;
+ a = ~a;
+ }
+
+ return a & 0xffff0000
+ ? ( a & 0xff000000
+ ? -1 + bitoff[ 0xFF & (a >> 24) ]
+ : 7 + bitoff[ 0xFF & (a >> 16) ] )
+ : ( a & 0xff00
+ ? 15 + bitoff[ 0xFF & (a >> 8) ]
+ : 23 + bitoff[ 0xFF & a ] );
+ }
+
+ longword gsm_L_asl P2((a,n), longword a, int n)
+ {
+ if (n >= 32) return 0;
+ if (n <= -32) return -(a < 0);
+ if (n < 0) return gsm_L_asr(a, -n);
+ return a << n;
+ }
+
+ word gsm_asl P2((a,n), word a, int n)
+ {
+ if (n >= 16) return 0;
+ if (n <= -16) return -(a < 0);
+ if (n < 0) return gsm_asr(a, -n);
+ return a << n;
+ }
+
+ longword gsm_L_asr P2((a,n), longword a, int n)
+ {
+ if (n >= 32) return -(a < 0);
+ if (n <= -32) return 0;
+ if (n < 0) return a << -n;
+
+ # ifdef SASR
+ return a >> n;
+ # else
+ if (a >= 0) return a >> n;
+ else return -(longword)( -(ulongword)a >> n );
+ # endif
+ }
+
+ word gsm_asr P2((a,n), word a, int n)
+ {
+ if (n >= 16) return -(a < 0);
+ if (n <= -16) return 0;
+ if (n < 0) return a << -n;
+
+ # ifdef SASR
+ return a >> n;
+ # else
+ if (a >= 0) return a >> n;
+ else return -(word)( -(uword)a >> n );
+ # endif
+ }
+
+ /*
+ * (From p. 46, end of section 4.2.5)
+ *
+ * NOTE: The following lines gives [sic] one correct implementation
+ * of the div(num, denum) arithmetic operation. Compute div
+ * which is the integer division of num by denum: with denum
+ * >= num > 0
+ */
+
+ word gsm_div P2((num,denum), word num, word denum)
+ {
+ longword L_num = num;
+ longword L_denum = denum;
+ word div = 0;
+ int k = 15;
+
+ /* The parameter num sometimes becomes zero.
+ * Although this is explicitly guarded against in 4.2.5,
+ * we assume that the result should then be zero as well.
+ */
+
+ /* assert(num != 0); */
+
+ assert(num >= 0 && denum >= num);
+ if (num == 0)
+ return 0;
+
+ while (k--) {
+ div <<= 1;
+ L_num <<= 1;
+
+ if (L_num >= L_denum) {
+ L_num -= L_denum;
+ div++;
+ }
+ }
+
+ return div;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/code.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/code.c:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/code.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,99 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/code.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "config.h"
+
+
+ #ifdef HAS_STDLIB_H
+ #include <stdlib.h>
+ #else
+ # include "proto.h"
+ extern char * memcpy P((char *, char *, int));
+ #endif
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * 4.2 FIXED POINT IMPLEMENTATION OF THE RPE-LTP CODER
+ */
+
+ void Gsm_Coder P8((S,s,LARc,Nc,bc,Mc,xmaxc,xMc),
+
+ struct gsm_state * S,
+
+ word * s, /* [0..159] samples IN */
+
+ /*
+ * The RPE-LTD coder works on a frame by frame basis. The length of
+ * the frame is equal to 160 samples. Some computations are done
+ * once per frame to produce at the output of the coder the
+ * LARc[1..8] parameters which are the coded LAR coefficients and
+ * also to realize the inverse filtering operation for the entire
+ * frame (160 samples of signal d[0..159]). These parts produce at
+ * the output of the coder:
+ */
+
+ word * LARc, /* [0..7] LAR coefficients OUT */
+
+ /*
+ * Procedure 4.2.11 to 4.2.18 are to be executed four times per
+ * frame. That means once for each sub-segment RPE-LTP analysis of
+ * 40 samples. These parts produce at the output of the coder:
+ */
+
+ word * Nc, /* [0..3] LTP lag OUT */
+ word * bc, /* [0..3] coded LTP gain OUT */
+ word * Mc, /* [0..3] RPE grid selection OUT */
+ word * xmaxc,/* [0..3] Coded maximum amplitude OUT */
+ word * xMc /* [13*4] normalized RPE samples OUT */
+ )
+ {
+ int k;
+ word * dp = S->dp0 + 120; /* [ -120...-1 ] */
+ word * dpp = dp; /* [ 0...39 ] */
+
+ static word e [50] = {0};
+
+ word so[160];
+
+ Gsm_Preprocess (S, s, so);
+ Gsm_LPC_Analysis (S, so, LARc);
+ Gsm_Short_Term_Analysis_Filter (S, LARc, so);
+
+ for (k = 0; k <= 3; k++, xMc += 13) {
+
+ Gsm_Long_Term_Predictor ( S,
+ so+k*40, /* d [0..39] IN */
+ dp, /* dp [-120..-1] IN */
+ e + 5, /* e [0..39] OUT */
+ dpp, /* dpp [0..39] OUT */
+ Nc++,
+ bc++);
+
+ Gsm_RPE_Encoding ( S,
+ e + 5, /* e ][0..39][ IN/OUT */
+ xmaxc++, Mc++, xMc );
+ /*
+ * Gsm_Update_of_reconstructed_short_time_residual_signal
+ * ( dpp, e + 5, dp );
+ */
+
+ { register int i;
+ register longword ltmp;
+ for (i = 0; i <= 39; i++)
+ dp[ i ] = GSM_ADD( e[5 + i], dpp[i] );
+ }
+ dp += 40;
+ dpp += 40;
+
+ }
+ (void)memcpy( (char *)S->dp0, (char *)(S->dp0 + 160),
+ 120 * sizeof(*S->dp0) );
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/config.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/config.h:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/config.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,34 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/config.h,v 1.1 2007/01/09 23:44:35 lattner Exp $*/
+
+ #ifndef CONFIG_H
+ #define CONFIG_H
+
+ /*efine SIGHANDLER_T int /* signal handlers are void */
+ /*efine HAS_SYSV_SIGNAL 1 /* sigs not blocked/reset? */
+
+ #define HAS_STDLIB_H 1 /* /usr/include/stdlib.h */
+ /*efine HAS_LIMITS_H 1 /* /usr/include/limits.h */
+ #define HAS_FCNTL_H 1 /* /usr/include/fcntl.h */
+ /*efine HAS_ERRNO_DECL 1 /* errno.h declares errno */
+
+ #define HAS_FSTAT 1 /* fstat syscall */
+ #define HAS_FCHMOD 1 /* fchmod syscall */
+ #define HAS_FCHOWN 1 /* fchown syscall */
+
+ #define HAS_STRING_H 1 /* /usr/include/string.h */
+ /*efine HAS_STRINGS_H 1 /* /usr/include/strings.h */
+
+ #define HAS_UNISTD_H 1 /* /usr/include/unistd.h */
+ #define HAS_UTIME 1 /* POSIX utime(path, times) */
+ /*efine HAS_UTIMES 1 /* use utimes() syscall instead */
+ #define HAS_UTIME_H 1 /* UTIME header file */
+ /*efine HAS_UTIMBUF 1 /* struct utimbuf */
+ /*efine HAS_UTIMEUSEC 1 /* microseconds in utimbuf? */
+
+ #endif /* CONFIG_H */
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/debug.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/debug.c:1.1
*** /dev/null Tue Jan 9 17:45:02 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/debug.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,76 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/debug.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+
+ #ifndef NDEBUG
+
+ /* If NDEBUG _is_ defined and no debugging should be performed,
+ * calls to functions in this module are #defined to nothing
+ * in private.h.
+ */
+
+ #include <stdio.h>
+ #include "proto.h"
+
+ void gsm_debug_words P4( (name, from, to, ptr),
+ char * name,
+ int from,
+ int to,
+ word * ptr)
+ {
+ int nprinted = 0;
+
+ fprintf( stderr, "%s [%d .. %d]: ", name, from, to );
+ while (from <= to) {
+ fprintf(stderr, "%d ", ptr[ from ] );
+ from++;
+ if (nprinted++ >= 7) {
+ nprinted = 0;
+ if (from < to) putc('\n', stderr);
+ }
+ }
+ putc('\n', stderr);
+ }
+
+ void gsm_debug_longwords P4( (name, from, to, ptr),
+ char * name,
+ int from,
+ int to,
+ longword * ptr)
+ {
+ int nprinted = 0;
+
+ fprintf( stderr, "%s [%d .. %d]: ", name, from, to );
+ while (from <= to) {
+
+ fprintf(stderr, "%d ", ptr[ from ] );
+ from++;
+ if (nprinted++ >= 7) {
+ nprinted = 0;
+ if (from < to) putc('\n', stderr);
+ }
+ }
+ putc('\n', stderr);
+ }
+
+ void gsm_debug_longword P2( (name, value),
+ char * name,
+ longword value )
+ {
+ fprintf(stderr, "%s: %d\n", name, (long)value );
+ }
+
+ void gsm_debug_word P2( (name, value),
+ char * name,
+ word value )
+ {
+ fprintf(stderr, "%s: %d\n", name, (long)value);
+ }
+
+ #endif
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/decode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/decode.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/decode.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,63 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/decode.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * 4.3 FIXED POINT IMPLEMENTATION OF THE RPE-LTP DECODER
+ */
+
+ static void Postprocessing P2((S,s),
+ struct gsm_state * S,
+ register word * s)
+ {
+ register int k;
+ register word msr = S->msr;
+ register longword ltmp; /* for GSM_ADD */
+ register word tmp;
+
+ for (k = 160; k--; s++) {
+ tmp = GSM_MULT_R( msr, 28180 );
+ msr = GSM_ADD(*s, tmp); /* Deemphasis */
+ *s = GSM_ADD(msr, msr) & 0xFFF8; /* Truncation & Upscaling */
+ }
+ S->msr = msr;
+ }
+
+ void Gsm_Decoder P8((S,LARcr, Ncr,bcr,Mcr,xmaxcr,xMcr,s),
+ struct gsm_state * S,
+
+ word * LARcr, /* [0..7] IN */
+
+ word * Ncr, /* [0..3] IN */
+ word * bcr, /* [0..3] IN */
+ word * Mcr, /* [0..3] IN */
+ word * xmaxcr, /* [0..3] IN */
+ word * xMcr, /* [0..13*4] IN */
+
+ word * s) /* [0..159] OUT */
+ {
+ int j, k;
+ word erp[40], wt[160];
+ word * drp = S->dp0 + 120;
+
+ for (j=0; j <= 3; j++, xmaxcr++, bcr++, Ncr++, Mcr++, xMcr += 13) {
+
+ Gsm_RPE_Decoding( S, *xmaxcr, *Mcr, xMcr, erp );
+ Gsm_Long_Term_Synthesis_Filtering( S, *Ncr, *bcr, erp, drp );
+
+ for (k = 0; k <= 39; k++) wt[ j * 40 + k ] = drp[ k ];
+ }
+
+ Gsm_Short_Term_Synthesis_Filter( S, LARcr, wt, s );
+ Postprocessing(S, s);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm.h:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,68 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm.h,v 1.1 2007/01/09 23:44:35 lattner Exp $*/
+
+ #ifndef GSM_H
+ #define GSM_H
+
+ #ifdef __cplusplus
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #if __STDC__
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #ifdef _NO_PROTO
+ # undef NeedFunctionPrototypes
+ #endif
+
+ #undef GSM_P /* gnu stdio.h actually defines this... */
+
+ #if NeedFunctionPrototypes
+ # define GSM_P( protos ) protos
+ #else
+ # define GSM_P( protos ) ( /* protos */ )
+ #endif
+
+ #ifdef NeedFunctionPrototypes
+ # include <stdio.h> /* for FILE * */
+ #endif
+
+ /*
+ * Interface
+ */
+
+ typedef struct gsm_state * gsm;
+ typedef short gsm_signal; /* signed 16 bit */
+ typedef unsigned char gsm_byte;
+ typedef gsm_byte gsm_frame[33]; /* 33 * 8 bits */
+
+ #define GSM_MAGIC 0xD /* 13 kbit/s RPE-LTP */
+
+ #define GSM_PATCHLEVEL 6
+ #define GSM_MINOR 0
+ #define GSM_MAJOR 1
+
+ #define GSM_OPT_VERBOSE 1
+ #define GSM_OPT_FAST 2
+
+ extern gsm gsm_create GSM_P((void));
+ extern void gsm_destroy GSM_P((gsm));
+
+ extern int gsm_print GSM_P((FILE *, gsm, gsm_byte *));
+ extern int gsm_option GSM_P((gsm, int, int *));
+
+ extern void gsm_encode GSM_P((gsm, gsm_signal *, gsm_byte *));
+ extern int gsm_decode GSM_P((gsm, gsm_byte *, gsm_signal *));
+
+ extern int gsm_explode GSM_P((gsm, gsm_byte *, gsm_signal *));
+ extern void gsm_implode GSM_P((gsm, gsm_signal *, gsm_byte *));
+
+ #undef GSM_P
+
+ #endif /* GSM_H */
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_create.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_create.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_create.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,55 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ static char ident[] = "$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_create.c,v 1.1 2007/01/09 23:44:35 lattner Exp $";
+
+ #include "config.h"
+
+ #ifdef HAS_STRING_H
+ #include <string.h>
+ #else
+ # include "proto.h"
+ extern char * memset P((char *, int, int));
+ #endif
+
+ #ifdef HAS_STDLIB_H
+ # include <stdlib.h>
+ #else
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern char * malloc();
+ # endif
+ #endif
+
+ #include <stdio.h>
+
+ #include "gsm.h"
+ #include "private.h"
+ #include "proto.h"
+
+ gsm gsm_create P0()
+ {
+ gsm r;
+
+ #ifdef USE_TABLE_MUL
+
+ static int mul_init = 0;
+ if (!mul_init) {
+ mul_init = 1;
+ init_umul_table();
+ }
+
+ #endif
+
+ r = (gsm)malloc(sizeof(struct gsm_state));
+ if (!r) return r;
+
+ memset((char *)r, 0, sizeof(*r));
+ r->nrp = 40;
+
+ return r;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_decode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_decode.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_decode.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,125 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_decode.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_decode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+ Nc[0] = (*c >> 1) & 0x7F;
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+ Mc[0] = (*c >> 5) & 0x3;
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+ Nc[1] = (*c >> 1) & 0x7F;
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+ Mc[1] = (*c >> 5) & 0x3;
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+ Nc[2] = (*c >> 1) & 0x7F;
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+ Mc[2] = (*c >> 5) & 0x3;
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+ Nc[3] = (*c >> 1) & 0x7F;
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+ Mc[3] = (*c >> 5) & 0x3;
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ Gsm_Decoder(s, LARc, Nc, bc, Mc, xmaxc, xmc, target);
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_destroy.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_destroy.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_destroy.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,26 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_destroy.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "gsm.h"
+ #include "config.h"
+ #include "proto.h"
+
+ #ifdef HAS_STDLIB_H
+ # include <stdlib.h>
+ #else
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern void free();
+ # endif
+ #endif
+
+ void gsm_destroy P1((S), gsm S)
+ {
+ if (S) free((char *)S);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_encode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_encode.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_encode.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,207 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_encode.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ void gsm_encode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ Gsm_Coder(s, source, LARc, Nc, bc, Mc, xmaxc, xmc);
+
+
+ /* variable size
+
+ GSM_MAGIC 4
+
+ LARc[0] 6
+ LARc[1] 6
+ LARc[2] 5
+ LARc[3] 5
+ LARc[4] 4
+ LARc[5] 4
+ LARc[6] 3
+ LARc[7] 3
+
+ Nc[0] 7
+ bc[0] 2
+ Mc[0] 2
+ xmaxc[0] 6
+ xmc[0] 3
+ xmc[1] 3
+ xmc[2] 3
+ xmc[3] 3
+ xmc[4] 3
+ xmc[5] 3
+ xmc[6] 3
+ xmc[7] 3
+ xmc[8] 3
+ xmc[9] 3
+ xmc[10] 3
+ xmc[11] 3
+ xmc[12] 3
+
+ Nc[1] 7
+ bc[1] 2
+ Mc[1] 2
+ xmaxc[1] 6
+ xmc[13] 3
+ xmc[14] 3
+ xmc[15] 3
+ xmc[16] 3
+ xmc[17] 3
+ xmc[18] 3
+ xmc[19] 3
+ xmc[20] 3
+ xmc[21] 3
+ xmc[22] 3
+ xmc[23] 3
+ xmc[24] 3
+ xmc[25] 3
+
+ Nc[2] 7
+ bc[2] 2
+ Mc[2] 2
+ xmaxc[2] 6
+ xmc[26] 3
+ xmc[27] 3
+ xmc[28] 3
+ xmc[29] 3
+ xmc[30] 3
+ xmc[31] 3
+ xmc[32] 3
+ xmc[33] 3
+ xmc[34] 3
+ xmc[35] 3
+ xmc[36] 3
+ xmc[37] 3
+ xmc[38] 3
+
+ Nc[3] 7
+ bc[3] 2
+ Mc[3] 2
+ xmaxc[3] 6
+ xmc[39] 3
+ xmc[40] 3
+ xmc[41] 3
+ xmc[42] 3
+ xmc[43] 3
+ xmc[44] 3
+ xmc[45] 3
+ xmc[46] 3
+ xmc[47] 3
+ xmc[48] 3
+ xmc[49] 3
+ xmc[50] 3
+ xmc[51] 3
+ */
+
+
+ *c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */
+ | ((LARc[0] >> 2) & 0xF);
+ *c++ = ((LARc[0] & 0x3) << 6)
+ | (LARc[1] & 0x3F);
+ *c++ = ((LARc[2] & 0x1F) << 3)
+ | ((LARc[3] >> 2) & 0x7);
+ *c++ = ((LARc[3] & 0x3) << 6)
+ | ((LARc[4] & 0xF) << 2)
+ | ((LARc[5] >> 2) & 0x3);
+ *c++ = ((LARc[5] & 0x3) << 6)
+ | ((LARc[6] & 0x7) << 3)
+ | (LARc[7] & 0x7);
+ *c++ = ((Nc[0] & 0x7F) << 1)
+ | ((bc[0] >> 1) & 0x1);
+ *c++ = ((bc[0] & 0x1) << 7)
+ | ((Mc[0] & 0x3) << 5)
+ | ((xmaxc[0] >> 1) & 0x1F);
+ *c++ = ((xmaxc[0] & 0x1) << 7)
+ | ((xmc[0] & 0x7) << 4)
+ | ((xmc[1] & 0x7) << 1)
+ | ((xmc[2] >> 2) & 0x1);
+ *c++ = ((xmc[2] & 0x3) << 6)
+ | ((xmc[3] & 0x7) << 3)
+ | (xmc[4] & 0x7);
+ *c++ = ((xmc[5] & 0x7) << 5) /* 10 */
+ | ((xmc[6] & 0x7) << 2)
+ | ((xmc[7] >> 1) & 0x3);
+ *c++ = ((xmc[7] & 0x1) << 7)
+ | ((xmc[8] & 0x7) << 4)
+ | ((xmc[9] & 0x7) << 1)
+ | ((xmc[10] >> 2) & 0x1);
+ *c++ = ((xmc[10] & 0x3) << 6)
+ | ((xmc[11] & 0x7) << 3)
+ | (xmc[12] & 0x7);
+ *c++ = ((Nc[1] & 0x7F) << 1)
+ | ((bc[1] >> 1) & 0x1);
+ *c++ = ((bc[1] & 0x1) << 7)
+ | ((Mc[1] & 0x3) << 5)
+ | ((xmaxc[1] >> 1) & 0x1F);
+ *c++ = ((xmaxc[1] & 0x1) << 7)
+ | ((xmc[13] & 0x7) << 4)
+ | ((xmc[14] & 0x7) << 1)
+ | ((xmc[15] >> 2) & 0x1);
+ *c++ = ((xmc[15] & 0x3) << 6)
+ | ((xmc[16] & 0x7) << 3)
+ | (xmc[17] & 0x7);
+ *c++ = ((xmc[18] & 0x7) << 5)
+ | ((xmc[19] & 0x7) << 2)
+ | ((xmc[20] >> 1) & 0x3);
+ *c++ = ((xmc[20] & 0x1) << 7)
+ | ((xmc[21] & 0x7) << 4)
+ | ((xmc[22] & 0x7) << 1)
+ | ((xmc[23] >> 2) & 0x1);
+ *c++ = ((xmc[23] & 0x3) << 6)
+ | ((xmc[24] & 0x7) << 3)
+ | (xmc[25] & 0x7);
+ *c++ = ((Nc[2] & 0x7F) << 1) /* 20 */
+ | ((bc[2] >> 1) & 0x1);
+ *c++ = ((bc[2] & 0x1) << 7)
+ | ((Mc[2] & 0x3) << 5)
+ | ((xmaxc[2] >> 1) & 0x1F);
+ *c++ = ((xmaxc[2] & 0x1) << 7)
+ | ((xmc[26] & 0x7) << 4)
+ | ((xmc[27] & 0x7) << 1)
+ | ((xmc[28] >> 2) & 0x1);
+ *c++ = ((xmc[28] & 0x3) << 6)
+ | ((xmc[29] & 0x7) << 3)
+ | (xmc[30] & 0x7);
+ *c++ = ((xmc[31] & 0x7) << 5)
+ | ((xmc[32] & 0x7) << 2)
+ | ((xmc[33] >> 1) & 0x3);
+ *c++ = ((xmc[33] & 0x1) << 7)
+ | ((xmc[34] & 0x7) << 4)
+ | ((xmc[35] & 0x7) << 1)
+ | ((xmc[36] >> 2) & 0x1);
+ *c++ = ((xmc[36] & 0x3) << 6)
+ | ((xmc[37] & 0x7) << 3)
+ | (xmc[38] & 0x7);
+ *c++ = ((Nc[3] & 0x7F) << 1)
+ | ((bc[3] >> 1) & 0x1);
+ *c++ = ((bc[3] & 0x1) << 7)
+ | ((Mc[3] & 0x3) << 5)
+ | ((xmaxc[3] >> 1) & 0x1F);
+ *c++ = ((xmaxc[3] & 0x1) << 7)
+ | ((xmc[39] & 0x7) << 4)
+ | ((xmc[40] & 0x7) << 1)
+ | ((xmc[41] >> 2) & 0x1);
+ *c++ = ((xmc[41] & 0x3) << 6) /* 30 */
+ | ((xmc[42] & 0x7) << 3)
+ | (xmc[43] & 0x7);
+ *c++ = ((xmc[44] & 0x7) << 5)
+ | ((xmc[45] & 0x7) << 2)
+ | ((xmc[46] >> 1) & 0x3);
+ *c++ = ((xmc[46] & 0x1) << 7)
+ | ((xmc[47] & 0x7) << 4)
+ | ((xmc[48] & 0x7) << 1)
+ | ((xmc[49] >> 2) & 0x1);
+ *c++ = ((xmc[49] & 0x3) << 6)
+ | ((xmc[50] & 0x7) << 3)
+ | (xmc[51] & 0x7);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_explode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_explode.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_explode.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,197 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_explode.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_explode P3((s, c, target), gsm s, gsm_byte * c, gsm_signal * target)
+ {
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ #define LARc target
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+
+ #define Nc (target + 8)
+
+ Nc[0] = (*c >> 1) & 0x7F;
+
+ #define bc (target + 9)
+
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+
+ #define Mc (target + 10)
+
+ Mc[0] = (*c >> 5) & 0x3;
+
+ #define xmaxc (target + 11)
+
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+
+ #define xmc (target + 12)
+
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 25 - 1)
+
+ Nc[1] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 26 - 1)
+
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 27 - 1)
+
+ Mc[1] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 28 - 1)
+
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 29 - 13)
+
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 42 - 2)
+
+ Nc[2] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 43 - 2)
+
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 44 - 2)
+
+ Mc[2] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 45 - 2)
+
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 46 - 26)
+
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+
+ #undef Nc
+ #define Nc (target + 59 - 3)
+
+ Nc[3] = (*c >> 1) & 0x7F;
+
+ #undef bc
+ #define bc (target + 60 - 3)
+
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+
+ #undef Mc
+ #define Mc (target + 61 - 3)
+
+ Mc[3] = (*c >> 5) & 0x3;
+
+ #undef xmaxc
+ #define xmaxc (target + 62 - 3)
+
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+
+ #undef xmc
+ #define xmc (target + 63 - 39)
+
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_implode.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_implode.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_implode.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,280 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_implode.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ void gsm_implode P3((s, source, c), gsm s, gsm_signal * source, gsm_byte * c)
+ {
+ /* variable size index
+
+ GSM_MAGIC 4 -
+
+ LARc[0] 6 0
+ LARc[1] 6 1
+ LARc[2] 5 2
+ LARc[3] 5 3
+ LARc[4] 4 4
+ LARc[5] 4 5
+ LARc[6] 3 6
+ LARc[7] 3 7
+
+ Nc[0] 7 8
+ bc[0] 2 9
+ Mc[0] 2 10
+ xmaxc[0] 6 11
+ xmc[0] 3 12
+ xmc[1] 3 13
+ xmc[2] 3 14
+ xmc[3] 3 15
+ xmc[4] 3 16
+ xmc[5] 3 17
+ xmc[6] 3 18
+ xmc[7] 3 19
+ xmc[8] 3 20
+ xmc[9] 3 21
+ xmc[10] 3 22
+ xmc[11] 3 23
+ xmc[12] 3 24
+
+ Nc[1] 7 25
+ bc[1] 2 26
+ Mc[1] 2 27
+ xmaxc[1] 6 28
+ xmc[13] 3 29
+ xmc[14] 3 30
+ xmc[15] 3 31
+ xmc[16] 3 32
+ xmc[17] 3 33
+ xmc[18] 3 34
+ xmc[19] 3 35
+ xmc[20] 3 36
+ xmc[21] 3 37
+ xmc[22] 3 38
+ xmc[23] 3 39
+ xmc[24] 3 40
+ xmc[25] 3 41
+
+ Nc[2] 7 42
+ bc[2] 2 43
+ Mc[2] 2 44
+ xmaxc[2] 6 45
+ xmc[26] 3 46
+ xmc[27] 3 47
+ xmc[28] 3 48
+ xmc[29] 3 49
+ xmc[30] 3 50
+ xmc[31] 3 51
+ xmc[32] 3 52
+ xmc[33] 3 53
+ xmc[34] 3 54
+ xmc[35] 3 55
+ xmc[36] 3 56
+ xmc[37] 3 57
+ xmc[38] 3 58
+
+ Nc[3] 7 59
+ bc[3] 2 60
+ Mc[3] 2 61
+ xmaxc[3] 6 62
+ xmc[39] 3 63
+ xmc[40] 3 64
+ xmc[41] 3 65
+ xmc[42] 3 66
+ xmc[43] 3 67
+ xmc[44] 3 68
+ xmc[45] 3 69
+ xmc[46] 3 70
+ xmc[47] 3 71
+ xmc[48] 3 72
+ xmc[49] 3 73
+ xmc[50] 3 74
+ xmc[51] 3 75
+ */
+
+
+ #define LARc source
+
+ *c++ = ((GSM_MAGIC & 0xF) << 4) /* 1 */
+ | ((LARc[0] >> 2) & 0xF);
+ *c++ = ((LARc[0] & 0x3) << 6)
+ | (LARc[1] & 0x3F);
+ *c++ = ((LARc[2] & 0x1F) << 3)
+ | ((LARc[3] >> 2) & 0x7);
+ *c++ = ((LARc[3] & 0x3) << 6)
+ | ((LARc[4] & 0xF) << 2)
+ | ((LARc[5] >> 2) & 0x3);
+ *c++ = ((LARc[5] & 0x3) << 6)
+ | ((LARc[6] & 0x7) << 3)
+ | (LARc[7] & 0x7);
+
+ #define Nc (source + 8)
+
+ *c++ = ((Nc[0] & 0x7F) << 1)
+
+ #define bc (source + 9)
+
+ | ((bc[0] >> 1) & 0x1);
+ *c++ = ((bc[0] & 0x1) << 7)
+
+ #define Mc (source + 10)
+
+ | ((Mc[0] & 0x3) << 5)
+
+ #define xmaxc (source + 11)
+
+ | ((xmaxc[0] >> 1) & 0x1F);
+ *c++ = ((xmaxc[0] & 0x1) << 7)
+
+ #define xmc (source + 12)
+
+ | ((xmc[0] & 0x7) << 4)
+ | ((xmc[1] & 0x7) << 1)
+ | ((xmc[2] >> 2) & 0x1);
+ *c++ = ((xmc[2] & 0x3) << 6)
+ | ((xmc[3] & 0x7) << 3)
+ | (xmc[4] & 0x7);
+ *c++ = ((xmc[5] & 0x7) << 5) /* 10 */
+ | ((xmc[6] & 0x7) << 2)
+ | ((xmc[7] >> 1) & 0x3);
+ *c++ = ((xmc[7] & 0x1) << 7)
+ | ((xmc[8] & 0x7) << 4)
+ | ((xmc[9] & 0x7) << 1)
+ | ((xmc[10] >> 2) & 0x1);
+ *c++ = ((xmc[10] & 0x3) << 6)
+ | ((xmc[11] & 0x7) << 3)
+ | (xmc[12] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 25 - 1)
+
+ *c++ = ((Nc[1] & 0x7F) << 1)
+
+ #undef bc
+ #define bc (source + 26 - 1)
+
+ | ((bc[1] >> 1) & 0x1);
+ *c++ = ((bc[1] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 27 - 1)
+
+ | ((Mc[1] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 28 - 1)
+
+ | ((xmaxc[1] >> 1) & 0x1F);
+ *c++ = ((xmaxc[1] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 29 - 13)
+
+ | ((xmc[13] & 0x7) << 4)
+ | ((xmc[14] & 0x7) << 1)
+ | ((xmc[15] >> 2) & 0x1);
+ *c++ = ((xmc[15] & 0x3) << 6)
+ | ((xmc[16] & 0x7) << 3)
+ | (xmc[17] & 0x7);
+ *c++ = ((xmc[18] & 0x7) << 5)
+ | ((xmc[19] & 0x7) << 2)
+ | ((xmc[20] >> 1) & 0x3);
+ *c++ = ((xmc[20] & 0x1) << 7)
+ | ((xmc[21] & 0x7) << 4)
+ | ((xmc[22] & 0x7) << 1)
+ | ((xmc[23] >> 2) & 0x1);
+ *c++ = ((xmc[23] & 0x3) << 6)
+ | ((xmc[24] & 0x7) << 3)
+ | (xmc[25] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 42 - 2)
+
+ *c++ = ((Nc[2] & 0x7F) << 1) /* 20 */
+
+ #undef bc
+ #define bc (source + 43 - 2)
+
+ | ((bc[2] >> 1) & 0x1);
+ *c++ = ((bc[2] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 44 - 2)
+
+ | ((Mc[2] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 45 - 2)
+
+ | ((xmaxc[2] >> 1) & 0x1F);
+ *c++ = ((xmaxc[2] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 46 - 26)
+
+ | ((xmc[26] & 0x7) << 4)
+ | ((xmc[27] & 0x7) << 1)
+ | ((xmc[28] >> 2) & 0x1);
+ *c++ = ((xmc[28] & 0x3) << 6)
+ | ((xmc[29] & 0x7) << 3)
+ | (xmc[30] & 0x7);
+ *c++ = ((xmc[31] & 0x7) << 5)
+ | ((xmc[32] & 0x7) << 2)
+ | ((xmc[33] >> 1) & 0x3);
+ *c++ = ((xmc[33] & 0x1) << 7)
+ | ((xmc[34] & 0x7) << 4)
+ | ((xmc[35] & 0x7) << 1)
+ | ((xmc[36] >> 2) & 0x1);
+ *c++ = ((xmc[36] & 0x3) << 6)
+ | ((xmc[37] & 0x7) << 3)
+ | (xmc[38] & 0x7);
+
+ #undef Nc
+ #define Nc (source + 59 - 3)
+
+ *c++ = ((Nc[3] & 0x7F) << 1)
+
+ #undef bc
+ #define bc (source + 60 - 3)
+
+ | ((bc[3] >> 1) & 0x1);
+ *c++ = ((bc[3] & 0x1) << 7)
+
+ #undef Mc
+ #define Mc (source + 61 - 3)
+
+ | ((Mc[3] & 0x3) << 5)
+
+ #undef xmaxc
+ #define xmaxc (source + 62 - 3)
+
+ | ((xmaxc[3] >> 1) & 0x1F);
+ *c++ = ((xmaxc[3] & 0x1) << 7)
+
+ #undef xmc
+ #define xmc (source + 63 - 39)
+
+ | ((xmc[39] & 0x7) << 4)
+ | ((xmc[40] & 0x7) << 1)
+ | ((xmc[41] >> 2) & 0x1);
+ *c++ = ((xmc[41] & 0x3) << 6) /* 30 */
+ | ((xmc[42] & 0x7) << 3)
+ | (xmc[43] & 0x7);
+ *c++ = ((xmc[44] & 0x7) << 5)
+ | ((xmc[45] & 0x7) << 2)
+ | ((xmc[46] >> 1) & 0x3);
+ *c++ = ((xmc[46] & 0x1) << 7)
+ | ((xmc[47] & 0x7) << 4)
+ | ((xmc[48] & 0x7) << 1)
+ | ((xmc[49] >> 2) & 0x1);
+ *c++ = ((xmc[49] & 0x3) << 6)
+ | ((xmc[50] & 0x7) << 3)
+ | (xmc[51] & 0x7);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_option.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_option.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_option.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,38 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_option.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_option P3((r, opt, val), gsm r, int opt, int * val)
+ {
+ int result = -1;
+
+ switch (opt) {
+ case GSM_OPT_VERBOSE:
+ #ifndef NDEBUG
+ result = r->verbose;
+ if (val) r->verbose = *val;
+ #endif
+ break;
+
+ case GSM_OPT_FAST:
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ result = r->fast;
+ if (val) r->fast = !!*val;
+ #endif
+ break;
+
+ default:
+ break;
+ }
+ return result;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_print.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_print.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_print.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,167 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/gsm_print.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ int gsm_print P3((f, s, c), FILE * f, gsm s, gsm_byte * c)
+ {
+ word LARc[8], Nc[4], Mc[4], bc[4], xmaxc[4], xmc[13*4];
+
+ /* GSM_MAGIC = (*c >> 4) & 0xF; */
+
+ if (((*c >> 4) & 0x0F) != GSM_MAGIC) return -1;
+
+ LARc[0] = (*c++ & 0xF) << 2; /* 1 */
+ LARc[0] |= (*c >> 6) & 0x3;
+ LARc[1] = *c++ & 0x3F;
+ LARc[2] = (*c >> 3) & 0x1F;
+ LARc[3] = (*c++ & 0x7) << 2;
+ LARc[3] |= (*c >> 6) & 0x3;
+ LARc[4] = (*c >> 2) & 0xF;
+ LARc[5] = (*c++ & 0x3) << 2;
+ LARc[5] |= (*c >> 6) & 0x3;
+ LARc[6] = (*c >> 3) & 0x7;
+ LARc[7] = *c++ & 0x7;
+
+
+ Nc[0] = (*c >> 1) & 0x7F;
+ bc[0] = (*c++ & 0x1) << 1;
+ bc[0] |= (*c >> 7) & 0x1;
+ Mc[0] = (*c >> 5) & 0x3;
+ xmaxc[0] = (*c++ & 0x1F) << 1;
+ xmaxc[0] |= (*c >> 7) & 0x1;
+ xmc[0] = (*c >> 4) & 0x7;
+ xmc[1] = (*c >> 1) & 0x7;
+ xmc[2] = (*c++ & 0x1) << 2;
+ xmc[2] |= (*c >> 6) & 0x3;
+ xmc[3] = (*c >> 3) & 0x7;
+ xmc[4] = *c++ & 0x7;
+ xmc[5] = (*c >> 5) & 0x7;
+ xmc[6] = (*c >> 2) & 0x7;
+ xmc[7] = (*c++ & 0x3) << 1; /* 10 */
+ xmc[7] |= (*c >> 7) & 0x1;
+ xmc[8] = (*c >> 4) & 0x7;
+ xmc[9] = (*c >> 1) & 0x7;
+ xmc[10] = (*c++ & 0x1) << 2;
+ xmc[10] |= (*c >> 6) & 0x3;
+ xmc[11] = (*c >> 3) & 0x7;
+ xmc[12] = *c++ & 0x7;
+
+ Nc[1] = (*c >> 1) & 0x7F;
+ bc[1] = (*c++ & 0x1) << 1;
+ bc[1] |= (*c >> 7) & 0x1;
+ Mc[1] = (*c >> 5) & 0x3;
+ xmaxc[1] = (*c++ & 0x1F) << 1;
+ xmaxc[1] |= (*c >> 7) & 0x1;
+ xmc[13] = (*c >> 4) & 0x7;
+ xmc[14] = (*c >> 1) & 0x7;
+ xmc[15] = (*c++ & 0x1) << 2;
+ xmc[15] |= (*c >> 6) & 0x3;
+ xmc[16] = (*c >> 3) & 0x7;
+ xmc[17] = *c++ & 0x7;
+ xmc[18] = (*c >> 5) & 0x7;
+ xmc[19] = (*c >> 2) & 0x7;
+ xmc[20] = (*c++ & 0x3) << 1;
+ xmc[20] |= (*c >> 7) & 0x1;
+ xmc[21] = (*c >> 4) & 0x7;
+ xmc[22] = (*c >> 1) & 0x7;
+ xmc[23] = (*c++ & 0x1) << 2;
+ xmc[23] |= (*c >> 6) & 0x3;
+ xmc[24] = (*c >> 3) & 0x7;
+ xmc[25] = *c++ & 0x7;
+
+
+ Nc[2] = (*c >> 1) & 0x7F;
+ bc[2] = (*c++ & 0x1) << 1; /* 20 */
+ bc[2] |= (*c >> 7) & 0x1;
+ Mc[2] = (*c >> 5) & 0x3;
+ xmaxc[2] = (*c++ & 0x1F) << 1;
+ xmaxc[2] |= (*c >> 7) & 0x1;
+ xmc[26] = (*c >> 4) & 0x7;
+ xmc[27] = (*c >> 1) & 0x7;
+ xmc[28] = (*c++ & 0x1) << 2;
+ xmc[28] |= (*c >> 6) & 0x3;
+ xmc[29] = (*c >> 3) & 0x7;
+ xmc[30] = *c++ & 0x7;
+ xmc[31] = (*c >> 5) & 0x7;
+ xmc[32] = (*c >> 2) & 0x7;
+ xmc[33] = (*c++ & 0x3) << 1;
+ xmc[33] |= (*c >> 7) & 0x1;
+ xmc[34] = (*c >> 4) & 0x7;
+ xmc[35] = (*c >> 1) & 0x7;
+ xmc[36] = (*c++ & 0x1) << 2;
+ xmc[36] |= (*c >> 6) & 0x3;
+ xmc[37] = (*c >> 3) & 0x7;
+ xmc[38] = *c++ & 0x7;
+
+ Nc[3] = (*c >> 1) & 0x7F;
+ bc[3] = (*c++ & 0x1) << 1;
+ bc[3] |= (*c >> 7) & 0x1;
+ Mc[3] = (*c >> 5) & 0x3;
+ xmaxc[3] = (*c++ & 0x1F) << 1;
+ xmaxc[3] |= (*c >> 7) & 0x1;
+
+ xmc[39] = (*c >> 4) & 0x7;
+ xmc[40] = (*c >> 1) & 0x7;
+ xmc[41] = (*c++ & 0x1) << 2;
+ xmc[41] |= (*c >> 6) & 0x3;
+ xmc[42] = (*c >> 3) & 0x7;
+ xmc[43] = *c++ & 0x7; /* 30 */
+ xmc[44] = (*c >> 5) & 0x7;
+ xmc[45] = (*c >> 2) & 0x7;
+ xmc[46] = (*c++ & 0x3) << 1;
+ xmc[46] |= (*c >> 7) & 0x1;
+ xmc[47] = (*c >> 4) & 0x7;
+ xmc[48] = (*c >> 1) & 0x7;
+ xmc[49] = (*c++ & 0x1) << 2;
+ xmc[49] |= (*c >> 6) & 0x3;
+ xmc[50] = (*c >> 3) & 0x7;
+ xmc[51] = *c & 0x7; /* 33 */
+
+ fprintf(f,
+ "LARc:\t%2.2d %2.2d %2.2d %2.2d %2.2d %2.2d %2.2d %2.2d\n",
+ LARc[0],LARc[1],LARc[2],LARc[3],LARc[4],LARc[5],LARc[6],LARc[7]);
+
+ fprintf(f, "#1: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[0], bc[0], Mc[0], xmaxc[0]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[0],xmc[1],xmc[2],xmc[3],xmc[4],xmc[5],xmc[6],
+ xmc[7],xmc[8],xmc[9],xmc[10],xmc[11],xmc[12] );
+
+ fprintf(f, "#2: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[1], bc[1], Mc[1], xmaxc[1]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[13+0],xmc[13+1],xmc[13+2],xmc[13+3],xmc[13+4],xmc[13+5],
+ xmc[13+6], xmc[13+7],xmc[13+8],xmc[13+9],xmc[13+10],xmc[13+11],
+ xmc[13+12] );
+
+ fprintf(f, "#3: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[2], bc[2], Mc[2], xmaxc[2]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[26+0],xmc[26+1],xmc[26+2],xmc[26+3],xmc[26+4],xmc[26+5],
+ xmc[26+6], xmc[26+7],xmc[26+8],xmc[26+9],xmc[26+10],xmc[26+11],
+ xmc[26+12] );
+
+ fprintf(f, "#4: Nc %4.4d bc %d Mc %d xmaxc %d\n",
+ Nc[3], bc[3], Mc[3], xmaxc[3]);
+ fprintf(f,
+ "\t%.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d %.2d\n",
+ xmc[39+0],xmc[39+1],xmc[39+2],xmc[39+3],xmc[39+4],xmc[39+5],
+ xmc[39+6], xmc[39+7],xmc[39+8],xmc[39+9],xmc[39+10],xmc[39+11],
+ xmc[39+12] );
+
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/large.au.run.gsm
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/long_term.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/long_term.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/long_term.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,603 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/long_term.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+
+ #ifdef USE_TABLE_MUL
+
+ unsigned int umul_table[ 513 ][ 256 ];
+
+ init_umul_table()
+ {
+ int i, j;
+ int n;
+ unsigned int * p = &umul_table[0][0];
+
+ for (i = 0; i < 513; i++) {
+ n = 0;
+ for (j = 0; j < 256; j++) {
+ *p++ = n;
+ n += i;
+ }
+ }
+ }
+
+ # define umul(x9, x15) \
+ ((int)(umul_table[x9][x15 & 0x0FF] + (umul_table[x9][ x15 >> 8 ] << 8)))
+
+ # define table_mul(a, b) \
+ ( (a < 0) ? ((b < 0) ? umul(-a, -b) : -umul(-a, b)) \
+ : ((b < 0) ? -umul(a, -b) : umul(a, b)))
+
+ #endif /* USE_TABLE_MUL */
+
+
+
+ /*
+ * 4.2.11 .. 4.2.12 LONG TERM PREDICTOR (LTP) SECTION
+ */
+
+
+ /*
+ * This procedure computes the LTP gain (bc) and the LTP lag (Nc)
+ * for the long term analysis filter. This is done by calculating a
+ * maximum of the cross-correlation function between the current
+ * sub-segment short term residual signal d[0..39] (output of
+ * the short term analysis filter; for simplification the index
+ * of this array begins at 0 and ends at 39 for each sub-segment of the
+ * RPE-LTP analysis) and the previous reconstructed short term
+ * residual signal dp[ -120 .. -1 ]. A dynamic scaling must be
+ * performed to avoid overflow.
+ */
+
+ /* This procedure exists in four versions. First, the two integer
+ * versions with or without table-multiplication (as one function);
+ * then, the two floating point versions (as another function), with
+ * or without scaling.
+ */
+
+ #ifndef USE_FLOAT_MUL
+
+ static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+ word wt[40];
+
+ longword L_max, L_power;
+ word R, S, dmax, scal;
+ register word temp;
+
+ /* Search of the optimum scaling of d[0..39].
+ */
+ dmax = 0;
+
+ for (k = 0; k <= 39; k++) {
+ temp = d[k];
+ temp = GSM_ABS( temp );
+ if (temp > dmax) dmax = temp;
+ }
+
+ temp = 0;
+ if (dmax == 0) scal = 0;
+ else {
+ assert(dmax > 0);
+ temp = gsm_norm( (longword)dmax << 16 );
+ }
+
+ if (temp > 6) scal = 0;
+ else scal = 6 - temp;
+
+ assert(scal >= 0);
+
+ /* Initialization of a working array wt
+ */
+
+ for (k = 0; k <= 39; k++) wt[k] = SASR( d[k], scal );
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda++) {
+
+ # undef STEP
+ # ifdef USE_TABLE_MUL
+ # define STEP(k) (table_mul(wt[k], dp[k - lambda]))
+ # else
+ # define STEP(k) (wt[k] * dp[k - lambda])
+ # endif
+
+ register longword L_result;
+
+ L_result = STEP(0) ; L_result += STEP(1) ;
+ L_result += STEP(2) ; L_result += STEP(3) ;
+ L_result += STEP(4) ; L_result += STEP(5) ;
+ L_result += STEP(6) ; L_result += STEP(7) ;
+ L_result += STEP(8) ; L_result += STEP(9) ;
+ L_result += STEP(10) ; L_result += STEP(11) ;
+ L_result += STEP(12) ; L_result += STEP(13) ;
+ L_result += STEP(14) ; L_result += STEP(15) ;
+ L_result += STEP(16) ; L_result += STEP(17) ;
+ L_result += STEP(18) ; L_result += STEP(19) ;
+ L_result += STEP(20) ; L_result += STEP(21) ;
+ L_result += STEP(22) ; L_result += STEP(23) ;
+ L_result += STEP(24) ; L_result += STEP(25) ;
+ L_result += STEP(26) ; L_result += STEP(27) ;
+ L_result += STEP(28) ; L_result += STEP(29) ;
+ L_result += STEP(30) ; L_result += STEP(31) ;
+ L_result += STEP(32) ; L_result += STEP(33) ;
+ L_result += STEP(34) ; L_result += STEP(35) ;
+ L_result += STEP(36) ; L_result += STEP(37) ;
+ L_result += STEP(38) ; L_result += STEP(39) ;
+
+ if (L_result > L_max) {
+
+ Nc = lambda;
+ L_max = L_result;
+ }
+ }
+
+ *Nc_out = Nc;
+
+ L_max <<= 1;
+
+ /* Rescaling of L_max
+ */
+ assert(scal <= 100 && scal >= -100);
+ L_max = L_max >> (6 - scal); /* sub(6, scal) */
+
+ assert( Nc <= 120 && Nc >= 40);
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ L_power = 0;
+ for (k = 0; k <= 39; k++) {
+
+ register longword L_temp;
+
+ L_temp = SASR( dp[k - Nc], 3 );
+ L_power += L_temp * L_temp;
+ }
+ L_power <<= 1; /* from L_MULT */
+
+ /* Normalization of L_max and L_power
+ */
+
+ if (L_max <= 0) {
+ *bc_out = 0;
+ return;
+ }
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ temp = gsm_norm( L_power );
+
+ R = SASR( L_max << temp, 16 );
+ S = SASR( L_power << temp, 16 );
+
+ /* Coding of the LTP gain
+ */
+
+ /* Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;
+ *bc_out = bc;
+ }
+
+ #else /* USE_FLOAT_MUL */
+
+ static void Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+
+ float wt_float[40];
+ float dp_float_base[120], * dp_float = dp_float_base + 120;
+
+ longword L_max, L_power;
+ word R, S, dmax, scal;
+ register word temp;
+
+ /* Search of the optimum scaling of d[0..39].
+ */
+ dmax = 0;
+
+ for (k = 0; k <= 39; k++) {
+ temp = d[k];
+ temp = GSM_ABS( temp );
+ if (temp > dmax) dmax = temp;
+ }
+
+ temp = 0;
+ if (dmax == 0) scal = 0;
+ else {
+ assert(dmax > 0);
+ temp = gsm_norm( (longword)dmax << 16 );
+ }
+
+ if (temp > 6) scal = 0;
+ else scal = 6 - temp;
+
+ assert(scal >= 0);
+
+ /* Initialization of a working array wt
+ */
+
+ for (k = 0; k < 40; k++) wt_float[k] = SASR( d[k], scal );
+ for (k = -120; k < 0; k++) dp_float[k] = dp[k];
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda += 9) {
+
+ /* Calculate L_result for l = lambda .. lambda + 9.
+ */
+ register float *lp = dp_float - lambda;
+
+ register float W;
+ register float a = lp[-8], b = lp[-7], c = lp[-6],
+ d = lp[-5], e = lp[-4], f = lp[-3],
+ g = lp[-2], h = lp[-1];
+ register float E;
+ register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
+ S5 = 0, S6 = 0, S7 = 0, S8 = 0;
+
+ # undef STEP
+ # define STEP(K, a, b, c, d, e, f, g, h) \
+ W = wt_float[K]; \
+ E = W * a; S8 += E; \
+ E = W * b; S7 += E; \
+ E = W * c; S6 += E; \
+ E = W * d; S5 += E; \
+ E = W * e; S4 += E; \
+ E = W * f; S3 += E; \
+ E = W * g; S2 += E; \
+ E = W * h; S1 += E; \
+ a = lp[K]; \
+ E = W * a; S0 += E
+
+ # define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)
+ # define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)
+ # define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)
+ # define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)
+ # define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)
+ # define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)
+ # define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)
+ # define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)
+
+ STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);
+ STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);
+
+ STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);
+ STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);
+
+ STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);
+ STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);
+
+ STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);
+ STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);
+
+ STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);
+ STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);
+
+ if (S0 > L_max) { L_max = S0; Nc = lambda; }
+ if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }
+ if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }
+ if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }
+ if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }
+ if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }
+ if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }
+ if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }
+ if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }
+ }
+ *Nc_out = Nc;
+
+ L_max <<= 1;
+
+ /* Rescaling of L_max
+ */
+ assert(scal <= 100 && scal >= -100);
+ L_max = L_max >> (6 - scal); /* sub(6, scal) */
+
+ assert( Nc <= 120 && Nc >= 40);
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ L_power = 0;
+ for (k = 0; k <= 39; k++) {
+
+ register longword L_temp;
+
+ L_temp = SASR( dp[k - Nc], 3 );
+ L_power += L_temp * L_temp;
+ }
+ L_power <<= 1; /* from L_MULT */
+
+ /* Normalization of L_max and L_power
+ */
+
+ if (L_max <= 0) {
+ *bc_out = 0;
+ return;
+ }
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ temp = gsm_norm( L_power );
+
+ R = SASR( L_max << temp, 16 );
+ S = SASR( L_power << temp, 16 );
+
+ /* Coding of the LTP gain
+ */
+
+ /* Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ for (bc = 0; bc <= 2; bc++) if (R <= gsm_mult(S, gsm_DLB[bc])) break;
+ *bc_out = bc;
+ }
+
+ #ifdef FAST
+
+ static void Fast_Calculation_of_the_LTP_parameters P4((d,dp,bc_out,Nc_out),
+ register word * d, /* [0..39] IN */
+ register word * dp, /* [-120..-1] IN */
+ word * bc_out, /* OUT */
+ word * Nc_out /* OUT */
+ )
+ {
+ register int k, lambda;
+ word Nc, bc;
+
+ float wt_float[40];
+ float dp_float_base[120], * dp_float = dp_float_base + 120;
+
+ register float L_max, L_power;
+
+ for (k = 0; k < 40; ++k) wt_float[k] = (float)d[k];
+ for (k = -120; k <= 0; ++k) dp_float[k] = (float)dp[k];
+
+ /* Search for the maximum cross-correlation and coding of the LTP lag
+ */
+ L_max = 0;
+ Nc = 40; /* index for the maximum cross-correlation */
+
+ for (lambda = 40; lambda <= 120; lambda += 9) {
+
+ /* Calculate L_result for l = lambda .. lambda + 9.
+ */
+ register float *lp = dp_float - lambda;
+
+ register float W;
+ register float a = lp[-8], b = lp[-7], c = lp[-6],
+ d = lp[-5], e = lp[-4], f = lp[-3],
+ g = lp[-2], h = lp[-1];
+ register float E;
+ register float S0 = 0, S1 = 0, S2 = 0, S3 = 0, S4 = 0,
+ S5 = 0, S6 = 0, S7 = 0, S8 = 0;
+
+ # undef STEP
+ # define STEP(K, a, b, c, d, e, f, g, h) \
+ W = wt_float[K]; \
+ E = W * a; S8 += E; \
+ E = W * b; S7 += E; \
+ E = W * c; S6 += E; \
+ E = W * d; S5 += E; \
+ E = W * e; S4 += E; \
+ E = W * f; S3 += E; \
+ E = W * g; S2 += E; \
+ E = W * h; S1 += E; \
+ a = lp[K]; \
+ E = W * a; S0 += E
+
+ # define STEP_A(K) STEP(K, a, b, c, d, e, f, g, h)
+ # define STEP_B(K) STEP(K, b, c, d, e, f, g, h, a)
+ # define STEP_C(K) STEP(K, c, d, e, f, g, h, a, b)
+ # define STEP_D(K) STEP(K, d, e, f, g, h, a, b, c)
+ # define STEP_E(K) STEP(K, e, f, g, h, a, b, c, d)
+ # define STEP_F(K) STEP(K, f, g, h, a, b, c, d, e)
+ # define STEP_G(K) STEP(K, g, h, a, b, c, d, e, f)
+ # define STEP_H(K) STEP(K, h, a, b, c, d, e, f, g)
+
+ STEP_A( 0); STEP_B( 1); STEP_C( 2); STEP_D( 3);
+ STEP_E( 4); STEP_F( 5); STEP_G( 6); STEP_H( 7);
+
+ STEP_A( 8); STEP_B( 9); STEP_C(10); STEP_D(11);
+ STEP_E(12); STEP_F(13); STEP_G(14); STEP_H(15);
+
+ STEP_A(16); STEP_B(17); STEP_C(18); STEP_D(19);
+ STEP_E(20); STEP_F(21); STEP_G(22); STEP_H(23);
+
+ STEP_A(24); STEP_B(25); STEP_C(26); STEP_D(27);
+ STEP_E(28); STEP_F(29); STEP_G(30); STEP_H(31);
+
+ STEP_A(32); STEP_B(33); STEP_C(34); STEP_D(35);
+ STEP_E(36); STEP_F(37); STEP_G(38); STEP_H(39);
+
+ if (S0 > L_max) { L_max = S0; Nc = lambda; }
+ if (S1 > L_max) { L_max = S1; Nc = lambda + 1; }
+ if (S2 > L_max) { L_max = S2; Nc = lambda + 2; }
+ if (S3 > L_max) { L_max = S3; Nc = lambda + 3; }
+ if (S4 > L_max) { L_max = S4; Nc = lambda + 4; }
+ if (S5 > L_max) { L_max = S5; Nc = lambda + 5; }
+ if (S6 > L_max) { L_max = S6; Nc = lambda + 6; }
+ if (S7 > L_max) { L_max = S7; Nc = lambda + 7; }
+ if (S8 > L_max) { L_max = S8; Nc = lambda + 8; }
+ }
+ *Nc_out = Nc;
+
+ if (L_max <= 0.) {
+ *bc_out = 0;
+ return;
+ }
+
+ /* Compute the power of the reconstructed short term residual
+ * signal dp[..]
+ */
+ dp_float -= Nc;
+ L_power = 0;
+ for (k = 0; k < 40; ++k) {
+ register float f = dp_float[k];
+ L_power += f * f;
+ }
+
+ if (L_max >= L_power) {
+ *bc_out = 3;
+ return;
+ }
+
+ /* Coding of the LTP gain
+ * Table 4.3a must be used to obtain the level DLB[i] for the
+ * quantization of the LTP gain b to get the coded version bc.
+ */
+ lambda = L_max / L_power * 32768.;
+ for (bc = 0; bc <= 2; ++bc) if (lambda <= gsm_DLB[bc]) break;
+ *bc_out = bc;
+ }
+
+ #endif /* FAST */
+ #endif /* USE_FLOAT_MUL */
+
+
+ /* 4.2.12 */
+
+ static void Long_term_analysis_filtering P6((bc,Nc,dp,d,dpp,e),
+ word bc, /* IN */
+ word Nc, /* IN */
+ register word * dp, /* previous d [-120..-1] IN */
+ register word * d, /* d [0..39] IN */
+ register word * dpp, /* estimate [0..39] OUT */
+ register word * e /* long term res. signal [0..39] OUT */
+ )
+ /*
+ * In this part, we have to decode the bc parameter to compute
+ * the samples of the estimate dpp[0..39]. The decoding of bc needs the
+ * use of table 4.3b. The long term residual signal e[0..39]
+ * is then calculated to be fed to the RPE encoding section.
+ */
+ {
+ register int k;
+ register longword ltmp;
+
+ # undef STEP
+ # define STEP(BP) \
+ for (k = 0; k <= 39; k++) { \
+ dpp[k] = GSM_MULT_R( BP, dp[k - Nc]); \
+ e[k] = GSM_SUB( d[k], dpp[k] ); \
+ }
+
+ switch (bc) {
+ case 0: STEP( 3277 ); break;
+ case 1: STEP( 11469 ); break;
+ case 2: STEP( 21299 ); break;
+ case 3: STEP( 32767 ); break;
+ }
+ }
+
+ void Gsm_Long_Term_Predictor P7((S,d,dp,e,dpp,Nc,bc), /* 4x for 160 samples */
+
+ struct gsm_state * S,
+
+ word * d, /* [0..39] residual signal IN */
+ word * dp, /* [-120..-1] d' IN */
+
+ word * e, /* [0..39] OUT */
+ word * dpp, /* [0..39] OUT */
+ word * Nc, /* correlation lag OUT */
+ word * bc /* gain factor OUT */
+ )
+ {
+ assert( d ); assert( dp ); assert( e );
+ assert( dpp); assert( Nc ); assert( bc );
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ if (S->fast)
+ Fast_Calculation_of_the_LTP_parameters( d, dp, bc, Nc );
+ else
+ #endif
+ Calculation_of_the_LTP_parameters( d, dp, bc, Nc );
+
+ Long_term_analysis_filtering( *bc, *Nc, dp, d, dpp, e );
+ }
+
+ /* 4.3.2 */
+ void Gsm_Long_Term_Synthesis_Filtering P5((S,Ncr,bcr,erp,drp),
+ struct gsm_state * S,
+
+ word Ncr,
+ word bcr,
+ register word * erp, /* [0..39] IN */
+ register word * drp /* [-120..-1] IN, [0..40] OUT */
+ )
+ /*
+ * This procedure uses the bcr and Ncr parameter to realize the
+ * long term synthesis filtering. The decoding of bcr needs
+ * table 4.3b.
+ */
+ {
+ register longword ltmp; /* for ADD */
+ register int k;
+ word brp, drpp, Nr;
+
+ /* Check the limits of Nr.
+ */
+ Nr = Ncr < 40 || Ncr > 120 ? S->nrp : Ncr;
+ S->nrp = Nr;
+ assert(Nr >= 40 && Nr <= 120);
+
+ /* Decoding of the LTP gain bcr
+ */
+ brp = gsm_QLB[ bcr ];
+
+ /* Computation of the reconstructed short term residual
+ * signal drp[0..39]
+ */
+ assert(brp != MIN_WORD);
+
+ for (k = 0; k <= 39; k++) {
+ drpp = GSM_MULT_R( brp, drp[ k - Nr ] );
+ drp[k] = GSM_ADD( erp[k], drpp );
+ }
+
+ /*
+ * Update of the reconstructed short term residual signal
+ * drp[ -1..-120 ]
+ */
+
+ for (k = 0; k <= 119; k++) drp[ -120 + k ] = drp[ -80 + k ];
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/lpc.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/lpc.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/lpc.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,341 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/lpc.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ #undef P
+
+ /*
+ * 4.2.4 .. 4.2.7 LPC ANALYSIS SECTION
+ */
+
+ /* 4.2.4 */
+
+
+ static void Autocorrelation P2((s, L_ACF),
+ word * s, /* [0..159] IN/OUT */
+ longword * L_ACF) /* [0..8] OUT */
+ /*
+ * The goal is to compute the array L_ACF[k]. The signal s[i] must
+ * be scaled in order to avoid an overflow situation.
+ */
+ {
+ register int k, i;
+
+ word temp, smax, scalauto;
+
+ #ifdef USE_FLOAT_MUL
+ float float_s[160];
+ #endif
+
+ /* Dynamic scaling of the array s[0..159]
+ */
+
+ /* Search for the maximum.
+ */
+ smax = 0;
+ for (k = 0; k <= 159; k++) {
+ temp = GSM_ABS( s[k] );
+ if (temp > smax) smax = temp;
+ }
+
+ /* Computation of the scaling factor.
+ */
+ if (smax == 0) scalauto = 0;
+ else {
+ assert(smax > 0);
+ scalauto = 4 - gsm_norm( (longword)smax << 16 );/* sub(4,..) */
+ }
+
+ /* Scaling of the array s[0...159]
+ */
+
+ if (scalauto > 0) {
+
+ # ifdef USE_FLOAT_MUL
+ # define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ float_s[k] = (float) \
+ (s[k] = GSM_MULT_R(s[k], 16384 >> (n-1)));\
+ break;
+ # else
+ # define SCALE(n) \
+ case n: for (k = 0; k <= 159; k++) \
+ s[k] = GSM_MULT_R( s[k], 16384 >> (n-1) );\
+ break;
+ # endif /* USE_FLOAT_MUL */
+
+ switch (scalauto) {
+ SCALE(1)
+ SCALE(2)
+ SCALE(3)
+ SCALE(4)
+ }
+ # undef SCALE
+ }
+ # ifdef USE_FLOAT_MUL
+ else for (k = 0; k <= 159; k++) float_s[k] = (float) s[k];
+ # endif
+
+ /* Compute the L_ACF[..].
+ */
+ {
+ # ifdef USE_FLOAT_MUL
+ register float * sp = float_s;
+ register float sl = *sp;
+
+ # define STEP(k) L_ACF[k] += (longword)(sl * sp[ -(k) ]);
+ # else
+ word * sp = s;
+ word sl = *sp;
+
+ # define STEP(k) L_ACF[k] += ((longword)sl * sp[ -(k) ]);
+ # endif
+
+ # define NEXTI sl = *++sp
+
+
+ for (k = 9; k--; L_ACF[k] = 0) ;
+
+ STEP (0);
+ NEXTI;
+ STEP(0); STEP(1);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6);
+ NEXTI;
+ STEP(0); STEP(1); STEP(2); STEP(3); STEP(4); STEP(5); STEP(6); STEP(7);
+
+ for (i = 8; i <= 159; i++) {
+
+ NEXTI;
+
+ STEP(0);
+ STEP(1); STEP(2); STEP(3); STEP(4);
+ STEP(5); STEP(6); STEP(7); STEP(8);
+ }
+
+ for (k = 9; k--; L_ACF[k] <<= 1) ;
+
+ }
+ /* Rescaling of the array s[0..159]
+ */
+ if (scalauto > 0) {
+ assert(scalauto <= 4);
+ for (k = 160; k--; *s++ <<= scalauto) ;
+ }
+ }
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+
+ static void Fast_Autocorrelation P2((s, L_ACF),
+ word * s, /* [0..159] IN/OUT */
+ longword * L_ACF) /* [0..8] OUT */
+ {
+ register int k, i;
+ float f_L_ACF[9];
+ float scale;
+
+ float s_f[160];
+ register float *sf = s_f;
+
+ for (i = 0; i < 160; ++i) sf[i] = s[i];
+ for (k = 0; k <= 8; k++) {
+ register float L_temp2 = 0;
+ register float *sfl = sf - k;
+ for (i = k; i < 160; ++i) L_temp2 += sf[i] * sfl[i];
+ f_L_ACF[k] = L_temp2;
+ }
+ scale = MAX_LONGWORD / f_L_ACF[0];
+
+ for (k = 0; k <= 8; k++) {
+ L_ACF[k] = f_L_ACF[k] * scale;
+ }
+ }
+ #endif /* defined (USE_FLOAT_MUL) && defined (FAST) */
+
+ /* 4.2.5 */
+
+ static void Reflection_coefficients P2( (L_ACF, r),
+ longword * L_ACF, /* 0...8 IN */
+ register word * r /* 0...7 OUT */
+ )
+ {
+ register int i, m, n;
+ register word temp;
+ register longword ltmp;
+ word ACF[9]; /* 0..8 */
+ word P[ 9]; /* 0..8 */
+ word K[ 9]; /* 2..8 */
+
+ /* Schur recursion with 16 bits arithmetic.
+ */
+
+ if (L_ACF[0] == 0) {
+ for (i = 8; i--; *r++ = 0) ;
+ return;
+ }
+
+ assert( L_ACF[0] != 0 );
+ temp = gsm_norm( L_ACF[0] );
+
+ assert(temp >= 0 && temp < 32);
+
+ /* ? overflow ? */
+ for (i = 0; i <= 8; i++) ACF[i] = SASR( L_ACF[i] << temp, 16 );
+
+ /* Initialize array P[..] and K[..] for the recursion.
+ */
+
+ for (i = 1; i <= 7; i++) K[ i ] = ACF[ i ];
+ for (i = 0; i <= 8; i++) P[ i ] = ACF[ i ];
+
+ /* Compute reflection coefficients
+ */
+ for (n = 1; n <= 8; n++, r++) {
+
+ temp = P[1];
+ temp = GSM_ABS(temp);
+ if (P[0] < temp) {
+ for (i = n; i <= 8; i++) *r++ = 0;
+ return;
+ }
+
+ *r = gsm_div( temp, P[0] );
+
+ assert(*r >= 0);
+ if (P[1] > 0) *r = -*r; /* r[n] = sub(0, r[n]) */
+ assert (*r != MIN_WORD);
+ if (n == 8) return;
+
+ /* Schur recursion
+ */
+ temp = GSM_MULT_R( P[1], *r );
+ P[0] = GSM_ADD( P[0], temp );
+
+ for (m = 1; m <= 8 - n; m++) {
+ temp = GSM_MULT_R( K[ m ], *r );
+ P[m] = GSM_ADD( P[ m+1 ], temp );
+
+ temp = GSM_MULT_R( P[ m+1 ], *r );
+ K[m] = GSM_ADD( K[ m ], temp );
+ }
+ }
+ }
+
+ /* 4.2.6 */
+
+ static void Transformation_to_Log_Area_Ratios P1((r),
+ register word * r /* 0..7 IN/OUT */
+ )
+ /*
+ * The following scaling for r[..] and LAR[..] has been used:
+ *
+ * r[..] = integer( real_r[..]*32768. ); -1 <= real_r < 1.
+ * LAR[..] = integer( real_LAR[..] * 16384 );
+ * with -1.625 <= real_LAR <= 1.625
+ */
+ {
+ register word temp;
+ register int i;
+
+
+ /* Computation of the LAR[0..7] from the r[0..7]
+ */
+ for (i = 1; i <= 8; i++, r++) {
+
+ temp = *r;
+ temp = GSM_ABS(temp);
+ assert(temp >= 0);
+
+ if (temp < 22118) {
+ temp >>= 1;
+ } else if (temp < 31130) {
+ assert( temp >= 11059 );
+ temp -= 11059;
+ } else {
+ assert( temp >= 26112 );
+ temp -= 26112;
+ temp <<= 2;
+ }
+
+ *r = *r < 0 ? -temp : temp;
+ assert( *r != MIN_WORD );
+ }
+ }
+
+ /* 4.2.7 */
+
+ static void Quantization_and_coding P1((LAR),
+ register word * LAR /* [0..7] IN/OUT */
+ )
+ {
+ register word temp;
+ longword ltmp;
+
+
+ /* This procedure needs four tables; the following equations
+ * give the optimum scaling for the constants:
+ *
+ * A[0..7] = integer( real_A[0..7] * 1024 )
+ * B[0..7] = integer( real_B[0..7] * 512 )
+ * MAC[0..7] = maximum of the LARc[0..7]
+ * MIC[0..7] = minimum of the LARc[0..7]
+ */
+
+ # undef STEP
+ # define STEP( A, B, MAC, MIC ) \
+ temp = GSM_MULT( A, *LAR ); \
+ temp = GSM_ADD( temp, B ); \
+ temp = GSM_ADD( temp, 256 ); \
+ temp = SASR( temp, 9 ); \
+ *LAR = temp>MAC ? MAC - MIC : (temp<MIC ? 0 : temp - MIC); \
+ LAR++;
+
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 0, 31, -32 );
+ STEP( 20480, 2048, 15, -16 );
+ STEP( 20480, -2560, 15, -16 );
+
+ STEP( 13964, 94, 7, -8 );
+ STEP( 15360, -1792, 7, -8 );
+ STEP( 8534, -341, 3, -4 );
+ STEP( 9036, -1144, 3, -4 );
+
+ # undef STEP
+ }
+
+ void Gsm_LPC_Analysis P3((S, s,LARc),
+ struct gsm_state *S,
+ word * s, /* 0..159 signals IN/OUT */
+ word * LARc) /* 0..7 LARc's OUT */
+ {
+ longword L_ACF[9];
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+ if (S->fast) Fast_Autocorrelation (s, L_ACF );
+ else
+ #endif
+ Autocorrelation (s, L_ACF );
+ Reflection_coefficients (L_ACF, LARc );
+ Transformation_to_Log_Area_Ratios (LARc);
+ Quantization_and_coding (LARc);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/preprocess.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/preprocess.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/preprocess.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,113 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/preprocess.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /* 4.2.0 .. 4.2.3 PREPROCESSING SECTION
+ *
+ * After A-law to linear conversion (or directly from the
+ * Ato D converter) the following scaling is assumed for
+ * input to the RPE-LTP algorithm:
+ *
+ * in: 0.1.....................12
+ * S.v.v.v.v.v.v.v.v.v.v.v.v.*.*.*
+ *
+ * Where S is the sign bit, v a valid bit, and * a "don't care" bit.
+ * The original signal is called sop[..]
+ *
+ * out: 0.1................... 12
+ * S.S.v.v.v.v.v.v.v.v.v.v.v.v.0.0
+ */
+
+
+ void Gsm_Preprocess P3((S, s, so),
+ struct gsm_state * S,
+ word * s,
+ word * so ) /* [0..159] IN/OUT */
+ {
+
+ word z1 = S->z1;
+ longword L_z2 = S->L_z2;
+ word mp = S->mp;
+
+ word s1;
+ longword L_s2;
+
+ longword L_temp;
+
+ word msp, lsp;
+ word SO;
+
+ longword ltmp; /* for ADD */
+ ulongword utmp; /* for L_ADD */
+
+ register int k = 160;
+
+ while (k--) {
+
+ /* 4.2.1 Downscaling of the input signal
+ */
+ SO = SASR( *s, 3 ) << 2;
+ s++;
+
+ assert (SO >= -0x4000); /* downscaled by */
+ assert (SO <= 0x3FFC); /* previous routine. */
+
+
+ /* 4.2.2 Offset compensation
+ *
+ * This part implements a high-pass filter and requires extended
+ * arithmetic precision for the recursive part of this filter.
+ * The input of this procedure is the array so[0...159] and the
+ * output the array sof[ 0...159 ].
+ */
+ /* Compute the non-recursive part
+ */
+
+ s1 = SO - z1; /* s1 = gsm_sub( *so, z1 ); */
+ z1 = SO;
+
+ assert(s1 != MIN_WORD);
+
+ /* Compute the recursive part
+ */
+ L_s2 = s1;
+ L_s2 <<= 15;
+
+ /* Execution of a 31 bv 16 bits multiplication
+ */
+
+ msp = SASR( L_z2, 15 );
+ lsp = L_z2-((longword)msp<<15); /* gsm_L_sub(L_z2,(msp<<15)); */
+
+ L_s2 += GSM_MULT_R( lsp, 32735 );
+ L_temp = (longword)msp * 32735; /* GSM_L_MULT(msp,32735) >> 1;*/
+ L_z2 = GSM_L_ADD( L_temp, L_s2 );
+
+ /* Compute sof[k] with rounding
+ */
+ L_temp = GSM_L_ADD( L_z2, 16384 );
+
+ /* 4.2.3 Preemphasis
+ */
+
+ msp = GSM_MULT_R( mp, -28180 );
+ mp = SASR( L_temp, 15 );
+ *so++ = GSM_ADD( mp, msp );
+ }
+
+ S->z1 = z1;
+ S->L_z2 = L_z2;
+ S->mp = mp;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/private.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/private.h:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/private.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,263 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/private.h,v 1.1 2007/01/09 23:44:35 lattner Exp $*/
+
+ #ifndef PRIVATE_H
+ #define PRIVATE_H
+
+ typedef short word; /* 16 bit signed int */
+ typedef long longword; /* 32 bit signed int */
+
+ typedef unsigned short uword; /* unsigned word */
+ typedef unsigned long ulongword; /* unsigned longword */
+
+ struct gsm_state {
+
+ word dp0[ 280 ];
+
+ word z1; /* preprocessing.c, Offset_com. */
+ longword L_z2; /* Offset_com. */
+ int mp; /* Preemphasis */
+
+ word u[8]; /* short_term_aly_filter.c */
+ word LARpp[2][8]; /* */
+ word j; /* */
+
+ word nrp; /* 40 */ /* long_term.c, synthesis */
+ word v[9]; /* short_term.c, synthesis */
+ word msr; /* decoder.c, Postprocessing */
+
+ char verbose; /* only used if !NDEBUG */
+ char fast; /* only used if FAST */
+
+ };
+
+
+ #define MIN_WORD ((-32767)-1)
+ #define MAX_WORD ( 32767)
+
+ #define MIN_LONGWORD ((-2147483647)-1)
+ #define MAX_LONGWORD ( 2147483647)
+
+ #ifdef SASR /* >> is a signed arithmetic shift right */
+ #undef SASR
+ #define SASR(x, by) ((x) >> (by))
+ #endif /* SASR */
+
+
+ #include "proto.h"
+
+ /*
+ * Prototypes from add.c
+ */
+ extern word gsm_mult P((word a, word b));
+ extern longword gsm_L_mult P((word a, word b));
+ extern word gsm_mult_r P((word a, word b));
+
+ extern word gsm_div P((word num, word denum));
+
+ extern word gsm_add P(( word a, word b ));
+ extern longword gsm_L_add P(( longword a, longword b ));
+
+ extern word gsm_sub P((word a, word b));
+ extern longword gsm_L_sub P((longword a, longword b));
+
+ extern word gsm_abs P((word a));
+
+ extern word gsm_norm P(( longword a ));
+
+ extern longword gsm_L_asl P((longword a, int n));
+ extern word gsm_asl P((word a, int n));
+
+ extern longword gsm_L_asr P((longword a, int n));
+ extern word gsm_asr P((word a, int n));
+
+ /*
+ * Inlined functions from add.h
+ */
+
+ /*
+ * #define GSM_MULT_R(a, b) (* word a, word b, !(a == b == MIN_WORD) *) \
+ * (0x0FFFF & SASR(((longword)(a) * (longword)(b) + 16384), 15))
+ */
+ #define GSM_MULT_R(a, b) /* word a, word b, !(a == b == MIN_WORD) */ \
+ (SASR( ((longword)(a) * (longword)(b) + 16384), 15 ))
+
+ # define GSM_MULT(a,b) /* word a, word b, !(a == b == MIN_WORD) */ \
+ (SASR( ((longword)(a) * (longword)(b)), 15 ))
+
+ # define GSM_L_MULT(a, b) /* word a, word b */ \
+ (((longword)(a) * (longword)(b)) << 1)
+
+ # define GSM_L_ADD(a, b) \
+ ( (a) < 0 ? ( (b) >= 0 ? (a) + (b) \
+ : (utmp = (ulongword)-((a) + 1) + (ulongword)-((b) + 1)) \
+ >= MAX_LONGWORD ? MIN_LONGWORD : -(longword)utmp-2 ) \
+ : ((b) <= 0 ? (a) + (b) \
+ : (utmp = (ulongword)(a) + (ulongword)(b)) >= MAX_LONGWORD \
+ ? MAX_LONGWORD : utmp))
+
+ /*
+ * # define GSM_ADD(a, b) \
+ * ((ltmp = (longword)(a) + (longword)(b)) >= MAX_WORD \
+ * ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)
+ */
+ /* Nonportable, but faster: */
+
+ #define GSM_ADD(a, b) \
+ ((ulongword)((ltmp = (longword)(a) + (longword)(b)) - MIN_WORD) > \
+ MAX_WORD - MIN_WORD ? (ltmp > 0 ? MAX_WORD : MIN_WORD) : ltmp)
+
+ # define GSM_SUB(a, b) \
+ ((ltmp = (longword)(a) - (longword)(b)) >= MAX_WORD \
+ ? MAX_WORD : ltmp <= MIN_WORD ? MIN_WORD : ltmp)
+
+ # define GSM_ABS(a) ((a) < 0 ? ((a) == MIN_WORD ? MAX_WORD : -(a)) : (a))
+
+ /* Use these if necessary:
+
+ # define GSM_MULT_R(a, b) gsm_mult_r(a, b)
+ # define GSM_MULT(a, b) gsm_mult(a, b)
+ # define GSM_L_MULT(a, b) gsm_L_mult(a, b)
+
+ # define GSM_L_ADD(a, b) gsm_L_add(a, b)
+ # define GSM_ADD(a, b) gsm_add(a, b)
+ # define GSM_SUB(a, b) gsm_sub(a, b)
+
+ # define GSM_ABS(a) gsm_abs(a)
+
+ */
+
+ /*
+ * More prototypes from implementations..
+ */
+ extern void Gsm_Coder P((
+ struct gsm_state * S,
+ word * s, /* [0..159] samples IN */
+ word * LARc, /* [0..7] LAR coefficients OUT */
+ word * Nc, /* [0..3] LTP lag OUT */
+ word * bc, /* [0..3] coded LTP gain OUT */
+ word * Mc, /* [0..3] RPE grid selection OUT */
+ word * xmaxc,/* [0..3] Coded maximum amplitude OUT */
+ word * xMc /* [13*4] normalized RPE samples OUT */));
+
+ extern void Gsm_Long_Term_Predictor P(( /* 4x for 160 samples */
+ struct gsm_state * S,
+ word * d, /* [0..39] residual signal IN */
+ word * dp, /* [-120..-1] d' IN */
+ word * e, /* [0..40] OUT */
+ word * dpp, /* [0..40] OUT */
+ word * Nc, /* correlation lag OUT */
+ word * bc /* gain factor OUT */));
+
+ extern void Gsm_LPC_Analysis P((
+ struct gsm_state * S,
+ word * s, /* 0..159 signals IN/OUT */
+ word * LARc)); /* 0..7 LARc's OUT */
+
+ extern void Gsm_Preprocess P((
+ struct gsm_state * S,
+ word * s, word * so));
+
+ extern void Gsm_Encoding P((
+ struct gsm_state * S,
+ word * e,
+ word * ep,
+ word * xmaxc,
+ word * Mc,
+ word * xMc));
+
+ extern void Gsm_Short_Term_Analysis_Filter P((
+ struct gsm_state * S,
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * d /* st res. signal [0..159] IN/OUT */));
+
+ extern void Gsm_Decoder P((
+ struct gsm_state * S,
+ word * LARcr, /* [0..7] IN */
+ word * Ncr, /* [0..3] IN */
+ word * bcr, /* [0..3] IN */
+ word * Mcr, /* [0..3] IN */
+ word * xmaxcr, /* [0..3] IN */
+ word * xMcr, /* [0..13*4] IN */
+ word * s)); /* [0..159] OUT */
+
+ extern void Gsm_Decoding P((
+ struct gsm_state * S,
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12] IN */
+ word * erp)); /* [0..39] OUT */
+
+ extern void Gsm_Long_Term_Synthesis_Filtering P((
+ struct gsm_state* S,
+ word Ncr,
+ word bcr,
+ word * erp, /* [0..39] IN */
+ word * drp)); /* [-120..-1] IN, [0..40] OUT */
+
+ void Gsm_RPE_Decoding P((
+ struct gsm_state *S,
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12], 3 bits IN */
+ word * erp)); /* [0..39] OUT */
+
+ void Gsm_RPE_Encoding P((
+ struct gsm_state * S,
+ word * e, /* -5..-1][0..39][40..44 IN/OUT */
+ word * xmaxc, /* OUT */
+ word * Mc, /* OUT */
+ word * xMc)); /* [0..12] OUT */
+
+ extern void Gsm_Short_Term_Synthesis_Filter P((
+ struct gsm_state * S,
+ word * LARcr, /* log area ratios [0..7] IN */
+ word * drp, /* received d [0...39] IN */
+ word * s)); /* signal s [0..159] OUT */
+
+ extern void Gsm_Update_of_reconstructed_short_time_residual_signal P((
+ word * dpp, /* [0...39] IN */
+ word * ep, /* [0...39] IN */
+ word * dp)); /* [-120...-1] IN/OUT */
+
+ /*
+ * Tables from table.c
+ */
+ #ifndef GSM_TABLE_C
+
+ extern word gsm_A[8], gsm_B[8], gsm_MIC[8], gsm_MAC[8];
+ extern word gsm_INVA[8];
+ extern word gsm_DLB[4], gsm_QLB[4];
+ extern word gsm_H[11];
+ extern word gsm_NRFAC[8];
+ extern word gsm_FAC[8];
+
+ #endif /* GSM_TABLE_C */
+
+ /*
+ * Debugging
+ */
+ #ifdef NDEBUG
+
+ # define gsm_debug_words(a, b, c, d) /* nil */
+ # define gsm_debug_longwords(a, b, c, d) /* nil */
+ # define gsm_debug_word(a, b) /* nil */
+ # define gsm_debug_longword(a, b) /* nil */
+
+ #else /* !NDEBUG => DEBUG */
+
+ extern void gsm_debug_words P((char * name, int, int, word *));
+ extern void gsm_debug_longwords P((char * name, int, int, longword *));
+ extern void gsm_debug_longword P((char * name, longword));
+ extern void gsm_debug_word P((char * name, word));
+
+ #endif /* !NDEBUG */
+
+ #include "unproto.h"
+
+ #endif /* PRIVATE_H */
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/proto.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/proto.h:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/proto.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,65 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/proto.h,v 1.1 2007/01/09 23:44:35 lattner Exp $*/
+
+ #ifndef PROTO_H
+ #define PROTO_H
+
+ #if __cplusplus
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #if __STDC__
+ # define NeedFunctionPrototypes 1
+ #endif
+
+ #ifdef _NO_PROTO
+ # undef NeedFunctionPrototypes
+ #endif
+
+ #undef P /* gnu stdio.h actually defines this... */
+ #undef P0
+ #undef P1
+ #undef P2
+ #undef P3
+ #undef P4
+ #undef P5
+ #undef P6
+ #undef P7
+ #undef P8
+
+ #if NeedFunctionPrototypes
+
+ # define P( protos ) protos
+
+ # define P0() (void)
+ # define P1(x, a) (a)
+ # define P2(x, a, b) (a, b)
+ # define P3(x, a, b, c) (a, b, c)
+ # define P4(x, a, b, c, d) (a, b, c, d)
+ # define P5(x, a, b, c, d, e) (a, b, c, d, e)
+ # define P6(x, a, b, c, d, e, f) (a, b, c, d, e, f)
+ # define P7(x, a, b, c, d, e, f, g) (a, b, c, d, e, f, g)
+ # define P8(x, a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h)
+
+ #else /* !NeedFunctionPrototypes */
+
+ # define P( protos ) ( /* protos */ )
+
+ # define P0() ()
+ # define P1(x, a) x a;
+ # define P2(x, a, b) x a; b;
+ # define P3(x, a, b, c) x a; b; c;
+ # define P4(x, a, b, c, d) x a; b; c; d;
+ # define P5(x, a, b, c, d, e) x a; b; c; d; e;
+ # define P6(x, a, b, c, d, e, f) x a; b; c; d; e; f;
+ # define P7(x, a, b, c, d, e, f, g) x a; b; c; d; e; f; g;
+ # define P8(x, a, b, c, d, e, f, g, h) x a; b; c; d; e; f; g; h;
+
+ #endif /* !NeedFunctionPrototypes */
+
+ #endif /* PROTO_H */
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/rpe.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/rpe.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/rpe.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,488 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/rpe.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /* 4.2.13 .. 4.2.17 RPE ENCODING SECTION
+ */
+
+ /* 4.2.13 */
+
+ static void Weighting_filter P2((e, x),
+ register word * e, /* signal [-5..0.39.44] IN */
+ word * x /* signal [0..39] OUT */
+ )
+ /*
+ * The coefficients of the weighting filter are stored in a table
+ * (see table 4.4). The following scaling is used:
+ *
+ * H[0..10] = integer( real_H[ 0..10] * 8192 );
+ */
+ {
+ /* word wt[ 50 ]; */
+
+ register longword L_result;
+ register int k /* , i */ ;
+
+ /* Initialization of a temporary working array wt[0...49]
+ */
+
+ /* for (k = 0; k <= 4; k++) wt[k] = 0;
+ * for (k = 5; k <= 44; k++) wt[k] = *e++;
+ * for (k = 45; k <= 49; k++) wt[k] = 0;
+ *
+ * (e[-5..-1] and e[40..44] are allocated by the caller,
+ * are initially zero and are not written anywhere.)
+ */
+ e -= 5;
+
+ /* Compute the signal x[0..39]
+ */
+ for (k = 0; k <= 39; k++) {
+
+ L_result = 8192 >> 1;
+
+ /* for (i = 0; i <= 10; i++) {
+ * L_temp = GSM_L_MULT( wt[k+i], gsm_H[i] );
+ * L_result = GSM_L_ADD( L_result, L_temp );
+ * }
+ */
+
+ #undef STEP
+ #define STEP( i, H ) (e[ k + i ] * (longword)H)
+
+ /* Every one of these multiplications is done twice --
+ * but I don't see an elegant way to optimize this.
+ * Do you?
+ */
+
+ #ifdef STUPID_COMPILER
+ L_result += STEP( 0, -134 ) ;
+ L_result += STEP( 1, -374 ) ;
+ /* + STEP( 2, 0 ) */
+ L_result += STEP( 3, 2054 ) ;
+ L_result += STEP( 4, 5741 ) ;
+ L_result += STEP( 5, 8192 ) ;
+ L_result += STEP( 6, 5741 ) ;
+ L_result += STEP( 7, 2054 ) ;
+ /* + STEP( 8, 0 ) */
+ L_result += STEP( 9, -374 ) ;
+ L_result += STEP( 10, -134 ) ;
+ #else
+ L_result +=
+ STEP( 0, -134 )
+ + STEP( 1, -374 )
+ /* + STEP( 2, 0 ) */
+ + STEP( 3, 2054 )
+ + STEP( 4, 5741 )
+ + STEP( 5, 8192 )
+ + STEP( 6, 5741 )
+ + STEP( 7, 2054 )
+ /* + STEP( 8, 0 ) */
+ + STEP( 9, -374 )
+ + STEP(10, -134 )
+ ;
+ #endif
+
+ /* L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x2) *)
+ * L_result = GSM_L_ADD( L_result, L_result ); (* scaling(x4) *)
+ *
+ * x[k] = SASR( L_result, 16 );
+ */
+
+ /* 2 adds vs. >>16 => 14, minus one shift to compensate for
+ * those we lost when replacing L_MULT by '*'.
+ */
+
+ L_result = SASR( L_result, 13 );
+ x[k] = ( L_result < MIN_WORD ? MIN_WORD
+ : (L_result > MAX_WORD ? MAX_WORD : L_result ));
+ }
+ }
+
+ /* 4.2.14 */
+
+ static void RPE_grid_selection P3((x,xM,Mc_out),
+ word * x, /* [0..39] IN */
+ word * xM, /* [0..12] OUT */
+ word * Mc_out /* OUT */
+ )
+ /*
+ * The signal x[0..39] is used to select the RPE grid which is
+ * represented by Mc.
+ */
+ {
+ /* register word temp1; */
+ register int /* m, */ i;
+ register longword L_result, L_temp;
+ longword EM; /* xxx should be L_EM? */
+ word Mc;
+
+ longword L_common_0_3;
+
+ EM = 0;
+ Mc = 0;
+
+ /* for (m = 0; m <= 3; m++) {
+ * L_result = 0;
+ *
+ *
+ * for (i = 0; i <= 12; i++) {
+ *
+ * temp1 = SASR( x[m + 3*i], 2 );
+ *
+ * assert(temp1 != MIN_WORD);
+ *
+ * L_temp = GSM_L_MULT( temp1, temp1 );
+ * L_result = GSM_L_ADD( L_temp, L_result );
+ * }
+ *
+ * if (L_result > EM) {
+ * Mc = m;
+ * EM = L_result;
+ * }
+ * }
+ */
+
+ #undef STEP
+ #define STEP( m, i ) L_temp = SASR( x[m + 3 * i], 2 ); \
+ L_result += L_temp * L_temp;
+
+ /* common part of 0 and 3 */
+
+ L_result = 0;
+ STEP( 0, 1 ); STEP( 0, 2 ); STEP( 0, 3 ); STEP( 0, 4 );
+ STEP( 0, 5 ); STEP( 0, 6 ); STEP( 0, 7 ); STEP( 0, 8 );
+ STEP( 0, 9 ); STEP( 0, 10); STEP( 0, 11); STEP( 0, 12);
+ L_common_0_3 = L_result;
+
+ /* i = 0 */
+
+ STEP( 0, 0 );
+ L_result <<= 1; /* implicit in L_MULT */
+ EM = L_result;
+
+ /* i = 1 */
+
+ L_result = 0;
+ STEP( 1, 0 );
+ STEP( 1, 1 ); STEP( 1, 2 ); STEP( 1, 3 ); STEP( 1, 4 );
+ STEP( 1, 5 ); STEP( 1, 6 ); STEP( 1, 7 ); STEP( 1, 8 );
+ STEP( 1, 9 ); STEP( 1, 10); STEP( 1, 11); STEP( 1, 12);
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 1;
+ EM = L_result;
+ }
+
+ /* i = 2 */
+
+ L_result = 0;
+ STEP( 2, 0 );
+ STEP( 2, 1 ); STEP( 2, 2 ); STEP( 2, 3 ); STEP( 2, 4 );
+ STEP( 2, 5 ); STEP( 2, 6 ); STEP( 2, 7 ); STEP( 2, 8 );
+ STEP( 2, 9 ); STEP( 2, 10); STEP( 2, 11); STEP( 2, 12);
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 2;
+ EM = L_result;
+ }
+
+ /* i = 3 */
+
+ L_result = L_common_0_3;
+ STEP( 3, 12 );
+ L_result <<= 1;
+ if (L_result > EM) {
+ Mc = 3;
+ EM = L_result;
+ }
+
+ /**/
+
+ /* Down-sampling by a factor 3 to get the selected xM[0..12]
+ * RPE sequence.
+ */
+ for (i = 0; i <= 12; i ++) xM[i] = x[Mc + 3*i];
+ *Mc_out = Mc;
+ }
+
+ /* 4.12.15 */
+
+ static void APCM_quantization_xmaxc_to_exp_mant P3((xmaxc,exp_out,mant_out),
+ word xmaxc, /* IN */
+ word * exp_out, /* OUT */
+ word * mant_out ) /* OUT */
+ {
+ word exp, mant;
+
+ /* Compute exponent and mantissa of the decoded version of xmaxc
+ */
+
+ exp = 0;
+ if (xmaxc > 15) exp = SASR(xmaxc, 3) - 1;
+ mant = xmaxc - (exp << 3);
+
+ if (mant == 0) {
+ exp = -4;
+ mant = 7;
+ }
+ else {
+ while (mant <= 7) {
+ mant = mant << 1 | 1;
+ exp--;
+ }
+ mant -= 8;
+ }
+
+ assert( exp >= -4 && exp <= 6 );
+ assert( mant >= 0 && mant <= 7 );
+
+ *exp_out = exp;
+ *mant_out = mant;
+ }
+
+ static void APCM_quantization P5((xM,xMc,mant_out,exp_out,xmaxc_out),
+ word * xM, /* [0..12] IN */
+
+ word * xMc, /* [0..12] OUT */
+ word * mant_out, /* OUT */
+ word * exp_out, /* OUT */
+ word * xmaxc_out /* OUT */
+ )
+ {
+ int i, itest;
+
+ word xmax, xmaxc, temp, temp1, temp2;
+ word exp, mant;
+
+
+ /* Find the maximum absolute value xmax of xM[0..12].
+ */
+
+ xmax = 0;
+ for (i = 0; i <= 12; i++) {
+ temp = xM[i];
+ temp = GSM_ABS(temp);
+ if (temp > xmax) xmax = temp;
+ }
+
+ /* Qantizing and coding of xmax to get xmaxc.
+ */
+
+ exp = 0;
+ temp = SASR( xmax, 9 );
+ itest = 0;
+
+ for (i = 0; i <= 5; i++) {
+
+ itest |= (temp <= 0);
+ temp = SASR( temp, 1 );
+
+ assert(exp <= 5);
+ if (itest == 0) exp++; /* exp = add (exp, 1) */
+ }
+
+ assert(exp <= 6 && exp >= 0);
+ temp = exp + 5;
+
+ assert(temp <= 11 && temp >= 0);
+ xmaxc = gsm_add( SASR(xmax, temp), exp << 3 );
+
+ /* Quantizing and coding of the xM[0..12] RPE sequence
+ * to get the xMc[0..12]
+ */
+
+ APCM_quantization_xmaxc_to_exp_mant( xmaxc, &exp, &mant );
+
+ /* This computation uses the fact that the decoded version of xmaxc
+ * can be calculated by using the exponent and the mantissa part of
+ * xmaxc (logarithmic table).
+ * So, this method avoids any division and uses only a scaling
+ * of the RPE samples by a function of the exponent. A direct
+ * multiplication by the inverse of the mantissa (NRFAC[0..7]
+ * found in table 4.5) gives the 3 bit coded version xMc[0..12]
+ * of the RPE samples.
+ */
+
+
+ /* Direct computation of xMc[0..12] using table 4.5
+ */
+
+ assert( exp <= 4096 && exp >= -4096);
+ assert( mant >= 0 && mant <= 7 );
+
+ temp1 = 6 - exp; /* normalization by the exponent */
+ temp2 = gsm_NRFAC[ mant ]; /* inverse mantissa */
+
+ for (i = 0; i <= 12; i++) {
+
+ assert(temp1 >= 0 && temp1 < 16);
+
+ temp = xM[i] << temp1;
+ temp = GSM_MULT( temp, temp2 );
+ temp = SASR(temp, 12);
+ xMc[i] = temp + 4; /* see note below */
+ }
+
+ /* NOTE: This equation is used to make all the xMc[i] positive.
+ */
+
+ *mant_out = mant;
+ *exp_out = exp;
+ *xmaxc_out = xmaxc;
+ }
+
+ /* 4.2.16 */
+
+ static void APCM_inverse_quantization P4((xMc,mant,exp,xMp),
+ register word * xMc, /* [0..12] IN */
+ word mant,
+ word exp,
+ register word * xMp) /* [0..12] OUT */
+ /*
+ * This part is for decoding the RPE sequence of coded xMc[0..12]
+ * samples to obtain the xMp[0..12] array. Table 4.6 is used to get
+ * the mantissa of xmaxc (FAC[0..7]).
+ */
+ {
+ int i;
+ word temp, temp1, temp2, temp3;
+ longword ltmp;
+
+ assert( mant >= 0 && mant <= 7 );
+
+ temp1 = gsm_FAC[ mant ]; /* see 4.2-15 for mant */
+ temp2 = gsm_sub( 6, exp ); /* see 4.2-15 for exp */
+ temp3 = gsm_asl( 1, gsm_sub( temp2, 1 ));
+
+ for (i = 13; i--;) {
+
+ assert( *xMc <= 7 && *xMc >= 0 ); /* 3 bit unsigned */
+
+ /* temp = gsm_sub( *xMc++ << 1, 7 ); */
+ temp = (*xMc++ << 1) - 7; /* restore sign */
+ assert( temp <= 7 && temp >= -7 ); /* 4 bit signed */
+
+ temp <<= 12; /* 16 bit signed */
+ temp = GSM_MULT_R( temp1, temp );
+ temp = GSM_ADD( temp, temp3 );
+ *xMp++ = gsm_asr( temp, temp2 );
+ }
+ }
+
+ /* 4.2.17 */
+
+ static void RPE_grid_positioning P3((Mc,xMp,ep),
+ word Mc, /* grid position IN */
+ register word * xMp, /* [0..12] IN */
+ register word * ep /* [0..39] OUT */
+ )
+ /*
+ * This procedure computes the reconstructed long term residual signal
+ * ep[0..39] for the LTP analysis filter. The inputs are the Mc
+ * which is the grid position selection and the xMp[0..12] decoded
+ * RPE samples which are upsampled by a factor of 3 by inserting zero
+ * values.
+ */
+ {
+ int i = 13;
+
+ assert(0 <= Mc && Mc <= 3);
+
+ switch (Mc) {
+ case 3: *ep++ = 0;
+ case 2: do {
+ *ep++ = 0;
+ case 1: *ep++ = 0;
+ case 0: *ep++ = *xMp++;
+ } while (--i);
+ }
+ while (++Mc < 4) *ep++ = 0;
+
+ /*
+
+ int i, k;
+ for (k = 0; k <= 39; k++) ep[k] = 0;
+ for (i = 0; i <= 12; i++) {
+ ep[ Mc + (3*i) ] = xMp[i];
+ }
+ */
+ }
+
+ /* 4.2.18 */
+
+ /* This procedure adds the reconstructed long term residual signal
+ * ep[0..39] to the estimated signal dpp[0..39] from the long term
+ * analysis filter to compute the reconstructed short term residual
+ * signal dp[-40..-1]; also the reconstructed short term residual
+ * array dp[-120..-41] is updated.
+ */
+
+ #if 0 /* Has been inlined in code.c */
+ void Gsm_Update_of_reconstructed_short_time_residual_signal P3((dpp, ep, dp),
+ word * dpp, /* [0...39] IN */
+ word * ep, /* [0...39] IN */
+ word * dp) /* [-120...-1] IN/OUT */
+ {
+ int k;
+
+ for (k = 0; k <= 79; k++)
+ dp[ -120 + k ] = dp[ -80 + k ];
+
+ for (k = 0; k <= 39; k++)
+ dp[ -40 + k ] = gsm_add( ep[k], dpp[k] );
+ }
+ #endif /* Has been inlined in code.c */
+
+ void Gsm_RPE_Encoding P5((S,e,xmaxc,Mc,xMc),
+
+ struct gsm_state * S,
+
+ word * e, /* -5..-1][0..39][40..44 IN/OUT */
+ word * xmaxc, /* OUT */
+ word * Mc, /* OUT */
+ word * xMc) /* [0..12] OUT */
+ {
+ word x[40];
+ word xM[13], xMp[13];
+ word mant, exp;
+
+ Weighting_filter(e, x);
+ RPE_grid_selection(x, xM, Mc);
+
+ APCM_quantization( xM, xMc, &mant, &exp, xmaxc);
+ APCM_inverse_quantization( xMc, mant, exp, xMp);
+
+ RPE_grid_positioning( *Mc, xMp, e );
+
+ }
+
+ void Gsm_RPE_Decoding P5((S, xmaxcr, Mcr, xMcr, erp),
+ struct gsm_state * S,
+
+ word xmaxcr,
+ word Mcr,
+ word * xMcr, /* [0..12], 3 bits IN */
+ word * erp /* [0..39] OUT */
+ )
+ {
+ word exp, mant;
+ word xMp[ 13 ];
+
+ APCM_quantization_xmaxc_to_exp_mant( xmaxcr, &exp, &mant );
+ APCM_inverse_quantization( xMcr, mant, exp, xMp );
+ RPE_grid_positioning( Mcr, xMp, erp );
+
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/short_term.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/short_term.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/short_term.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,429 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/short_term.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include <stdio.h>
+ #include <assert.h>
+
+ #include "private.h"
+
+ #include "gsm.h"
+ #include "proto.h"
+
+ /*
+ * SHORT TERM ANALYSIS FILTERING SECTION
+ */
+
+ /* 4.2.8 */
+
+ static void Decoding_of_the_coded_Log_Area_Ratios P2((LARc,LARpp),
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * LARpp) /* out: decoded .. */
+ {
+ register word temp1 /* , temp2 */;
+ register long ltmp; /* for GSM_ADD */
+
+ /* This procedure requires for efficient implementation
+ * two tables.
+ *
+ * INVA[1..8] = integer( (32768 * 8) / real_A[1..8])
+ * MIC[1..8] = minimum value of the LARc[1..8]
+ */
+
+ /* Compute the LARpp[1..8]
+ */
+
+ /* for (i = 1; i <= 8; i++, B++, MIC++, INVA++, LARc++, LARpp++) {
+ *
+ * temp1 = GSM_ADD( *LARc, *MIC ) << 10;
+ * temp2 = *B << 1;
+ * temp1 = GSM_SUB( temp1, temp2 );
+ *
+ * assert(*INVA != MIN_WORD);
+ *
+ * temp1 = GSM_MULT_R( *INVA, temp1 );
+ * *LARpp = GSM_ADD( temp1, temp1 );
+ * }
+ */
+
+ #undef STEP
+ #define STEP( B, MIC, INVA ) \
+ temp1 = GSM_ADD( *LARc++, MIC ) << 10; \
+ temp1 = GSM_SUB( temp1, B << 1 ); \
+ temp1 = GSM_MULT_R( INVA, temp1 ); \
+ *LARpp++ = GSM_ADD( temp1, temp1 );
+
+ STEP( 0, -32, 13107 );
+ STEP( 0, -32, 13107 );
+ STEP( 2048, -16, 13107 );
+ STEP( -2560, -16, 13107 );
+
+ STEP( 94, -8, 19223 );
+ STEP( -1792, -8, 17476 );
+ STEP( -341, -4, 31454 );
+ STEP( -1144, -4, 29708 );
+
+ /* NOTE: the addition of *MIC is used to restore
+ * the sign of *LARc.
+ */
+ }
+
+ /* 4.2.9 */
+ /* Computation of the quantized reflection coefficients
+ */
+
+ /* 4.2.9.1 Interpolation of the LARpp[1..8] to get the LARp[1..8]
+ */
+
+ /*
+ * Within each frame of 160 analyzed speech samples the short term
+ * analysis and synthesis filters operate with four different sets of
+ * coefficients, derived from the previous set of decoded LARs(LARpp(j-1))
+ * and the actual set of decoded LARs (LARpp(j))
+ *
+ * (Initial value: LARpp(j-1)[1..8] = 0.)
+ */
+
+ static void Coefficients_0_12 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARp++, LARpp_j_1++, LARpp_j++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = GSM_ADD( *LARp, SASR( *LARpp_j_1, 1));
+ }
+ }
+
+ static void Coefficients_13_26 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+ for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 1), SASR( *LARpp_j, 1 ));
+ }
+ }
+
+ static void Coefficients_27_39 P3((LARpp_j_1, LARpp_j, LARp),
+ register word * LARpp_j_1,
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARpp_j_1++, LARpp_j++, LARp++) {
+ *LARp = GSM_ADD( SASR( *LARpp_j_1, 2 ), SASR( *LARpp_j, 2 ));
+ *LARp = GSM_ADD( *LARp, SASR( *LARpp_j, 1 ));
+ }
+ }
+
+
+ static void Coefficients_40_159 P2((LARpp_j, LARp),
+ register word * LARpp_j,
+ register word * LARp)
+ {
+ register int i;
+
+ for (i = 1; i <= 8; i++, LARp++, LARpp_j++)
+ *LARp = *LARpp_j;
+ }
+
+ /* 4.2.9.2 */
+
+ static void LARp_to_rp P1((LARp),
+ register word * LARp) /* [0..7] IN/OUT */
+ /*
+ * The input of this procedure is the interpolated LARp[0..7] array.
+ * The reflection coefficients, rp[i], are used in the analysis
+ * filter and in the synthesis filter.
+ */
+ {
+ register int i;
+ register word temp;
+ register longword ltmp;
+
+ for (i = 1; i <= 8; i++, LARp++) {
+
+ /* temp = GSM_ABS( *LARp );
+ *
+ * if (temp < 11059) temp <<= 1;
+ * else if (temp < 20070) temp += 11059;
+ * else temp = GSM_ADD( temp >> 2, 26112 );
+ *
+ * *LARp = *LARp < 0 ? -temp : temp;
+ */
+
+ if (*LARp < 0) {
+ temp = *LARp == MIN_WORD ? MAX_WORD : -(*LARp);
+ *LARp = - ((temp < 11059) ? temp << 1
+ : ((temp < 20070) ? temp + 11059
+ : GSM_ADD( temp >> 2, 26112 )));
+ } else {
+ temp = *LARp;
+ *LARp = (temp < 11059) ? temp << 1
+ : ((temp < 20070) ? temp + 11059
+ : GSM_ADD( temp >> 2, 26112 ));
+ }
+ }
+ }
+
+
+ /* 4.2.10 */
+ static void Short_term_analysis_filtering P4((S,rp,k_n,s),
+ struct gsm_state * S,
+ register word * rp, /* [0..7] IN */
+ register int k_n, /* k_end - k_start */
+ register word * s /* [0..n-1] IN/OUT */
+ )
+ /*
+ * This procedure computes the short term residual signal d[..] to be fed
+ * to the RPE-LTP loop from the s[..] signal and from the local rp[..]
+ * array (quantized reflection coefficients). As the call of this
+ * procedure can be done in many ways (see the interpolation of the LAR
+ * coefficient), it is assumed that the computation begins with index
+ * k_start (for arrays d[..] and s[..]) and stops with index k_end
+ * (k_start and k_end are defined in 4.2.9.1). This procedure also
+ * needs to keep the array u[0..7] in memory for each call.
+ */
+ {
+ register word * u = S->u;
+ register int i;
+ register word di, zzz, ui, sav, rpi;
+ register longword ltmp;
+
+ for (; k_n--; s++) {
+
+ di = sav = *s;
+
+ for (i = 0; i < 8; i++) { /* YYY */
+
+ ui = u[i];
+ rpi = rp[i];
+ u[i] = sav;
+
+ zzz = GSM_MULT_R(rpi, di);
+ sav = GSM_ADD( ui, zzz);
+
+ zzz = GSM_MULT_R(rpi, ui);
+ di = GSM_ADD( di, zzz );
+ }
+
+ *s = di;
+ }
+ }
+
+ #if defined(USE_FLOAT_MUL) && defined(FAST)
+
+ static void Fast_Short_term_analysis_filtering P4((S,rp,k_n,s),
+ struct gsm_state * S,
+ register word * rp, /* [0..7] IN */
+ register int k_n, /* k_end - k_start */
+ register word * s /* [0..n-1] IN/OUT */
+ )
+ {
+ register word * u = S->u;
+ register int i;
+
+ float uf[8],
+ rpf[8];
+
+ register float scalef = 3.0517578125e-5;
+ register float sav, di, temp;
+
+ for (i = 0; i < 8; ++i) {
+ uf[i] = u[i];
+ rpf[i] = rp[i] * scalef;
+ }
+ for (; k_n--; s++) {
+ sav = di = *s;
+ for (i = 0; i < 8; ++i) {
+ register float rpfi = rpf[i];
+ register float ufi = uf[i];
+
+ uf[i] = sav;
+ temp = rpfi * di + ufi;
+ di += rpfi * ufi;
+ sav = temp;
+ }
+ *s = di;
+ }
+ for (i = 0; i < 8; ++i) u[i] = uf[i];
+ }
+ #endif /* ! (defined (USE_FLOAT_MUL) && defined (FAST)) */
+
+ static void Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),
+ struct gsm_state * S,
+ register word * rrp, /* [0..7] IN */
+ register int k, /* k_end - k_start */
+ register word * wt, /* [0..k-1] IN */
+ register word * sr /* [0..k-1] OUT */
+ )
+ {
+ register word * v = S->v;
+ register int i;
+ register word sri, tmp1, tmp2;
+ register longword ltmp; /* for GSM_ADD & GSM_SUB */
+
+ while (k--) {
+ sri = *wt++;
+ for (i = 8; i--;) {
+
+ /* sri = GSM_SUB( sri, gsm_mult_r( rrp[i], v[i] ) );
+ */
+ tmp1 = rrp[i];
+ tmp2 = v[i];
+ tmp2 = ( tmp1 == MIN_WORD && tmp2 == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)tmp2
+ + 16384) >> 15)) ;
+
+ sri = GSM_SUB( sri, tmp2 );
+
+ /* v[i+1] = GSM_ADD( v[i], gsm_mult_r( rrp[i], sri ) );
+ */
+ tmp1 = ( tmp1 == MIN_WORD && sri == MIN_WORD
+ ? MAX_WORD
+ : 0x0FFFF & (( (longword)tmp1 * (longword)sri
+ + 16384) >> 15)) ;
+
+ v[i+1] = GSM_ADD( v[i], tmp1);
+ }
+ *sr++ = v[0] = sri;
+ }
+ }
+
+
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+
+ static void Fast_Short_term_synthesis_filtering P5((S,rrp,k,wt,sr),
+ struct gsm_state * S,
+ register word * rrp, /* [0..7] IN */
+ register int k, /* k_end - k_start */
+ register word * wt, /* [0..k-1] IN */
+ register word * sr /* [0..k-1] OUT */
+ )
+ {
+ register word * v = S->v;
+ register int i;
+
+ float va[9], rrpa[8];
+ register float scalef = 3.0517578125e-5, temp;
+
+ for (i = 0; i < 8; ++i) {
+ va[i] = v[i];
+ rrpa[i] = (float)rrp[i] * scalef;
+ }
+ while (k--) {
+ register float sri = *wt++;
+ for (i = 8; i--;) {
+ sri -= rrpa[i] * va[i];
+ if (sri < -32768.) sri = -32768.;
+ else if (sri > 32767.) sri = 32767.;
+
+ temp = va[i] + rrpa[i] * sri;
+ if (temp < -32768.) temp = -32768.;
+ else if (temp > 32767.) temp = 32767.;
+ va[i+1] = temp;
+ }
+ *sr++ = va[0] = sri;
+ }
+ for (i = 0; i < 9; ++i) v[i] = va[i];
+ }
+
+ #endif /* defined(FAST) && defined(USE_FLOAT_MUL) */
+
+ void Gsm_Short_Term_Analysis_Filter P3((S,LARc,s),
+
+ struct gsm_state * S,
+
+ word * LARc, /* coded log area ratio [0..7] IN */
+ word * s /* signal [0..159] IN/OUT */
+ )
+ {
+ word * LARpp_j = S->LARpp[ S->j ];
+ word * LARpp_j_1 = S->LARpp[ S->j ^= 1 ];
+
+ word LARp[8];
+
+ #undef FILTER
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+ # define FILTER (* (S->fast \
+ ? Fast_Short_term_analysis_filtering \
+ : Short_term_analysis_filtering ))
+
+ #else
+ # define FILTER Short_term_analysis_filtering
+ #endif
+
+ Decoding_of_the_coded_Log_Area_Ratios( LARc, LARpp_j );
+
+ Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, s);
+
+ Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 14, s + 13);
+
+ Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, s + 27);
+
+ Coefficients_40_159( LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 120, s + 40);
+ }
+
+ void Gsm_Short_Term_Synthesis_Filter P4((S, LARcr, wt, s),
+ struct gsm_state * S,
+
+ word * LARcr, /* received log area ratios [0..7] IN */
+ word * wt, /* received d [0..159] IN */
+
+ word * s /* signal s [0..159] OUT */
+ )
+ {
+ word * LARpp_j = S->LARpp[ S->j ];
+ word * LARpp_j_1 = S->LARpp[ S->j ^=1 ];
+
+ word LARp[8];
+
+ #undef FILTER
+ #if defined(FAST) && defined(USE_FLOAT_MUL)
+
+ # define FILTER (* (S->fast \
+ ? Fast_Short_term_synthesis_filtering \
+ : Short_term_synthesis_filtering ))
+ #else
+ # define FILTER Short_term_synthesis_filtering
+ #endif
+
+ Decoding_of_the_coded_Log_Area_Ratios( LARcr, LARpp_j );
+
+ Coefficients_0_12( LARpp_j_1, LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, wt, s );
+
+ Coefficients_13_26( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 14, wt + 13, s + 13 );
+
+ Coefficients_27_39( LARpp_j_1, LARpp_j, LARp);
+ LARp_to_rp( LARp );
+ FILTER( S, LARp, 13, wt + 27, s + 27 );
+
+ Coefficients_40_159( LARpp_j, LARp );
+ LARp_to_rp( LARp );
+ FILTER(S, LARp, 120, wt + 40, s + 40);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/table.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/table.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/table.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,63 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/table.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ /* Most of these tables are inlined at their point of use.
+ */
+
+ /* 4.4 TABLES USED IN THE FIXED POINT IMPLEMENTATION OF THE RPE-LTP
+ * CODER AND DECODER
+ *
+ * (Most of them inlined, so watch out.)
+ */
+
+ #define GSM_TABLE_C
+ #include "private.h"
+ #include "gsm.h"
+
+ /* Table 4.1 Quantization of the Log.-Area Ratios
+ */
+ /* i 1 2 3 4 5 6 7 8 */
+ word gsm_A[8] = {20480, 20480, 20480, 20480, 13964, 15360, 8534, 9036};
+ word gsm_B[8] = { 0, 0, 2048, -2560, 94, -1792, -341, -1144};
+ word gsm_MIC[8] = { -32, -32, -16, -16, -8, -8, -4, -4 };
+ word gsm_MAC[8] = { 31, 31, 15, 15, 7, 7, 3, 3 };
+
+
+ /* Table 4.2 Tabulation of 1/A[1..8]
+ */
+ word gsm_INVA[8]={ 13107, 13107, 13107, 13107, 19223, 17476, 31454, 29708 };
+
+
+ /* Table 4.3a Decision level of the LTP gain quantizer
+ */
+ /* bc 0 1 2 3 */
+ word gsm_DLB[4] = { 6554, 16384, 26214, 32767 };
+
+
+ /* Table 4.3b Quantization levels of the LTP gain quantizer
+ */
+ /* bc 0 1 2 3 */
+ word gsm_QLB[4] = { 3277, 11469, 21299, 32767 };
+
+
+ /* Table 4.4 Coefficients of the weighting filter
+ */
+ /* i 0 1 2 3 4 5 6 7 8 9 10 */
+ word gsm_H[11] = {-134, -374, 0, 2054, 5741, 8192, 5741, 2054, 0, -374, -134 };
+
+
+ /* Table 4.5 Normalized inverse mantissa used to compute xM/xmax
+ */
+ /* i 0 1 2 3 4 5 6 7 */
+ word gsm_NRFAC[8] = { 29128, 26215, 23832, 21846, 20165, 18725, 17476, 16384 };
+
+
+ /* Table 4.6 Normalized direct mantissa used to compute xM/xmax
+ */
+ /* i 0 1 2 3 4 5 6 7 */
+ word gsm_FAC[8] = { 18431, 20479, 22527, 24575, 26623, 28671, 30719, 32767 };
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,787 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "toast.h"
+
+ /* toast -- lossy sound compression using the gsm library.
+ */
+
+ char * progname;
+
+ int f_decode = 0; /* decode rather than encode (-d) */
+ int f_cat = 0; /* write to stdout, not foo.gsm (-c) */
+ int f_force = 0; /* force deletion (-f) */
+ int f_precious = 0; /* avoid deletion (-p) */
+ int f_fast = 0; /* use faster fpt algorithm (-F) */
+ int f_verbose = 0; /* debugging (-V) */
+
+ struct stat instat; /* stat (inname) */
+
+ FILE *in, *out;
+ char *inname, *outname;
+
+ /*
+ * The function (*output)() writes a frame of 160 samples given as
+ * 160 signed 16 bit values (gsm_signals) to <out>.
+ * The function (*input)() reads one such frame from <in>.
+ * The function (*init_output)() begins output (e.g. writes a header).,
+ * The function (*init_input)() begins input (e.g. skips a header).
+ *
+ * There are different versions of input, output, init_input and init_output
+ * for different formats understood by toast; which ones are used
+ * depends on the command line arguments and, in their absence, the
+ * filename; the fallback is #defined in toast.h
+ *
+ * The specific implementations of input, output, init_input and init_output
+ * for a format `foo' live in toast_foo.c.
+ */
+
+ int (*output ) P((gsm_signal *)),
+ (*input ) P((gsm_signal *));
+ int (*init_input) P((void)),
+ (*init_output) P((void));
+
+ static int generic_init P0() { return 0; } /* NOP */
+
+ struct fmtdesc {
+
+ char * name, * longname, * suffix;
+
+ int (* init_input ) P((void)),
+ (* init_output) P((void));
+
+ int (* input ) P((gsm_signal * )),
+ (* output) P((gsm_signal * ));
+
+ } f_audio = {
+ "audio",
+ "8 kHz, 8 bit u-law encoding with Sun audio header", ".au",
+ audio_init_input,
+ audio_init_output,
+ ulaw_input,
+ ulaw_output
+ }, f_ulaw = {
+ "u-law", "plain 8 kHz, 8 bit u-law encoding", ".u",
+ generic_init,
+ generic_init,
+ ulaw_input,
+ ulaw_output
+
+ }, f_alaw = {
+ "A-law", "8 kHz, 8 bit A-law encoding", ".A",
+ generic_init,
+ generic_init,
+ alaw_input,
+ alaw_output
+
+ }, f_linear = {
+ "linear",
+ "16 bit (13 significant) signed 8 kHz signal", ".l",
+ generic_init,
+ generic_init,
+ linear_input,
+ linear_output
+ };
+
+ struct fmtdesc * alldescs[] = {
+ &f_audio,
+ &f_alaw,
+ &f_ulaw,
+ &f_linear,
+ (struct fmtdesc *)NULL
+ };
+
+ #define DEFAULT_FORMAT f_ulaw /* default audio format, others */
+ /* are: f_alaw,f_audio,f_linear */
+ struct fmtdesc * f_format = 0;
+
+ /*
+ * basename + suffix of a pathname
+ */
+ static char * endname P1((name), char * name)
+ {
+ if (name) {
+ char * s = strrchr(name, '/');
+ if (s && s[1]) name = s + 1;
+ }
+ return name;
+
+ }
+
+ /*
+ * Try to figure out what we're supposed to do from the argv[0], if
+ * any, and set the parameters accordingly.
+ */
+ static void parse_argv0 P1((av0), char * av0 )
+ {
+ int l;
+
+ progname = av0 = endname(av0 ? av0 : "toast");
+
+ /* If the name starts with `un', we want to decode, not code.
+ * If the name ends in `cat', we want to write to stdout,
+ * and decode as well.
+ */
+
+ if (!strncmp(av0, "un", 2)) f_decode = 1;
+ if ( (l = strlen(av0)) >= 3 /* strlen("cat") */
+ && !strcmp( av0 + l - 3, "cat" )) f_cat = f_decode = 1;
+ }
+
+
+ /*
+ * Check whether the name (possibly generated by appending
+ * .gsm to something else) is short enough for this system.
+ */
+ static int length_okay P1((name), char * name)
+ {
+ long max_filename_length = 0;
+ char * end;
+
+ /* If our _pathname_ is too long, we'll usually not be
+ * able to open the file at all -- don't worry about that.
+ *
+ * But if the _filename_ is too long, there is danger of
+ * silent truncation on some systems, which results
+ * in the target replacing the source!
+ */
+
+ if (!name) return 0;
+ end = endname(name);
+
+ #ifdef NAME_MAX
+ max_filename_length = NAME_MAX;
+ #else
+ #ifdef _PC_NAME_MAX
+ #ifdef USE_PATHCONF
+ { char * s, tmp;
+
+ /* s = dirname(name)
+ */
+ if ((s = end) > name) {
+ if (s > name + 1) s--;
+ tmp = s;
+ *s = 0;
+ }
+
+ errno = 0;
+ max_filename_length = pathconf(s > name ? name : ".",
+ _PC_NAME_MAX);
+ if (max_filename_length == -1 && errno) {
+ perror( s > name ? name : "." );
+ fprintf(stderr,
+ "%s: cannot get dynamic filename length limit for %s.\n",
+ progname, s > name ? name : ".");
+ return 0;
+ }
+ if (s > name) *s = tmp;
+ }
+ #endif /* USE_PATHCONF */
+ #endif /* _PC_NAME_MAX */
+ #endif /* !NAME_MAX */
+
+ if (max_filename_length > 0 && strlen(end) > max_filename_length) {
+ fprintf(stderr,
+ "%s: filename \"%s\" is too long (maximum is %ld)\n",
+ progname, endname(name), max_filename_length );
+ return 0;
+ }
+
+ return 1;
+ }
+
+ /*
+ * Return a pointer the suffix of a string, if any.
+ * A suffix alone has no suffix, an empty suffix can not be had.
+ */
+ static char * suffix P2((name, suf), char *name, char * suf)
+ {
+ size_t nlen = strlen(name);
+ size_t slen = strlen(suf);
+
+ if (!slen || nlen <= slen) return (char *)0;
+ name += nlen - slen;
+ return memcmp(name, suf, slen) ? (char *)0 : name;
+ }
+
+
+ static void catch_signals P1((fun), SIGHANDLER_T (*fun) ())
+ {
+ #ifdef SIGHUP
+ signal( SIGHUP, fun );
+ #endif
+ #ifdef SIGINT
+ signal( SIGINT, fun );
+ #endif
+ #ifdef SIGPIPE
+ signal( SIGPIPE, fun );
+ #endif
+ #ifdef SIGTERM
+ signal( SIGTERM, fun );
+ #endif
+ #ifdef SIGXFSZ
+ signal( SIGXFSZ, fun );
+ #endif
+ }
+
+ static SIGHANDLER_T onintr P0()
+ {
+ char * tmp = outname;
+
+ #ifdef HAS_SYSV_SIGNALS
+ catch_signals( SIG_IGN );
+ #endif
+
+ outname = (char *)0;
+ if (tmp) (void)unlink(tmp);
+
+ exit(1);
+ }
+
+ /*
+ * Allocate some memory and complain if it fails.
+ */
+ static char * emalloc P1((len), size_t len)
+ {
+ char * s;
+ if (!(s = malloc(len))) {
+ fprintf(stderr, "%s: failed to malloc %d bytes -- abort\n",
+ progname, len);
+ onintr();
+ exit(1);
+ }
+ return s;
+ }
+
+ static char* normalname P3((name, want, cut), char *name, char *want,char *cut)
+ {
+ size_t maxlen;
+ char * s, * p;
+
+ p = (char *)0;
+ if (!name) return p;
+
+ maxlen = strlen(name) + 1 + strlen(want) + strlen(cut);
+ p = strcpy(emalloc(maxlen), name);
+
+ if (s = suffix(p, cut)) strcpy(s, want);
+ else if (*want && !suffix(p, want)) strcat(p, want);
+
+ return p;
+ }
+
+ /*
+ * Generate a `plain' (non-encoded) name from a given name.
+ */
+ static char * plainname P1((name), char *name)
+ {
+ return normalname(name, "", SUFFIX_TOASTED );
+ }
+
+ /*
+ * Generate a `code' name (foo.Z) from a given name.
+ */
+ static char * codename P1((name), char *name)
+ {
+ return normalname( name, SUFFIX_TOASTED, "" );
+ }
+
+ /*
+ * If we're supposed to ask (fileno (stderr) is a tty, and f_force not
+ * set), ask the user whether to overwrite a file or not.
+ */
+ static int ok_to_replace P1(( name ), char * name)
+ {
+ int reply, c;
+
+ if (f_force) return 1; /* YES, do replace */
+ if (!isatty(fileno(stderr))) return 0; /* NO, don't replace */
+
+ fprintf(stderr,
+ "%s already exists; do you wish to overwrite %s (y or n)? ",
+ name, name);
+ fflush(stderr);
+
+ for (c = reply = getchar(); c != '\n' && c != EOF; c = getchar()) ;
+ if (reply == 'y') return 1;
+
+ fprintf(stderr, "\tnot overwritten\n");
+ return 0;
+ }
+
+ static void update_mode P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+
+ #ifdef HAS_FCHMOD
+ if (fchmod(fileno(out), instat.st_mode & 07777)) {
+ perror(outname);
+ fprintf(stderr, "%s: could not change file mode of \"%s\"\n",
+ progname, outname);
+ }
+ #else
+ if (outname && chmod(outname, instat.st_mode & 07777)) {
+ perror(outname);
+ fprintf(stderr, "%s: could not change file mode of \"%s\"\n",
+ progname, outname);
+ }
+ #endif /* HAS_FCHMOD */
+ }
+
+ static void update_own P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+ #ifdef HAS_FCHOWN
+ (void)fchown(fileno(out), instat.st_uid, instat.st_gid);
+ #else
+ (void)chown(outname, instat.st_uid, instat.st_gid);
+ #endif /* HAS_FCHOWN */
+ }
+
+ static void update_times P0()
+ {
+ if (!instat.st_nlink) return; /* couldn't stat in */
+
+ #ifdef HAS_UTIMES
+ if (outname) {
+ struct timeval tv[2];
+
+ tv[0].tv_sec = instat.st_atime;
+ tv[1].tv_sec = instat.st_mtime;
+ tv[0].tv_usec = tv[1].tv_usec = 0;
+ (void) utimes(outname, tv);
+ }
+ #else
+ #ifdef HAS_UTIME
+
+ if (outname) {
+
+ #ifdef HAS_UTIMBUF
+ struct utimbuf ut;
+
+ ut.actime = instat.st_atime;
+ ut.modtime = instat.st_mtime;
+
+ # ifdef HAS_UTIMEUSEC
+ ut.acusec = instat.st_ausec;
+ ut.modusec = instat.st_musec;
+ # endif /* HAS_UTIMEUSEC */
+
+ (void) utime(outname, &ut);
+
+ #else /* UTIMBUF */
+
+ time_t ut[2];
+
+ ut[0] = instat.st_atime;
+ ut[1] = instat.st_mtime;
+
+ (void) utime(outname, ut);
+
+ #endif /* UTIMBUF */
+ }
+ #endif /* HAS_UTIME */
+ #endif /* HAS_UTIMES */
+ }
+
+
+ static int okay_as_input P3((name,f,st), char* name, FILE* f, struct stat * st)
+ {
+ # ifdef HAS_FSTAT
+ if (fstat(fileno(f), st) < 0)
+ # else
+ if (stat(name, st) < 0)
+ # endif
+ {
+ perror(name);
+ fprintf(stderr, "%s: cannot stat \"%s\"\n", progname, name);
+ return 0;
+ }
+
+ if (!S_ISREG(st->st_mode)) {
+ fprintf(stderr,
+ "%s: \"%s\" is not a regular file -- unchanged.\n",
+ progname, name);
+ return 0;
+ }
+ if (st->st_nlink > 1 && !f_cat && !f_precious) {
+ fprintf(stderr,
+ "%s: \"%s\" has %s other link%s -- unchanged.\n",
+ progname,name,st->st_nlink - 1,"s" + (st->st_nlink<=2));
+ return 0;
+ }
+ return 1;
+ }
+
+ static void prepare_io P1(( desc), struct fmtdesc * desc)
+ {
+ output = desc->output;
+ input = desc->input;
+
+ init_input = desc->init_input;
+ init_output = desc->init_output;
+ }
+
+ static struct fmtdesc * grok_format P1((name), char * name)
+ {
+ char * c;
+ struct fmtdesc ** f;
+
+ if (name) {
+ c = plainname(name);
+
+ for (f = alldescs; *f; f++)
+ if ( (*f)->suffix
+ && *(*f)->suffix
+ && suffix(c, (*f)->suffix)) {
+
+ free(c);
+ return *f;
+ }
+
+ free(c);
+ }
+ return (struct fmtdesc *)0;
+ }
+
+ static int open_input P2((name, st), char * name, struct stat * st)
+ {
+ struct fmtdesc * f = f_format;
+
+ st->st_nlink = 0; /* indicates `undefined' value */
+ if (!name) {
+ inname = (char *)NULL;
+ in = stdin;
+ }
+ else {
+ if (f_decode) inname = codename(name);
+ else {
+ if (!f_cat && suffix(name, SUFFIX_TOASTED)) {
+ fprintf(stderr,
+ "%s: %s already has \"%s\" suffix -- unchanged.\n",
+ progname, name, SUFFIX_TOASTED );
+ return 0;
+ }
+ inname = strcpy(emalloc(strlen(name)+1), name);
+ }
+ if (!(in = fopen(inname, READ))) {
+ perror(inname); /* not guaranteed to be valid here */
+ fprintf(stderr, "%s: cannot open \"%s\" for reading\n",
+ progname, inname);
+ return 0;
+ }
+ if (!okay_as_input(inname, in, st)) return 0;
+ if (!f) f = grok_format(inname);
+ }
+ prepare_io( f ? f : & DEFAULT_FORMAT );
+ return 1;
+ }
+
+ static int open_output P1((name), char *name)
+ {
+ if (!name || f_cat) {
+ out = stdout;
+ outname = (char *)NULL;
+ }
+ else {
+ int outfd = -1;
+ char * o;
+
+ o = (*(f_decode ? plainname : codename))(name);
+ if (!length_okay(o)) return 0;
+ if ((outfd = open(o, O_WRITE_EXCL, 0666)) >= 0)
+ out = fdopen(outfd, WRITE);
+ else if (errno != EEXIST) out = (FILE *)NULL;
+ else if (ok_to_replace(o)) out = fopen(o, WRITE);
+ else return 0;
+
+ if (!out) {
+ perror(o);
+ fprintf(stderr,
+ "%s: can't open \"%s\" for writing\n",
+ progname, o);
+ if (outfd >= 0) (void)close(outfd);
+ return 0;
+ }
+
+ outname = o;
+ }
+ return 1;
+ }
+
+ static int process_encode P0()
+ {
+ gsm r;
+ gsm_signal s[ 160 ];
+ gsm_frame d;
+
+ int cc;
+
+ if (!(r = gsm_create())) {
+ perror(progname);
+ return -1;
+ }
+ (void)gsm_option(r, GSM_OPT_FAST, &f_fast);
+ (void)gsm_option(r, GSM_OPT_VERBOSE, &f_verbose);
+
+ while ((cc = (*input)(s)) > 0) {
+ if (cc < sizeof(s) / sizeof(*s))
+ memset((char *)(s+cc), 0, sizeof(s)-(cc * sizeof(*s)));
+ gsm_encode(r, s, d);
+ if (fwrite((char *)d, sizeof(d), 1, out) != 1) {
+ perror(outname ? outname : "stdout");
+ fprintf(stderr, "%s: error writing to %s\n",
+ progname, outname ? outname : "stdout");
+ gsm_destroy(r);
+ return -1;
+ }
+ }
+ if (cc < 0) {
+ perror(inname ? inname : "stdin");
+ fprintf(stderr, "%s: error reading from %s\n",
+ progname, inname ? inname : "stdin");
+ gsm_destroy(r);
+ return -1;
+ }
+ gsm_destroy(r);
+
+ return 0;
+ }
+
+ static int process_decode P0()
+ {
+ gsm r;
+ gsm_frame s;
+ gsm_signal d[ 160 ];
+
+ int cc;
+
+ if (!(r = gsm_create())) { /* malloc failed */
+ perror(progname);
+ return -1;
+ }
+ (void)gsm_option(r, GSM_OPT_FAST, &f_fast);
+ (void)gsm_option(r, GSM_OPT_VERBOSE, &f_verbose);
+
+ while ((cc = fread(s, 1, sizeof(s), in)) > 0) {
+
+ if (cc != sizeof(s)) {
+ if (cc >= 0) fprintf(stderr,
+ "%s: incomplete frame (%d byte%s missing) from %s\n",
+ progname, sizeof(s) - cc,
+ "s" + (sizeof(s) - cc == 1),
+ inname ? inname : "stdin" );
+ gsm_destroy(r);
+ errno = 0;
+ return -1;
+ }
+ if (gsm_decode(r, s, d)) {
+ fprintf(stderr, "%s: bad frame in %s\n",
+ progname, inname ? inname : "stdin");
+ gsm_destroy(r);
+ errno = 0;
+ return -1;
+ }
+
+ if ((*output)(d) < 0) {
+ perror(outname);
+ fprintf(stderr, "%s: error writing to %s\n",
+ progname, outname);
+ gsm_destroy(r);
+ return -1;
+ }
+ }
+
+ if (cc < 0) {
+ perror(inname ? inname : "stdin" );
+ fprintf(stderr, "%s: error reading from %s\n", progname,
+ inname ? inname : "stdin");
+ gsm_destroy(r);
+ return -1;
+ }
+
+ gsm_destroy(r);
+ return 0;
+ }
+
+ static int process P1((name), char * name)
+ {
+ int step = 0;
+
+ out = (FILE *)0;
+ in = (FILE *)0;
+
+ outname = (char *)0;
+ inname = (char *)0;
+
+ if (!open_input(name, &instat) || !open_output(name))
+ goto err;
+
+ if ((*(f_decode ? init_output : init_input))()) {
+ fprintf(stderr, "%s: error %s %s\n",
+ progname,
+ f_decode ? "writing header to" : "reading header from",
+ f_decode ? (outname ? outname : "stdout")
+ : (inname ? inname : "stdin"));
+ goto err;
+ }
+
+ if ((*(f_decode ? process_decode : process_encode))())
+ goto err;
+
+ if (fflush(out) < 0 || ferror(out)) {
+ perror(outname ? outname : "stdout");
+ fprintf(stderr, "%s: error writing \"%s\"\n", progname,
+ outname ? outname:"stdout");
+ goto err;
+ }
+
+ if (out != stdout) {
+
+ update_times();
+ update_mode ();
+ update_own ();
+
+ if (fclose(out) < 0) {
+ perror(outname);
+ fprintf(stderr, "%s: error writing \"%s\"\n",
+ progname, outname);
+ goto err;
+ }
+ if (outname != name) free(outname);
+ outname = (char *)0;
+ }
+ out = (FILE *)0;
+ if (in != stdin) {
+ (void)fclose(in), in = (FILE *)0;
+ if (!f_cat && !f_precious) {
+ if (unlink(inname) < 0) {
+ perror(inname);
+ fprintf(stderr,
+ "%s: source \"%s\" not deleted.\n",
+ progname, inname);
+ }
+ goto err;
+ }
+ if (inname != name) free(inname);
+ inname = (char *)0;
+ }
+ return 0;
+
+ /*
+ * Error handling and cleanup:
+ * - error out: close out, unlink it, close in, free the names.
+ * -
+ */
+ err:
+ if (out && out != stdout) {
+ (void)fclose(out), out = (FILE *)0;
+ if (unlink(outname) < 0 && errno != ENOENT && errno != EINTR) {
+ perror(outname);
+ fprintf(stderr, "%s: could not unlink \"%s\"\n",
+ progname, outname);
+ }
+ }
+ if (in && in != stdin) (void)fclose(in), in = (FILE *)0;
+
+ if (inname && inname != name) free(inname);
+ if (outname && outname != name) free(outname);
+
+ return -1;
+ }
+
+ static void version P0()
+ {
+ printf( "%s 1.0, version %s\n",
+ progname,
+ "$Id: toast.c,v 1.1 2007/01/09 23:44:35 lattner Exp $" );
+ }
+
+ static void help P0()
+ {
+ printf("Usage: %s [-fcpdhvaulsF] [files...]\n", progname);
+ printf("\n");
+
+ printf(" -f force Replace existing files without asking\n");
+ printf(" -c cat Write to stdout, do not remove source files\n");
+ printf(" -d decode Decode data (default is encode)\n");
+ printf(" -p precious Do not delete the source\n");
+ printf("\n");
+
+ printf(" -u u-law Force 8 kHz/8 bit u-law in/output format\n");
+ printf(" -s sun .au Force Sun .au u-law in/output format\n");
+ printf(" -a A-law Force 8 kHz/8 bit A-law in/output format\n");
+ printf(" -l linear Force 16 bit linear in/output format\n");
+ printf("\n");
+
+ printf(" -F fast Sacrifice conformance to performance\n");
+ printf(" -v version Show version information\n");
+ printf(" -h help Print this text\n");
+ printf("\n");
+ }
+
+
+ static void set_format P1((f), struct fmtdesc * f)
+ {
+ if (f_format && f_format != f) {
+ fprintf( stderr,
+ "%s: only one of -[uals] is possible (%s -h for help)\n",
+ progname, progname);
+ exit(1);
+ }
+
+ f_format = f;
+ }
+
+ int main P2((ac, av), int ac, char **av)
+ {
+ int opt;
+ extern int optind;
+
+ parse_argv0( *av );
+
+ while ((opt = getopt(ac, av, "fcdpvhuaslVF")) != EOF)
+ switch (opt) {
+
+ case 'd': f_decode = 1; break;
+ case 'f': f_force = 1; break;
+ case 'c': f_cat = 1; break;
+ case 'p': f_precious = 1; break;
+ case 'F': f_fast = 1; break;
+
+ #ifndef NDEBUG
+ case 'V': f_verbose = 1; break; /* undocumented */
+ #endif
+
+ case 'u': set_format( &f_ulaw ); break;
+ case 'l': set_format( &f_linear ); break;
+ case 'a': set_format( &f_alaw ); break;
+ case 's': set_format( &f_audio ); break;
+
+ case 'v': version(); exit(0);
+ case 'h': help(); exit(0);
+
+ default:
+ fprintf(stderr,
+ "Usage: %s [-fcpdhvuaslF] [files...] (-h for help)\n",
+ progname);
+ exit(1);
+ }
+
+ f_precious |= f_cat;
+
+ av += optind;
+ ac -= optind;
+
+ catch_signals(onintr);
+
+ if (ac <= 0) process( (char *)0 );
+ else while (ac--) process( *av++ );
+
+ exit(0);
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.h:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,105 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast.h,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #ifndef TOAST_H
+ #define TOAST_H /* Guard against multiple includes */
+
+ #include "config.h"
+
+ #include <sys/types.h>
+ #include <sys/stat.h>
+
+ #include <stdio.h>
+ #include <ctype.h>
+ #include <signal.h>
+
+ #include <errno.h>
+ #ifndef HAS_ERRNO_DECL
+ extern int errno;
+ #endif
+
+ #ifdef HAS_LIMITS_H
+ #include <limits.h>
+ #endif
+
+ #ifdef HAS_FCNTL_H
+ # include <fcntl.h>
+ #endif
+
+ #ifdef HAS_UTIME
+ # ifdef HAS_UTIME_H
+ # include <utime.h>
+ # endif
+ #endif
+
+ #include "gsm.h"
+
+ #ifndef S_ISREG
+ #define S_ISREG(x) ((x) & S_IFREG)
+ #endif /* S_ISREG */
+
+
+ # define READ "rb"
+ # define WRITE "wb"
+ # define O_WRITE_EXCL O_WRONLY|O_CREAT|O_EXCL
+
+ #ifndef SIGHANDLER_T
+ #define SIGHANDLER_T void /* what does a signal handler return? */
+ #endif
+
+
+ #ifdef HAS_STRING_H
+ #include <string.h>
+ #else
+ # ifdef HAS_STRINGS_H
+ # include <strings.h>
+ # else
+ # include "proto.h"
+
+ extern int strlen P((char *));
+ extern char * strcpy P((char *, char *));
+ extern char * strcat P((char *, char *));
+ extern char * strrchr P((char *, int));
+
+ # include "unproto.h"
+ # endif
+ #endif
+
+
+ #ifdef HAS_STDLIB_H
+ #include <stdlib.h>
+ #else
+ # include "proto.h"
+ # ifdef HAS_MALLOC_H
+ # include <malloc.h>
+ # else
+ extern char * malloc P((unsigned));
+ # endif
+ extern int exit P((int));
+ # include "unproto.h"
+ #endif
+
+
+ #ifdef HAS_UNISTD_H
+ # include <unistd.h>
+ #endif
+
+ /*
+ * This suffix is tacked onto/removed from filenames
+ * similar to the way freeze and compress do it.
+ */
+ #define SUFFIX_TOASTED ".gsm"
+
+ #include "proto.h"
+
+ extern int audio_init_input P((void)), audio_init_output P((void));
+ extern int ulaw_input P((gsm_signal*)), ulaw_output P((gsm_signal *));
+ extern int alaw_input P((gsm_signal*)), alaw_output P((gsm_signal *));
+ extern int linear_input P((gsm_signal*)), linear_output P((gsm_signal *));
+
+ #endif /* TOAST_H */
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_alaw.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_alaw.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_alaw.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,333 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_alaw.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "toast.h"
+
+ /* toast_alaw.c -- manipulate A-law encoded sound.
+ */
+
+ extern FILE * in, * out;
+
+ #define A2S(x) (a2s[ (unsigned char )(x) ])
+ #define S2A(x) (s2a[ ((unsigned short)(x)) >> 4 ])
+
+ static unsigned short a2s[] = {
+
+ 5120,60160, 320,65200,20480,44032, 1280,64192,
+ 2560,62848, 64,65456,10240,54784, 640,64864,
+ 7168,58112, 448,65072,28672,35840, 1792,63680,
+ 3584,61824, 192,65328,14336,50688, 896,64608,
+ 4096,61184, 256,65264,16384,48128, 1024,64448,
+ 2048,63360, 0,65520, 8192,56832, 512,64992,
+ 6144,59136, 384,65136,24576,39936, 1536,63936,
+ 3072,62336, 128,65392,12288,52736, 768,64736,
+ 5632,59648, 352,65168,22528,41984, 1408,64064,
+ 2816,62592, 96,65424,11264,53760, 704,64800,
+ 7680,57600, 480,65040,30720,33792, 1920,63552,
+ 3840,61568, 224,65296,15360,49664, 960,64544,
+ 4608,60672, 288,65232,18432,46080, 1152,64320,
+ 2304,63104, 32,65488, 9216,55808, 576,64928,
+ 6656,58624, 416,65104,26624,37888, 1664,63808,
+ 3328,62080, 160,65360,13312,51712, 832,64672,
+ 5376,59904, 336,65184,21504,43008, 1344,64128,
+ 2688,62720, 80,65440,10752,54272, 672,64832,
+ 7424,57856, 464,65056,29696,34816, 1856,63616,
+ 3712,61696, 208,65312,14848,50176, 928,64576,
+ 4352,60928, 272,65248,17408,47104, 1088,64384,
+ 2176,63232, 16,65504, 8704,56320, 544,64960,
+ 6400,58880, 400,65120,25600,38912, 1600,63872,
+ 3200,62208, 144,65376,12800,52224, 800,64704,
+ 5888,59392, 368,65152,23552,40960, 1472,64000,
+ 2944,62464, 112,65408,11776,53248, 736,64768,
+ 7936,57344, 496,65024,31744,32768, 1984,63488,
+ 3968,61440, 240,65280,15872,49152, 992,64512,
+ 4864,60416, 304,65216,19456,45056, 1216,64256,
+ 2432,62976, 48,65472, 9728,55296, 608,64896,
+ 6912,58368, 432,65088,27648,36864, 1728,63744,
+ 3456,61952, 176,65344,13824,51200, 864,64640
+ };
+
+
+ static unsigned char s2a[] = {
+
+ 170, 42,234,106,138, 10,202, 74,186, 58,250,122,154, 26,218, 90,
+ 162, 34,226, 98,130, 2,194, 66,178, 50,242,114,146, 18,210, 82,
+ 174, 46, 46,238,238,110,110,142,142, 14, 14,206,206, 78, 78,190,
+ 190, 62, 62,254,254,126,126,158,158, 30, 30,222,222, 94, 94,166,
+ 166, 38, 38, 38, 38,230,230,230,230,102,102,102,102,134,134,134,
+ 134, 6, 6, 6, 6,198,198,198,198, 70, 70, 70, 70,182,182,182,
+ 182, 54, 54, 54, 54,246,246,246,246,118,118,118,118,150,150,150,
+ 150, 22, 22, 22, 22,214,214,214,214, 86, 86, 86, 86,168,168,168,
+ 168, 40, 40, 40, 40, 40, 40, 40, 40,232,232,232,232,232,232,232,
+ 232,104,104,104,104,104,104,104,104,136,136,136,136,136,136,136,
+ 136, 8, 8, 8, 8, 8, 8, 8, 8,200,200,200,200,200,200,200,
+ 200, 72, 72, 72, 72, 72, 72, 72, 72,184,184,184,184,184,184,184,
+ 184, 56, 56, 56, 56, 56, 56, 56, 56,248,248,248,248,248,248,248,
+ 248,120,120,120,120,120,120,120,120,152,152,152,152,152,152,152,
+ 152, 24, 24, 24, 24, 24, 24, 24, 24,216,216,216,216,216,216,216,
+ 216, 88, 88, 88, 88, 88, 88, 88, 88,160,160,160,160,160,160,160,
+ 160, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32,224,224,224,224,224,224,224,224,224,224,224,224,224,224,224,
+ 224, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96,
+ 96,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,
+ 128, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,
+ 192, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+ 64,176,176,176,176,176,176,176,176,176,176,176,176,176,176,176,
+ 176, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
+ 48,240,240,240,240,240,240,240,240,240,240,240,240,240,240,240,
+ 240,112,112,112,112,112,112,112,112,112,112,112,112,112,112,112,
+ 112,144,144,144,144,144,144,144,144,144,144,144,144,144,144,144,
+ 144, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16,208,208,208,208,208,208,208,208,208,208,208,208,208,208,208,
+ 208, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
+ 80,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,
+ 172, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
+ 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44,
+ 44,236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,
+ 236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,236,
+ 236,108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,
+ 108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,108,
+ 108,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,
+ 140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,
+ 140, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+ 12,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+ 204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+ 204, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+ 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76,
+ 76,188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,
+ 188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,188,
+ 188, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
+ 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
+ 60,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,
+ 252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,252,
+ 252,124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,
+ 124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,124,
+ 124,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,
+ 156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,156,
+ 156, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+ 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+ 28,220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,
+ 220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,220,
+ 220, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92,
+ 92,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,
+ 164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,164,
+ 164, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,228,
+ 228,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,100,
+ 100,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,132,
+ 132, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,196,
+ 196, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+ 68,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,180,
+ 180, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
+ 52,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,244,
+ 244,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,116,
+ 116,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,148,
+ 148, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+ 20,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,212,
+ 212, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
+ 84, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
+ 85,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,213,
+ 213, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+ 21,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,149,
+ 149,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,
+ 117,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,245,
+ 245, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
+ 53,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+ 181, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
+ 69,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,197,
+ 197, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+ 5,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,133,
+ 133,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,101,
+ 101,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,229,
+ 229, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
+ 37,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,165,
+ 165, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
+ 93,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
+ 221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
+ 221, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29,157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,
+ 157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,157,
+ 157,125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,
+ 125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,125,
+ 125,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,
+ 253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,253,
+ 253, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
+ 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
+ 61,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+ 189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+ 189, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+ 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
+ 77,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,
+ 205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,
+ 205, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+ 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+ 13,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,
+ 141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,141,
+ 141,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+ 109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+ 109,237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,
+ 237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,237,
+ 237, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+ 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
+ 45,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,
+ 173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,
+ 173, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+ 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81, 81,
+ 81,209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,
+ 209, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+ 17,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,
+ 145,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,
+ 113,241,241,241,241,241,241,241,241,241,241,241,241,241,241,241,
+ 241, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
+ 49,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,
+ 177, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+ 65,193,193,193,193,193,193,193,193,193,193,193,193,193,193,193,
+ 193, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1,129,129,129,129,129,129,129,129,129,129,129,129,129,129,129,
+ 129, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
+ 97,225,225,225,225,225,225,225,225,225,225,225,225,225,225,225,
+ 225, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33,161,161,161,161,161,161,161,161,161,161,161,161,161,161,161,
+ 161, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89,
+ 89,217,217,217,217,217,217,217,217, 25, 25, 25, 25, 25, 25, 25,
+ 25,153,153,153,153,153,153,153,153,121,121,121,121,121,121,121,
+ 121,249,249,249,249,249,249,249,249, 57, 57, 57, 57, 57, 57, 57,
+ 57,185,185,185,185,185,185,185,185, 73, 73, 73, 73, 73, 73, 73,
+ 73,201,201,201,201,201,201,201,201, 9, 9, 9, 9, 9, 9, 9,
+ 9,137,137,137,137,137,137,137,137,105,105,105,105,105,105,105,
+ 105,233,233,233,233,233,233,233,233, 41, 41, 41, 41, 41, 41, 41,
+ 41,169,169,169,169,169,169,169,169, 87, 87, 87, 87, 87, 87, 87,
+ 87,215,215,215,215, 23, 23, 23, 23,151,151,151,151,119,119,119,
+ 119,247,247,247,247, 55, 55, 55, 55,183,183,183,183, 71, 71, 71,
+ 71,199,199,199,199, 7, 7, 7, 7,135,135,135,135,103,103,103,
+ 103,231,231,231,231, 39, 39, 39, 39,167,167,167,167, 95, 95, 95,
+ 95,223,223, 31, 31,159,159,127,127,255,255, 63, 63,191,191, 79,
+ 79,207,207, 15, 15,143,143,111,111,239,239, 47, 47,175,175, 83,
+ 83,211, 19,147,115,243, 51,179, 67,195, 3,131, 99,227, 35,163,
+ 91,219, 27,155,123,251, 59,187, 75,203, 11,139,107,235, 43,171
+ };
+
+ int alaw_input P1((buf), gsm_signal * buf)
+ {
+ int i, c;
+
+ for (i = 0; i < 160 && (c = fgetc(in)) != EOF; i++) buf[i] = A2S( c );
+ if (c == EOF && ferror(in)) return -1;
+ return i;
+ }
+
+ int alaw_output P1((buf), gsm_signal * buf)
+ {
+ int i;
+
+ for (i = 0; i < 160; i++, buf++)
+ if (fputc( S2A( *buf ), out) == EOF) return -1;
+ return 0;
+ }
+
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_audio.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_audio.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_audio.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,103 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_audio.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "toast.h"
+
+ /* toast_audio -- functions to manipulate SunOS audio files.
+ *
+ * This is reverse engineered from our present soundfiles
+ * and in no way portable, durable or aesthetically pleasing.
+ */
+
+ extern FILE * in, * out;
+ extern char * inname;
+ extern char * progname;
+
+ extern int (*output) P((gsm_signal *)),
+ (*input ) P((gsm_signal *));
+
+ extern int alaw_input P((gsm_signal *)),
+ ulaw_input P((gsm_signal *)),
+ linear_input P((gsm_signal *));
+
+ extern int ulaw_output P((gsm_signal *));
+
+ static int put_u32 P2((f, u), FILE * f, unsigned long u)
+ {
+ /* Write a 32-bit unsigned value msb first.
+ */
+ if ( putc( (char)((u>>24) & 0x0FF), f) == EOF
+ || putc( (char)((u>>16) & 0x0FF), f) == EOF
+ || putc( (char)((u>> 8) & 0x0FF), f) == EOF
+ || putc( (char)( u & 0x0FF), f) == EOF) return -1;
+
+ return 0;
+ }
+
+ static int get_u32 P2((f, up), FILE * f, unsigned long * up)
+ {
+ /* Read a 32-bit unsigned value msb first.
+ */
+ int i;
+ unsigned long u;
+
+ if ( (i = getc(f)) == EOF
+ || ((u = (unsigned char)i), (i = getc(f)) == EOF)
+ || ((u = (u<<8)|(unsigned char)i), (i = getc(f)) == EOF)
+ || ((u = (u<<8)|(unsigned char)i), (i = getc(f)) == EOF)) return -1;
+ *up = (u<<8)|(unsigned char)i;
+ return 0;
+ }
+
+ int audio_init_input P0()
+ {
+ unsigned long len, enc; /* unsigned 32 bits */
+
+ if ( fgetc(in) != '.'
+ || fgetc(in) != 's'
+ || fgetc(in) != 'n'
+ || fgetc(in) != 'd'
+ || get_u32( in, &len )
+ || get_u32( in, &enc ) /* skip this */
+ || get_u32( in, &enc )
+ || fseek(in, (long)(len - 4*4), 1) < 0) {
+ fprintf(stderr,
+ "%s: bad (missing?) header in Sun audio file \"%s\";\n\
+ Try one of -u, -a, -l instead (%s -h for help).\n",
+ progname, inname ? inname : "stdin", progname);
+ return -1;
+ }
+
+ switch (enc) {
+ case 1: input = ulaw_input; break;
+ case 2: input = alaw_input; break;
+ case 3: input = linear_input; break;
+ default:
+ fprintf(stderr,
+ "%s: warning: file format #%lu for %s not implemented, defaulting to u-law.\n",
+ progname, enc, inname);
+ input = ulaw_input;
+ break;
+ }
+ return 0;
+ }
+
+ int audio_init_output P0()
+ {
+ if ( fputs(".snd", out) == EOF
+ || put_u32(out, 32)
+ || put_u32(out, ~(unsigned long)0)
+ || put_u32(out, 1)
+ || put_u32(out, 8000)
+ || put_u32(out, 1)
+ || put_u32(out, 0)
+ || put_u32(out, 0)) return -1;
+
+ return 0;
+ }
+
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_lin.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_lin.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_lin.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,24 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_lin.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "toast.h"
+
+ /* toast_linear.c -- read and write 16 bit linear sound in host byte order.
+ */
+
+ extern FILE *in, *out;
+
+ int linear_input (buf) gsm_signal * buf;
+ {
+ return fread( (char *)buf, sizeof(*buf), 160, in );
+ }
+
+ int linear_output P1((buf), gsm_signal * buf)
+ {
+ return -( fwrite( (char *)buf, sizeof(*buf), 160, out ) != 160 );
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_ulaw.c
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_ulaw.c:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_ulaw.c Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,621 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /* $Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/toast_ulaw.c,v 1.1 2007/01/09 23:44:35 lattner Exp $ */
+
+ #include "toast.h"
+
+ /* toast_ulaw -- functions to manipulate u-law encoded sound.
+ */
+
+ extern FILE *in, *out;
+
+ #define U2S(x) (u2s[ (unsigned char)(x) ])
+ #define S2U(x) (s2u[ ((unsigned short)(x)) >> 3 ])
+
+ static unsigned short u2s[] = {
+ 33280, 34308, 35336, 36364, 37393, 38421, 39449, 40477,
+ 41505, 42534, 43562, 44590, 45618, 46647, 47675, 48703,
+ 49474, 49988, 50503, 51017, 51531, 52045, 52559, 53073,
+ 53587, 54101, 54616, 55130, 55644, 56158, 56672, 57186,
+ 57572, 57829, 58086, 58343, 58600, 58857, 59114, 59371,
+ 59628, 59885, 60142, 60399, 60656, 60913, 61171, 61428,
+ 61620, 61749, 61877, 62006, 62134, 62263, 62392, 62520,
+ 62649, 62777, 62906, 63034, 63163, 63291, 63420, 63548,
+ 63645, 63709, 63773, 63838, 63902, 63966, 64030, 64095,
+ 64159, 64223, 64287, 64352, 64416, 64480, 64544, 64609,
+ 64657, 64689, 64721, 64753, 64785, 64818, 64850, 64882,
+ 64914, 64946, 64978, 65010, 65042, 65075, 65107, 65139,
+ 65163, 65179, 65195, 65211, 65227, 65243, 65259, 65275,
+ 65291, 65308, 65324, 65340, 65356, 65372, 65388, 65404,
+ 65416, 65424, 65432, 65440, 65448, 65456, 65464, 65472,
+ 65480, 65488, 65496, 65504, 65512, 65520, 65528, 0,
+ 32256, 31228, 30200, 29172, 28143, 27115, 26087, 25059,
+ 24031, 23002, 21974, 20946, 19918, 18889, 17861, 16833,
+ 16062, 15548, 15033, 14519, 14005, 13491, 12977, 12463,
+ 11949, 11435, 10920, 10406, 9892, 9378, 8864, 8350,
+ 7964, 7707, 7450, 7193, 6936, 6679, 6422, 6165,
+ 5908, 5651, 5394, 5137, 4880, 4623, 4365, 4108,
+ 3916, 3787, 3659, 3530, 3402, 3273, 3144, 3016,
+ 2887, 2759, 2630, 2502, 2373, 2245, 2116, 1988,
+ 1891, 1827, 1763, 1698, 1634, 1570, 1506, 1441,
+ 1377, 1313, 1249, 1184, 1120, 1056, 992, 927,
+ 879, 847, 815, 783, 751, 718, 686, 654,
+ 622, 590, 558, 526, 494, 461, 429, 397,
+ 373, 357, 341, 325, 309, 293, 277, 261,
+ 245, 228, 212, 196, 180, 164, 148, 132,
+ 120, 112, 104, 96, 88, 80, 72, 64,
+ 56, 48, 40, 32, 24, 16, 8, 0
+ };
+
+ static unsigned char s2u[] = {
+ 0377,0376,0375,0374,0373,0372,0371,0370,0367,0366,0365,0364,0363,0362,0361,
+ 0360,0357,0357,0356,0356,0355,0355,0354,0354,0353,0353,0352,0352,0351,0351,
+ 0350,0350,0347,0347,0346,0346,0345,0345,0344,0344,0343,0343,0342,0342,0341,
+ 0341,0340,0340,0337,0337,0337,0337,0336,0336,0336,0336,0335,0335,0335,0335,
+ 0334,0334,0334,0334,0333,0333,0333,0333,0332,0332,0332,0332,0331,0331,0331,
+ 0331,0330,0330,0330,0330,0327,0327,0327,0327,0326,0326,0326,0326,0325,0325,
+ 0325,0325,0324,0324,0324,0324,0323,0323,0323,0323,0322,0322,0322,0322,0321,
+ 0321,0321,0321,0320,0320,0320,0320,0317,0317,0317,0317,0317,0317,0317,0317,
+ 0316,0316,0316,0316,0316,0316,0316,0316,0315,0315,0315,0315,0315,0315,0315,
+ 0315,0314,0314,0314,0314,0314,0314,0314,0314,0313,0313,0313,0313,0313,0313,
+ 0313,0313,0312,0312,0312,0312,0312,0312,0312,0312,0311,0311,0311,0311,0311,
+ 0311,0311,0311,0310,0310,0310,0310,0310,0310,0310,0310,0307,0307,0307,0307,
+ 0307,0307,0307,0307,0306,0306,0306,0306,0306,0306,0306,0306,0305,0305,0305,
+ 0305,0305,0305,0305,0305,0304,0304,0304,0304,0304,0304,0304,0304,0303,0303,
+ 0303,0303,0303,0303,0303,0303,0303,0302,0302,0302,0302,0302,0302,0302,0302,
+ 0301,0301,0301,0301,0301,0301,0301,0301,0300,0300,0300,0300,0300,0300,0300,
+ 0300,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,0277,
+ 0277,0277,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,0276,
+ 0276,0276,0276,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,0275,
+ 0275,0275,0275,0275,0274,0274,0274,0274,0274,0274,0274,0274,0274,0274,0274,
+ 0274,0274,0274,0274,0274,0273,0273,0273,0273,0273,0273,0273,0273,0273,0273,
+ 0273,0273,0273,0273,0273,0273,0272,0272,0272,0272,0272,0272,0272,0272,0272,
+ 0272,0272,0272,0272,0272,0272,0272,0271,0271,0271,0271,0271,0271,0271,0271,
+ 0271,0271,0271,0271,0271,0271,0271,0271,0270,0270,0270,0270,0270,0270,0270,
+ 0270,0270,0270,0270,0270,0270,0270,0270,0270,0267,0267,0267,0267,0267,0267,
+ 0267,0267,0267,0267,0267,0267,0267,0267,0267,0267,0266,0266,0266,0266,0266,
+ 0266,0266,0266,0266,0266,0266,0266,0266,0266,0266,0266,0265,0265,0265,0265,
+ 0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0265,0264,0264,0264,
+ 0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0264,0263,0263,
+ 0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0263,0262,
+ 0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,0262,
+ 0262,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,0261,
+ 0261,0261,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,0260,
+ 0260,0260,0260,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,
+ 0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,0257,
+ 0257,0257,0257,0257,0257,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,
+ 0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,0256,
+ 0256,0256,0256,0256,0256,0256,0256,0255,0255,0255,0255,0255,0255,0255,0255,
+ 0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,0255,
+ 0255,0255,0255,0255,0255,0255,0255,0255,0255,0254,0254,0254,0254,0254,0254,
+ 0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,
+ 0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0254,0253,0253,0253,0253,
+ 0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,
+ 0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0253,0252,0252,
+ 0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,
+ 0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,0252,
+ 0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,
+ 0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,0251,
+ 0251,0251,0251,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,
+ 0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,0250,
+ 0250,0250,0250,0250,0250,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,
+ 0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,0247,
+ 0247,0247,0247,0247,0247,0247,0247,0246,0246,0246,0246,0246,0246,0246,0246,
+ 0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,0246,
+ 0246,0246,0246,0246,0246,0246,0246,0246,0246,0245,0245,0245,0245,0245,0245,
+ 0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,
+ 0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0245,0244,0244,0244,0244,
+ 0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,
+ 0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0244,0243,0243,
+ 0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,
+ 0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,0243,
+ 0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,
+ 0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,0242,
+ 0242,0242,0242,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,
+ 0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,0241,
+ 0241,0241,0241,0241,0241,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,
+ 0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,0240,
+ 0240,0240,0240,0240,0240,0240,0240,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,
+ 0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0237,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,0236,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,0235,
+ 0235,0235,0235,0235,0235,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,0234,
+ 0234,0234,0234,0234,0234,0234,0234,0234,0234,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,
+ 0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0233,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,0232,
+ 0232,0232,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,0231,
+ 0231,0231,0231,0231,0231,0231,0231,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,
+ 0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0230,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,0227,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,0226,
+ 0226,0226,0226,0226,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,0225,
+ 0225,0225,0225,0225,0225,0225,0225,0225,0225,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,
+ 0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0224,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,0223,
+ 0223,0223,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,0222,
+ 0222,0222,0222,0222,0222,0222,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,
+ 0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0221,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,0220,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,0217,
+ 0217,0217,0217,0217,0217,0217,0217,0217,0217,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,0216,
+ 0216,0216,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,
+ 0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0215,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,0214,
+ 0214,0214,0214,0214,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,
+ 0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0213,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,0212,
+ 0212,0212,0212,0212,0212,0212,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,0211,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,0210,
+ 0210,0210,0210,0210,0210,0210,0210,0210,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,0207,
+ 0207,0207,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,
+ 0206,0206,0206,0206,0206,0206,0206,0206,0206,0206,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,0205,
+ 0205,0205,0205,0205,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,
+ 0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0204,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,0203,
+ 0203,0203,0203,0203,0203,0203,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,
+ 0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0202,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,0201,
+ 0201,0201,0201,0201,0201,0201,0201,0201,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,0200,
+ 0200,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,0000,
+ 0000,0000,0000,0000,0000,0000,0000,0000,0000,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,0001,
+ 0001,0001,0001,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,
+ 0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0002,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,0003,
+ 0003,0003,0003,0003,0003,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,
+ 0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0004,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,0005,
+ 0005,0005,0005,0005,0005,0005,0005,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,0006,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,0007,
+ 0007,0007,0007,0007,0007,0007,0007,0007,0007,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,0010,
+ 0010,0010,0010,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,
+ 0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0011,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,0012,
+ 0012,0012,0012,0012,0012,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,
+ 0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0013,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,0014,
+ 0014,0014,0014,0014,0014,0014,0014,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,0015,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,0016,
+ 0016,0016,0016,0016,0016,0016,0016,0016,0016,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,0017,
+ 0017,0017,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,0020,
+ 0020,0020,0020,0020,0020,0020,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,
+ 0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0021,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,0022,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,0023,
+ 0023,0023,0023,0023,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,0024,
+ 0024,0024,0024,0024,0024,0024,0024,0024,0024,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,
+ 0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0025,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,0026,
+ 0026,0026,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,0027,
+ 0027,0027,0027,0027,0027,0027,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,
+ 0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0030,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,0031,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,0032,
+ 0032,0032,0032,0032,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,0033,
+ 0033,0033,0033,0033,0033,0033,0033,0033,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,
+ 0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0034,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,0035,
+ 0035,0035,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,0036,
+ 0036,0036,0036,0036,0036,0036,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,
+ 0037,0037,0037,0037,0037,0037,0037,0037,0037,0037,0040,0040,0040,0040,0040,
+ 0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,
+ 0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0040,0041,0041,
+ 0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,
+ 0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,0041,
+ 0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,
+ 0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,0042,
+ 0042,0042,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,
+ 0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,0043,
+ 0043,0043,0043,0043,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,
+ 0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,0044,
+ 0044,0044,0044,0044,0044,0044,0045,0045,0045,0045,0045,0045,0045,0045,0045,
+ 0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,0045,
+ 0045,0045,0045,0045,0045,0045,0045,0045,0046,0046,0046,0046,0046,0046,0046,
+ 0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,
+ 0046,0046,0046,0046,0046,0046,0046,0046,0046,0046,0047,0047,0047,0047,0047,
+ 0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,
+ 0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0047,0050,0050,
+ 0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,
+ 0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,0050,
+ 0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,
+ 0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,0051,
+ 0051,0051,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,
+ 0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,0052,
+ 0052,0052,0052,0052,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,
+ 0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,0053,
+ 0053,0053,0053,0053,0053,0053,0054,0054,0054,0054,0054,0054,0054,0054,0054,
+ 0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,0054,
+ 0054,0054,0054,0054,0054,0054,0054,0054,0055,0055,0055,0055,0055,0055,0055,
+ 0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,
+ 0055,0055,0055,0055,0055,0055,0055,0055,0055,0055,0056,0056,0056,0056,0056,
+ 0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,
+ 0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0056,0057,0057,0057,
+ 0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,
+ 0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,0057,
+ 0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,0060,
+ 0060,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,0061,
+ 0061,0061,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,0062,
+ 0062,0062,0062,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,0063,
+ 0063,0063,0063,0063,0064,0064,0064,0064,0064,0064,0064,0064,0064,0064,0064,
+ 0064,0064,0064,0064,0064,0065,0065,0065,0065,0065,0065,0065,0065,0065,0065,
+ 0065,0065,0065,0065,0065,0065,0066,0066,0066,0066,0066,0066,0066,0066,0066,
+ 0066,0066,0066,0066,0066,0066,0066,0067,0067,0067,0067,0067,0067,0067,0067,
+ 0067,0067,0067,0067,0067,0067,0067,0067,0070,0070,0070,0070,0070,0070,0070,
+ 0070,0070,0070,0070,0070,0070,0070,0070,0070,0071,0071,0071,0071,0071,0071,
+ 0071,0071,0071,0071,0071,0071,0071,0071,0071,0071,0072,0072,0072,0072,0072,
+ 0072,0072,0072,0072,0072,0072,0072,0072,0072,0072,0072,0073,0073,0073,0073,
+ 0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0073,0074,0074,0074,
+ 0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0074,0075,0075,
+ 0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,0075,
+ 0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,0076,
+ 0076,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,0077,
+ 0077,0077,0100,0100,0100,0100,0100,0100,0100,0100,0101,0101,0101,0101,0101,
+ 0101,0101,0101,0102,0102,0102,0102,0102,0102,0102,0102,0103,0103,0103,0103,
+ 0103,0103,0103,0103,0104,0104,0104,0104,0104,0104,0104,0104,0105,0105,0105,
+ 0105,0105,0105,0105,0105,0106,0106,0106,0106,0106,0106,0106,0106,0107,0107,
+ 0107,0107,0107,0107,0107,0107,0110,0110,0110,0110,0110,0110,0110,0110,0111,
+ 0111,0111,0111,0111,0111,0111,0111,0112,0112,0112,0112,0112,0112,0112,0112,
+ 0113,0113,0113,0113,0113,0113,0113,0113,0114,0114,0114,0114,0114,0114,0114,
+ 0114,0115,0115,0115,0115,0115,0115,0115,0115,0116,0116,0116,0116,0116,0116,
+ 0116,0116,0117,0117,0117,0117,0117,0117,0117,0117,0120,0120,0120,0120,0121,
+ 0121,0121,0121,0122,0122,0122,0122,0123,0123,0123,0123,0124,0124,0124,0124,
+ 0125,0125,0125,0125,0126,0126,0126,0126,0127,0127,0127,0127,0130,0130,0130,
+ 0130,0131,0131,0131,0131,0132,0132,0132,0132,0133,0133,0133,0133,0134,0134,
+ 0134,0134,0135,0135,0135,0135,0136,0136,0136,0136,0137,0137,0137,0137,0140,
+ 0140,0141,0141,0142,0142,0143,0143,0144,0144,0145,0145,0146,0146,0147,0147,
+ 0150,0150,0150,0151,0151,0152,0152,0153,0153,0154,0154,0155,0155,0156,0156,
+ 0157,0157,0160,0161,0162,0163,0164,0165,0166,0167,0170,0171,0172,0173,0174,
+ 0175,0176
+ };
+
+ int ulaw_input P1((buf), gsm_signal * buf)
+ {
+ int i, c;
+
+ for (i = 0; i < 160 && (c = fgetc(in)) != EOF; i++) buf[i] = U2S(c);
+ if (c == EOF && ferror(in)) return -1;
+ return i;
+ }
+
+ int ulaw_output P1((buf), gsm_signal * buf)
+ {
+ int i;
+
+ for(i = 0; i < 160; i++, buf++)
+ if (fputc( (char)S2U( (unsigned short)*buf ), out) == EOF)
+ return -1;
+ return 0;
+ }
Index: llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/unproto.h
diff -c /dev/null llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/unproto.h:1.1
*** /dev/null Tue Jan 9 17:45:03 2007
--- llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/unproto.h Tue Jan 9 17:44:35 2007
***************
*** 0 ****
--- 1,23 ----
+ /*
+ * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
+ * Universitaet Berlin. See the accompanying file "COPYRIGHT" for
+ * details. THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
+ */
+
+ /*$Header: /var/cvs/llvm/llvm-test/MultiSource/Benchmarks/MiBench/telecomm-gsm/unproto.h,v 1.1 2007/01/09 23:44:35 lattner Exp $*/
+
+ #ifdef PROTO_H /* sic */
+ #undef PROTO_H
+
+ #undef P
+ #undef P0
+ #undef P1
+ #undef P2
+ #undef P3
+ #undef P4
+ #undef P5
+ #undef P6
+ #undef P7
+ #undef P8
+
+ #endif /* PROTO_H */
More information about the llvm-commits
mailing list