|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
00001 /* 00002 00003 Copyright (C) 2000, 2001 Silicon Graphics, Inc. All Rights Reserved. 00004 00005 This program is free software; you can redistribute it and/or modify it 00006 under the terms of version 2 of the GNU General Public License as 00007 published by the Free Software Foundation. 00008 00009 This program is distributed in the hope that it would be useful, but 00010 WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 00012 00013 Further, this software is distributed without any warranty that it is 00014 free of the rightful claim of any third person regarding infringement 00015 or the like. Any license provided herein, whether implied or 00016 otherwise, applies only to this software file. Patent licenses, if 00017 any, provided herein do not apply to combinations of this program with 00018 other software, or any other product whatsoever. 00019 00020 You should have received a copy of the GNU General Public License along 00021 with this program; if not, write the Free Software Foundation, Inc., 59 00022 Temple Place - Suite 330, Boston MA 02111-1307, USA. 00023 00024 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00025 Mountain View, CA 94043, or: 00026 00027 http://www.sgi.com 00028 00029 For further information regarding this notice, see: 00030 00031 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00032 00033 */ 00034 00035 00036 #include <stdio.h> 00037 #include "arith.h" 00038 #include "arith.internal.h" 00039 00040 #if !defined __sun && (!defined __STDC__ || !defined _CRAY || _RELEASE < 4) 00041 #error Must be compiled with gcc or Cray Standard C Compiler, version >= 4.0. 00042 #endif 00043 00044 #if defined _CRAY 00045 00046 typedef signed int SINT46; 00047 typedef unsigned int UINT46; 00048 typedef unsigned long UINT64; 00049 typedef signed long SINT64; 00050 00051 # define LS46(v) (*(SINT46*)v) 00052 # define LU46(v) (*(UINT46*)v) 00053 # define LS64(v) (*(SINT64*)v) 00054 # define LU64(v) (*(UINT64*)v) 00055 00056 #elif defined __sun 00057 00058 typedef unsigned long long int UINT64; 00059 typedef signed long long int SINT64; 00060 typedef signed long long int SINT46; 00061 00062 /* 00063 * The Sun needs these because data alignment issues prevent us from 00064 * casting AR_INT_64 addresses directly to SINT64 addresses and then 00065 * loading the pointed-to doubleword. 00066 */ 00067 SINT46 LS46(AR_INT_64 *vp) 00068 { 00069 return((((SINT46) vp->part1) << 48) | 00070 (((SINT46) vp->part2) << 32) | 00071 (((SINT46) vp->part3) << 16) | 00072 (((SINT46) vp->part4) )); 00073 } 00074 00075 SINT64 LS64(AR_INT_64 *vp) 00076 { 00077 return((((SINT64) vp->part1) << 48) | 00078 (((SINT64) vp->part2) << 32) | 00079 (((SINT64) vp->part3) << 16) | 00080 (((SINT64) vp->part4) )); 00081 } 00082 00083 UINT64 LU64(AR_INT_64 *vp) 00084 { 00085 return((((UINT64) vp->part1) << 48) | 00086 (((UINT64) vp->part2) << 32) | 00087 (((UINT64) vp->part3) << 16) | 00088 (((UINT64) vp->part4) )); 00089 } 00090 #endif 00091 00092 00093 AR_INT_64 cool_ints[] = 00094 { 00095 /* march a one bit though a positive 64-bit int */ 00096 {0x0000, 0x0000, 0x0000, 0x0000}, 00097 {0x0000, 0x0000, 0x0000, 0x0001}, 00098 {0x0000, 0x0000, 0x0000, 0x0002}, 00099 {0x0000, 0x0000, 0x0000, 0x0004}, 00100 {0x0000, 0x0000, 0x0000, 0x0010}, 00101 {0x0000, 0x0000, 0x0000, 0x0040}, 00102 {0x0000, 0x0000, 0x0000, 0x0100}, 00103 {0x0000, 0x0000, 0x0000, 0x0400}, 00104 {0x0000, 0x0000, 0x0000, 0x1000}, 00105 {0x0000, 0x0000, 0x0000, 0x4000}, 00106 {0x0000, 0x0000, 0x0001, 0x0000}, 00107 {0x0000, 0x0000, 0x0004, 0x0000}, 00108 {0x0000, 0x0000, 0x0010, 0x0000}, 00109 {0x0000, 0x0000, 0x0040, 0x0000}, 00110 {0x0000, 0x0000, 0x0100, 0x0000}, 00111 {0x0000, 0x0000, 0x0400, 0x0000}, 00112 {0x0000, 0x0000, 0x1000, 0x0000}, 00113 {0x0000, 0x0000, 0x4000, 0x0000}, 00114 {0x0000, 0x0001, 0x0000, 0x0000}, 00115 {0x0000, 0x0004, 0x0000, 0x0000}, 00116 {0x0000, 0x0010, 0x0000, 0x0000}, 00117 {0x0000, 0x0040, 0x0000, 0x0000}, 00118 {0x0000, 0x0100, 0x0000, 0x0000}, 00119 {0x0000, 0x0400, 0x0000, 0x0000}, 00120 {0x0000, 0x1000, 0x0000, 0x0000}, 00121 {0x0000, 0x4000, 0x0000, 0x0000}, 00122 {0x0001, 0x0000, 0x0000, 0x0000}, 00123 {0x0004, 0x0000, 0x0000, 0x0000}, 00124 {0x0010, 0x0000, 0x0000, 0x0000}, 00125 {0x0040, 0x0000, 0x0000, 0x0000}, 00126 {0x0100, 0x0000, 0x0000, 0x0000}, 00127 {0x0400, 0x0000, 0x0000, 0x0000}, 00128 {0x1000, 0x0000, 0x0000, 0x0000}, 00129 {0x2000, 0x0000, 0x0000, 0x0000}, 00130 {0x4000, 0x0000, 0x0000, 0x0000}, 00131 {0x8000, 0x0000, 0x0000, 0x0000}, 00132 00133 /* march a one bit though a negative 32/64-bit int */ 00134 {0x8000, 0x0000, 0x8000, 0x0000}, 00135 {0x8000, 0x0000, 0x8000, 0x0001}, 00136 {0x8000, 0x0000, 0x8000, 0x0002}, 00137 {0x8000, 0x0000, 0x8000, 0x0004}, 00138 {0x8000, 0x0000, 0x8000, 0x0010}, 00139 {0x8000, 0x0000, 0x8000, 0x0040}, 00140 {0x8000, 0x0000, 0x8000, 0x0100}, 00141 {0x8000, 0x0000, 0x8000, 0x0400}, 00142 {0x8000, 0x0000, 0x8000, 0x1000}, 00143 {0x8000, 0x0000, 0x8000, 0x4000}, 00144 {0x8000, 0x0000, 0x8001, 0x0000}, 00145 {0x8000, 0x0000, 0x8004, 0x0000}, 00146 {0x8000, 0x0000, 0x8010, 0x0000}, 00147 {0x8000, 0x0000, 0x8040, 0x0000}, 00148 {0x8000, 0x0000, 0x8100, 0x0000}, 00149 {0x8000, 0x0000, 0x8400, 0x0000}, 00150 {0x8000, 0x0000, 0x9000, 0x0000}, 00151 {0x8000, 0x0000, 0xc000, 0x0000}, 00152 {0x8000, 0x0001, 0x0000, 0x0000}, 00153 {0x8000, 0x0004, 0x0000, 0x0000}, 00154 {0x8000, 0x0010, 0x0000, 0x0000}, 00155 {0x8000, 0x0040, 0x0000, 0x0000}, 00156 {0x8000, 0x0100, 0x0000, 0x0000}, 00157 {0x8000, 0x0400, 0x0000, 0x0000}, 00158 {0x8000, 0x1000, 0x0000, 0x0000}, 00159 {0x8000, 0x4000, 0x0000, 0x0000}, 00160 {0x8001, 0x0000, 0x0000, 0x0000}, 00161 {0x8004, 0x0000, 0x0000, 0x0000}, 00162 {0x8010, 0x0000, 0x0000, 0x0000}, 00163 {0x8040, 0x0000, 0x0000, 0x0000}, 00164 {0x8100, 0x0000, 0x0000, 0x0000}, 00165 {0x8400, 0x0000, 0x0000, 0x0000}, 00166 {0x9000, 0x0000, 0x0000, 0x0000}, 00167 {0xa000, 0x0000, 0x0000, 0x0000}, 00168 {0xc000, 0x0000, 0x0000, 0x0000}, 00169 00170 /* shift 64 one bits through a 64-bit positive int */ 00171 /* {0x0000, 0x0000, 0x0000, 0x0001}, */ /* already have this one */ 00172 {0x0000, 0x0000, 0x0000, 0x0003}, 00173 {0x0000, 0x0000, 0x0000, 0x0007}, 00174 {0x0000, 0x0000, 0x0000, 0x000f}, 00175 {0x0000, 0x0000, 0x0000, 0x003f}, 00176 {0x0000, 0x0000, 0x0000, 0x00ff}, 00177 {0x0000, 0x0000, 0x0000, 0x03ff}, 00178 {0x0000, 0x0000, 0x0000, 0x0fff}, 00179 {0x0000, 0x0000, 0x0000, 0x3fff}, 00180 {0x0000, 0x0000, 0x0000, 0xffff}, 00181 {0x0000, 0x0000, 0x0003, 0xffff}, 00182 {0x0000, 0x0000, 0x000f, 0xffff}, 00183 {0x0000, 0x0000, 0x003f, 0xffff}, 00184 {0x0000, 0x0000, 0x00ff, 0xffff}, 00185 {0x0000, 0x0000, 0x03ff, 0xffff}, 00186 {0x0000, 0x0000, 0x0fff, 0xffff}, 00187 {0x0000, 0x0000, 0x3fff, 0xffff}, 00188 {0x0000, 0x0000, 0xffff, 0xffff}, 00189 {0x0000, 0x0003, 0xffff, 0xffff}, 00190 {0x0000, 0x000f, 0xffff, 0xffff}, 00191 {0x0000, 0x003f, 0xffff, 0xffff}, 00192 {0x0000, 0x00ff, 0xffff, 0xffff}, 00193 {0x0000, 0x03ff, 0xffff, 0xffff}, 00194 {0x0000, 0x0fff, 0xffff, 0xffff}, 00195 {0x0000, 0x3fff, 0xffff, 0xffff}, 00196 {0x0000, 0xffff, 0xffff, 0xffff}, 00197 {0x0003, 0xffff, 0xffff, 0xffff}, 00198 {0x000f, 0xffff, 0xffff, 0xffff}, 00199 {0x003f, 0xffff, 0xffff, 0xffff}, 00200 {0x00ff, 0xffff, 0xffff, 0xffff}, 00201 {0x03ff, 0xffff, 0xffff, 0xffff}, 00202 {0x0fff, 0xffff, 0xffff, 0xffff}, 00203 {0x3fff, 0xffff, 0xffff, 0xffff}, 00204 {0x7fff, 0xffff, 0xffff, 0xfffe}, 00205 {0x7fff, 0xffff, 0xffff, 0xfff8}, 00206 {0x7fff, 0xffff, 0xffff, 0xffe0}, 00207 {0x7fff, 0xffff, 0xffff, 0xff80}, 00208 {0x7fff, 0xffff, 0xffff, 0xfe00}, 00209 {0x7fff, 0xffff, 0xffff, 0xf800}, 00210 {0x7fff, 0xffff, 0xffff, 0xe000}, 00211 {0x7fff, 0xffff, 0xffff, 0x8000}, 00212 {0x7fff, 0xffff, 0xfffe, 0x0000}, 00213 {0x7fff, 0xffff, 0xfff8, 0x0000}, 00214 {0x7fff, 0xffff, 0xffe0, 0x0000}, 00215 {0x7fff, 0xffff, 0xff80, 0x0000}, 00216 {0x7fff, 0xffff, 0xfe00, 0x0000}, 00217 {0x7fff, 0xffff, 0xf800, 0x0000}, 00218 {0x7fff, 0xffff, 0xe000, 0x0000}, 00219 {0x7fff, 0xffff, 0x8000, 0x0000}, 00220 {0x7fff, 0xfffe, 0x0000, 0x0000}, 00221 {0x7fff, 0xfff8, 0x0000, 0x0000}, 00222 {0x7fff, 0xffe0, 0x0000, 0x0000}, 00223 {0x7fff, 0xff80, 0x0000, 0x0000}, 00224 {0x7fff, 0xfe00, 0x0000, 0x0000}, 00225 {0x7fff, 0xf800, 0x0000, 0x0000}, 00226 {0x7fff, 0xe000, 0x0000, 0x0000}, 00227 {0x7fff, 0x8000, 0x0000, 0x0000}, 00228 {0x7ffe, 0x0000, 0x0000, 0x0000}, 00229 {0x7ff8, 0x0000, 0x0000, 0x0000}, 00230 {0x7fe0, 0x0000, 0x0000, 0x0000}, 00231 {0x7f80, 0x0000, 0x0000, 0x0000}, 00232 {0x7e00, 0x0000, 0x0000, 0x0000}, 00233 {0x7800, 0x0000, 0x0000, 0x0000}, 00234 {0x7000, 0x0000, 0x0000, 0x0000}, 00235 {0x6000, 0x0000, 0x0000, 0x0000}, 00236 {0x4000, 0x0000, 0x0000, 0x0000}, 00237 00238 /* shift 64 one bits through a 64-bit negative int */ 00239 {0x8000, 0x0000, 0x0000, 0x0001}, 00240 {0x8000, 0x0000, 0x0000, 0x0003}, 00241 {0x8000, 0x0000, 0x0000, 0x0007}, 00242 {0x8000, 0x0000, 0x0000, 0x000f}, 00243 {0x8000, 0x0000, 0x0000, 0x001f}, 00244 {0x8000, 0x0000, 0x0000, 0x007f}, 00245 {0x8000, 0x0000, 0x0000, 0x01ff}, 00246 {0x8000, 0x0000, 0x0000, 0x07ff}, 00247 {0x8000, 0x0000, 0x0000, 0x1fff}, 00248 {0x8000, 0x0000, 0x0000, 0x7fff}, 00249 {0x8000, 0x0000, 0x0001, 0xffff}, 00250 {0x8000, 0x0000, 0x0007, 0xffff}, 00251 {0x8000, 0x0000, 0x001f, 0xffff}, 00252 {0x8000, 0x0000, 0x007f, 0xffff}, 00253 {0x8000, 0x0000, 0x01ff, 0xffff}, 00254 {0x8000, 0x0000, 0x07ff, 0xffff}, 00255 {0x8000, 0x0000, 0x1fff, 0xffff}, 00256 {0x8000, 0x0000, 0x7fff, 0xffff}, 00257 {0x8000, 0x0001, 0xffff, 0xffff}, 00258 {0x8000, 0x0007, 0xffff, 0xffff}, 00259 {0x8000, 0x001f, 0xffff, 0xffff}, 00260 {0x8000, 0x007f, 0xffff, 0xffff}, 00261 {0x8000, 0x01ff, 0xffff, 0xffff}, 00262 {0x8000, 0x07ff, 0xffff, 0xffff}, 00263 {0x8000, 0x1fff, 0xffff, 0xffff}, 00264 {0x8000, 0x7fff, 0xffff, 0xffff}, 00265 {0x8001, 0xffff, 0xffff, 0xffff}, 00266 {0x8007, 0xffff, 0xffff, 0xffff}, 00267 {0x801f, 0xffff, 0xffff, 0xffff}, 00268 {0x807f, 0xffff, 0xffff, 0xffff}, 00269 {0x81ff, 0xffff, 0xffff, 0xffff}, 00270 {0x87ff, 0xffff, 0xffff, 0xffff}, 00271 {0x9fff, 0xffff, 0xffff, 0xffff}, 00272 {0xffff, 0xffff, 0xffff, 0xffff}, 00273 {0xffff, 0xffff, 0xffff, 0xfffc}, 00274 {0xffff, 0xffff, 0xffff, 0xfff0}, 00275 {0xffff, 0xffff, 0xffff, 0xffc0}, 00276 {0xffff, 0xffff, 0xffff, 0xff00}, 00277 {0xffff, 0xffff, 0xffff, 0xfc00}, 00278 {0xffff, 0xffff, 0xffff, 0xf000}, 00279 {0xffff, 0xffff, 0xffff, 0xc000}, 00280 {0xffff, 0xffff, 0xffff, 0x0000}, 00281 {0xffff, 0xffff, 0xfffc, 0x0000}, 00282 {0xffff, 0xffff, 0xfff0, 0x0000}, 00283 {0xffff, 0xffff, 0xffc0, 0x0000}, 00284 {0xffff, 0xffff, 0xff00, 0x0000}, 00285 {0xffff, 0xffff, 0xfc00, 0x0000}, 00286 {0xffff, 0xffff, 0xf000, 0x0000}, 00287 {0xffff, 0xffff, 0xc000, 0x0000}, 00288 {0xffff, 0xffff, 0x0000, 0x0000}, 00289 {0xffff, 0xfffc, 0x0000, 0x0000}, 00290 {0xffff, 0xfff0, 0x0000, 0x0000}, 00291 {0xffff, 0xffc0, 0x0000, 0x0000}, 00292 {0xffff, 0xff00, 0x0000, 0x0000}, 00293 {0xffff, 0xfc00, 0x0000, 0x0000}, 00294 {0xffff, 0xf000, 0x0000, 0x0000}, 00295 {0xffff, 0xc000, 0x0000, 0x0000}, 00296 {0xffff, 0x0000, 0x0000, 0x0000}, 00297 {0xfffc, 0x0000, 0x0000, 0x0000}, 00298 {0xfff0, 0x0000, 0x0000, 0x0000}, 00299 {0xffc0, 0x0000, 0x0000, 0x0000}, 00300 {0xff00, 0x0000, 0x0000, 0x0000}, 00301 {0xfc00, 0x0000, 0x0000, 0x0000}, 00302 {0xf000, 0x0000, 0x0000, 0x0000}, 00303 {0xe000, 0x0000, 0x0000, 0x0000}, 00304 {0xc000, 0x0000, 0x0000, 0x0000} 00305 }; 00306 int num_cool_ints = sizeof(cool_ints)/sizeof(AR_INT_64); 00307 00308 00309 AR_INT_64 dshift_vals[] = 00310 { 00311 {0x0000, 0x0000, 0x0000, 0x0000}, /* 0 */ 00312 {0x0000, 0x0000, 0x0000, 0x0001}, /* 1 */ 00313 {0x0000, 0x0000, 0x0000, 0x000a}, /* 10 */ 00314 {0x0000, 0x0000, 0x0000, 0x0010}, /* 16 */ 00315 {0x0000, 0x0000, 0x0000, 0x0015}, /* 20 */ 00316 {0x0000, 0x0000, 0x0000, 0x001f}, /* 31 */ 00317 {0x0000, 0x0000, 0x0000, 0x0020}, /* 32 */ 00318 {0x0000, 0x0000, 0x0000, 0x0021}, /* 33 */ 00319 {0x0000, 0x0000, 0x0000, 0x002b}, /* 44 */ 00320 {0x0000, 0x0000, 0x0000, 0x003f}, /* 63 */ 00321 {0x0000, 0x0000, 0x0000, 0x0040}, /* 64 */ 00322 {0x0000, 0x0000, 0x0000, 0x0041}, /* 65 */ 00323 {0xffff, 0xffff, 0xffff, 0xffff} /* -1 */ 00324 }; 00325 int num_dshift_vals = sizeof(dshift_vals)/sizeof(AR_INT_64); 00326 00327 00328 AR_TYPE ar_types[] = 00329 { 00330 AR_Int_8_S, 00331 AR_Int_8_U, 00332 AR_Int_16_S, 00333 AR_Int_16_U, 00334 AR_Int_24_S, 00335 AR_Int_24_U, 00336 AR_Int_32_S, 00337 AR_Int_32_U, 00338 AR_Int_46_S, 00339 AR_Int_64_S, 00340 AR_Int_64_U 00341 }; 00342 int num_ar_types = sizeof(ar_types) / sizeof(AR_TYPE); 00343 00344 #define IS_SUPPORTED_INT_TYPE(t) \ 00345 ((t) == AR_Int_8_S || (t) == AR_Int_8_U || \ 00346 (t) == AR_Int_16_S || (t) == AR_Int_16_U || \ 00347 (t) == AR_Int_32_S || (t) == AR_Int_32_U || \ 00348 (t) == AR_Int_46_S || \ 00349 (t) == AR_Int_64_S || (t) == AR_Int_64_U) 00350 00351 AR_TYPE sint8_artype = AR_Int_8_S; 00352 AR_TYPE uint8_artype = AR_Int_8_U; 00353 AR_TYPE sint16_artype = AR_Int_16_S; 00354 AR_TYPE uint16_artype = AR_Int_16_U; 00355 AR_TYPE sint24_artype = AR_Int_24_S; 00356 AR_TYPE uint24_artype = AR_Int_24_U; 00357 AR_TYPE sint32_artype = AR_Int_32_S; 00358 AR_TYPE uint32_artype = AR_Int_32_U; 00359 AR_TYPE sint46_artype = AR_Int_46_S; 00360 AR_TYPE sint64_artype = AR_Int_64_S; 00361 AR_TYPE uint64_artype = AR_Int_64_U; 00362 00363 SINT64 act_result [sizeof(cool_ints)/sizeof(AR_INT_64)]; 00364 int act_status [sizeof(cool_ints)/sizeof(AR_INT_64)]; 00365 00366 AR_INT_64 test_result[sizeof(cool_ints)/sizeof(AR_INT_64)]; 00367 int test_status[sizeof(cool_ints)/sizeof(AR_INT_64)]; 00368 00369 00370 /*======================================== 00371 * 00372 * SUN SUPPORT 00373 */ 00374 #if defined __sun 00375 /* 00376 * On the Sun, these are not intrinsics. Also, the Sun 64 bit ("long 00377 * long") shift code is limited to shifting by 0 .. 63 bits, so shift 00378 * counts of 64, and some of those of 0, have to be handled specially. 00379 */ 00380 static SINT64 _dshiftl(SINT64 op1, SINT64 op2, SINT64 shcnt) 00381 { 00382 SINT64 rshcnt = ((SINT64) 64) - shcnt; 00383 00384 if (shcnt == 0) 00385 return(op1); 00386 else if (shcnt == 64) 00387 return(op2); 00388 return((op1 << shcnt) | (((UINT64) op2) >> rshcnt)); 00389 } 00390 00391 static SINT64 _dshiftr(SINT64 op1, SINT64 op2, SINT64 shcnt) 00392 { 00393 SINT64 rshcnt = ((SINT64) 64) - shcnt; 00394 00395 if (shcnt == 0) 00396 return(op2); 00397 else if (shcnt == 64) 00398 return(op1); 00399 return((op1 << rshcnt) | (((UINT64) op2) >> shcnt)); 00400 } 00401 00402 static UINT64 shftl64(UINT64 op, SINT64 shcnt) 00403 { 00404 if (shcnt == 0) 00405 return(op); 00406 else if (shcnt == 64) 00407 return(0); 00408 return(op << shcnt); 00409 } 00410 00411 static UINT64 shftr64(UINT64 op, SINT64 shcnt) 00412 { 00413 if (shcnt == 0) 00414 return(op); 00415 else if (shcnt == 64) 00416 return(0); 00417 return(op >> shcnt); 00418 } 00419 00420 static SINT64 _mask(SINT64 bits) 00421 { 00422 /* 00423 * Kludge time ... 00424 * 00425 * Gcc 2.6.3 apparently has a bug, in that (~((UINT64) 0)) does 00426 * not, in fact generate 0xFFFFFFFFFFFFFFFF. Instead, it makes 00427 * a 0x00000000FFFFFFFF. The following is used to generate the 00428 * correct value instead. I would recommend switching to Sun's 00429 * unbundled ANSI cc, but it only #defines __STC__ as 1 when a 00430 * -Xc (strict ANSI compliance) switch is given, and in that 00431 * mode, it doesn't allow the "long long" types. 00432 */ 00433 union 00434 { 00435 AR_INT_64 u64p; 00436 UINT64 u64w; 00437 } u; 00438 00439 u.u64p.part1 = u.u64p.part2 = u.u64p.part3 = u.u64p.part4 = 0xFFFF; 00440 00441 if (bits > 0 && bits <= 63) 00442 return((SINT64) (u.u64w << (((SINT64) 64) - bits))); 00443 else if (bits >= 64 && bits < 128) 00444 return((SINT64) (u.u64w >> (bits - ((SINT64) 64)))); 00445 return(0); 00446 } 00447 00448 static SINT64 _leadz(SINT64 val) 00449 { 00450 int lz_bits; 00451 00452 if (val == 0) 00453 return(64); 00454 for (lz_bits = 0; val > 0; val <<= 1, lz_bits++) 00455 ; 00456 return((SINT64) lz_bits); 00457 } 00458 00459 static SINT64 _popcnt(SINT64 val) 00460 { 00461 int pop_bits, bit_count; 00462 00463 for (pop_bits = bit_count = 0; 00464 bit_count < 64; 00465 pop_bits += val & 0x1, val >>= 1, bit_count++) 00466 ; 00467 return((SINT64) pop_bits); 00468 } 00469 00470 static SINT64 _poppar(SINT64 val) 00471 { 00472 return(_popcnt(val) & ((SINT64) 0x1)); 00473 } 00474 #endif 00475 00476 00477 /*======================================== 00478 * 00479 * 8-BIT SUPPORT 00480 */ 00481 00482 /* 00483 * These un-sign-extend and sign-extend 8 bit values stored in 00484 * 64 bit integers. 00485 */ 00486 SINT64 DSEXT8(SINT64 v) 00487 { 00488 return(v & 0xFF); 00489 } 00490 00491 SINT64 SEXT8(SINT64 v) 00492 { 00493 return((( - ((v >> 7) & 0x1)) << 8) | DSEXT8(v)); 00494 } 00495 00496 00497 /* 00498 * These load a 8 bit value and if necessary sign extend it to 8 bits. 00499 */ 00500 SINT64 LS8(AR_INT_64 *vp) 00501 { 00502 return(SEXT8((UINT64) (vp->part4 & 0xFF))); 00503 } 00504 00505 UINT64 LU8(AR_INT_64 *vp) 00506 { 00507 return((UINT64) (vp->part4 & 0xFF)); 00508 } 00509 00510 00511 /* 00512 * This determines whether or not 8-bit values are zero/negative. 00513 */ 00514 #define is_zero8(v) (DSEXT8(v) == 0) 00515 #define is_neg8(v) (((v) & 0x80) != 0) 00516 00517 00518 /* 00519 * New 8-bit equivalents to the 64-bit intrinsics. 00520 */ 00521 static SINT64 _dshiftl8(SINT64 op1, SINT64 op2, SINT64 shcnt) 00522 { 00523 SINT64 rshcnt = ((SINT64) 8) - shcnt; 00524 00525 op2 &= 0xFF; 00526 return(((op1 << shcnt) | (op2 >> rshcnt)) & 0xFF); 00527 } 00528 00529 static SINT64 _dshiftr8(SINT64 op1, SINT64 op2, SINT64 shcnt) 00530 { 00531 SINT64 rshcnt = ((SINT64) 8) - shcnt; 00532 00533 op2 &= 0xFF; 00534 return(((op1 << rshcnt) | (op2 >> shcnt)) & 0xFF); 00535 } 00536 00537 static SINT64 _mask8(SINT64 bits) 00538 { 00539 bits &= 0xFF; 00540 if (bits > 0 && bits < 8) 00541 return((SINT64) ((0xFF << (((SINT64) 8) - bits)) & 0xFF)); 00542 else if (bits >= 8 && bits < 16) 00543 return((SINT64) (((UINT64) 0xFF) >> (bits - 8))); 00544 return(0); 00545 } 00546 00547 static SINT64 _leadz8(SINT64 val) 00548 { 00549 int lz_bits; 00550 00551 val <<= 56; 00552 if (val == 0) 00553 return(8); 00554 for (lz_bits = 0; val >= 0; val <<= 1) { 00555 lz_bits++; 00556 } 00557 return((SINT64) lz_bits); 00558 } 00559 00560 static SINT64 _popcnt8(SINT64 val) 00561 { 00562 int pop_bits, bit_count; 00563 00564 for (pop_bits = bit_count = 0; 00565 bit_count < 8; 00566 pop_bits += val & 0x1, val >>= 1, bit_count++) 00567 ; 00568 return((SINT64) pop_bits); 00569 } 00570 00571 static SINT64 _poppar8(SINT64 val) 00572 { 00573 return(_popcnt8(val) & ((SINT64) 0x1)); 00574 } 00575 00576 00577 /*======================================== 00578 * 00579 * 16-BIT SUPPORT 00580 */ 00581 00582 /* 00583 * These un-sign-extend and sign-extend 16 bit values stored in 00584 * 64 bit integers. 00585 */ 00586 SINT64 DSEXT16(SINT64 v) 00587 { 00588 return(v & 0xFFFF); 00589 } 00590 00591 SINT64 SEXT16(SINT64 v) 00592 { 00593 return((( - ((v >> 15) & 0x1)) << 16) | DSEXT16(v)); 00594 } 00595 00596 00597 /* 00598 * These load a 16 bit value and if necessary sign extend it to 16 bits. 00599 */ 00600 SINT64 LS16(AR_INT_64 *vp) 00601 { 00602 return(SEXT16((UINT64) vp->part4)); 00603 } 00604 00605 UINT64 LU16(AR_INT_64 *vp) 00606 { 00607 return((UINT64) vp->part4); 00608 } 00609 00610 00611 /* 00612 * This determines whether or not 16-bit values are zero/negative. 00613 */ 00614 #define is_zero16(v) (DSEXT16(v) == 0) 00615 #define is_neg16(v) (((v) & 0x8000) != 0) 00616 00617 00618 /* 00619 * New 16-bit equivalents to the 64-bit intrinsics. 00620 */ 00621 static SINT64 _dshiftl16(SINT64 op1, SINT64 op2, SINT64 shcnt) 00622 { 00623 SINT64 rshcnt = ((SINT64) 16) - shcnt; 00624 00625 op2 &= 0xFFFF; 00626 return(((op1 << shcnt) | (op2 >> rshcnt)) & 0xFFFF); 00627 } 00628 00629 static SINT64 _dshiftr16(SINT64 op1, SINT64 op2, SINT64 shcnt) 00630 { 00631 SINT64 rshcnt = ((SINT64) 16) - shcnt; 00632 00633 op2 &= 0xFFFF; 00634 return(((op1 << rshcnt) | (op2 >> shcnt)) & 0xFFFF); 00635 } 00636 00637 static SINT64 _mask16(SINT64 bits) 00638 { 00639 bits &= 0xFFFF; 00640 if (bits > 0 && bits < 16) 00641 return((SINT64) ((0xFFFF << (((SINT64) 16) - bits)) & 0xFFFF)); 00642 else if (bits >= 16 && bits < 32) 00643 return((SINT64) (((UINT64) 0xFFFF) >> (bits - 16))); 00644 return(0); 00645 } 00646 00647 static SINT64 _leadz16(SINT64 val) 00648 { 00649 int lz_bits; 00650 00651 val <<= 48; 00652 if (val == 0) 00653 return(16); 00654 for (lz_bits = 0; val >= 0; val <<= 1) { 00655 lz_bits++; 00656 } 00657 return((SINT64) lz_bits); 00658 } 00659 00660 static SINT64 _popcnt16(SINT64 val) 00661 { 00662 int pop_bits, bit_count; 00663 00664 for (pop_bits = bit_count = 0; 00665 bit_count < 16; 00666 pop_bits += val & 0x1, val >>= 1, bit_count++) 00667 ; 00668 return((SINT64) pop_bits); 00669 } 00670 00671 static SINT64 _poppar16(SINT64 val) 00672 { 00673 return(_popcnt16(val) & ((SINT64) 0x1)); 00674 } 00675 00676 00677 /*======================================== 00678 * 00679 * 32-BIT SUPPORT 00680 */ 00681 00682 /* 00683 * These un-sign-extend and sign-extend 32 bit values stored in 00684 * 64 bit integers. 00685 */ 00686 SINT64 DSEXT32(SINT64 v) 00687 { 00688 return(v & 0xFFFFFFFF); 00689 } 00690 00691 SINT64 SEXT32(SINT64 v) 00692 { 00693 return((( - ((v >> 31) & 0x1)) << 32) | DSEXT32(v)); 00694 } 00695 00696 00697 /* 00698 * These load a 32 bit value and if necessary sign extend it to 32 bits. 00699 */ 00700 SINT64 LS32(AR_INT_64 *vp) 00701 { 00702 return(SEXT32((((UINT64) vp->part3) << 16) | ((UINT64) vp->part4))); 00703 } 00704 00705 UINT64 LU32(AR_INT_64 *vp) 00706 { 00707 return((((UINT64) vp->part3) << 16) | (((UINT64) vp->part4))); 00708 } 00709 00710 00711 /* 00712 * This determines whether or not 32-bit values are zero/negative. 00713 */ 00714 #define is_zero32(v) (DSEXT32(v) == 0) 00715 #define is_neg32(v) (((v) & 0x80000000) != 0) 00716 00717 00718 /* 00719 * New 32-bit equivalents to the 64-bit intrinsics. 00720 */ 00721 static SINT64 _dshiftl32(SINT64 op1, SINT64 op2, SINT64 shcnt) 00722 { 00723 SINT64 rshcnt = ((SINT64) 32) - shcnt; 00724 00725 op2 &= 0xFFFFFFFF; 00726 return(((op1 << shcnt) | (op2 >> rshcnt)) & 0xFFFFFFFF); 00727 } 00728 00729 static SINT64 _dshiftr32(SINT64 op1, SINT64 op2, SINT64 shcnt) 00730 { 00731 SINT64 rshcnt = ((SINT64) 32) - shcnt; 00732 00733 op2 &= 0xFFFFFFFF; 00734 return(((op1 << rshcnt) | (op2 >> shcnt)) & 0xFFFFFFFF); 00735 } 00736 00737 static SINT64 _mask32(SINT64 bits) 00738 { 00739 bits &= 0xFFFFFFFF; 00740 if (bits > 0 && bits < 32) 00741 return((SINT64) ((0xFFFFFFFF << (((SINT64) 32) - bits)) & 0xFFFFFFFF)); 00742 else if (bits >= 32 && bits < 64) 00743 return((SINT64) (((UINT64) 0xFFFFFFFF) >> (bits - 32))); 00744 return(0); 00745 } 00746 00747 static SINT64 _leadz32(SINT64 val) 00748 { 00749 int lz_bits; 00750 00751 val <<= 32; 00752 if (val == 0) 00753 return(32); 00754 for (lz_bits = 0; val >= 0; val <<= 1) { 00755 lz_bits++; 00756 } 00757 return((SINT64) lz_bits); 00758 } 00759 00760 static SINT64 _popcnt32(SINT64 val) 00761 { 00762 int pop_bits, bit_count; 00763 00764 for (pop_bits = bit_count = 0; 00765 bit_count < 32; 00766 pop_bits += val & 0x1, val >>= 1, bit_count++) 00767 ; 00768 return((SINT64) pop_bits); 00769 } 00770 00771 static SINT64 _poppar32(SINT64 val) 00772 { 00773 return(_popcnt32(val) & ((SINT64) 0x1)); 00774 } 00775 00776 00777 /*======================================== 00778 * 00779 * 46-BIT SUPPORT 00780 */ 00781 00782 /* 00783 * These un-sign-extend and sign-extend 46 bit values stored in 00784 * 64 bit integers. They're no-ops, but they make writing the 00785 * code easier. 00786 */ 00787 SINT64 DSEXT46(SINT64 v) 00788 { 00789 return(v); 00790 } 00791 00792 SINT64 SEXT46(SINT64 v) 00793 { 00794 return(v); 00795 } 00796 00797 00798 /* 00799 * This determines whether or not 46-bit values are zero/negative. 00800 */ 00801 #define is_zero46(v) ((v) == 0) 00802 #define is_neg46(v) ((v) < 0) 00803 00804 00805 /* 00806 * New 46-bit equivalents to the 64-bit intrinsics. Also no-ops, 00807 * to make writing the code easier. 00808 */ 00809 static SINT64 _dshiftl46(SINT64 op1, SINT64 op2, SINT64 shcnt) 00810 { 00811 return(_dshiftl(op1, op2, shcnt)); 00812 } 00813 00814 static SINT64 _dshiftr46(SINT64 op1, SINT64 op2, SINT64 shcnt) 00815 { 00816 return(_dshiftr(op1, op2, shcnt)); 00817 } 00818 00819 static SINT64 _mask46(SINT64 bits) 00820 { 00821 return(_mask(bits)); 00822 } 00823 00824 static SINT64 _leadz46(SINT64 val) 00825 { 00826 return(_leadz(val)); 00827 } 00828 00829 static SINT64 _popcnt46(SINT64 val) 00830 { 00831 return(_popcnt(val)); 00832 } 00833 00834 static SINT64 _poppar46(SINT64 val) 00835 { 00836 return(_poppar(val)); 00837 } 00838 00839 00840 /*======================================== 00841 * 00842 * 64-BIT SUPPORT 00843 */ 00844 00845 /* 00846 * These un-sign-extend and sign-extend 64 bit values stored in 00847 * 64 bit integers. They're no-ops, but they make writing the 00848 * code easier. 00849 */ 00850 SINT64 DSEXT64(SINT64 v) 00851 { 00852 return(v); 00853 } 00854 00855 SINT64 SEXT64(SINT64 v) 00856 { 00857 return(v); 00858 } 00859 00860 00861 /* 00862 * This determines whether or not 64-bit values are zero/negative. 00863 */ 00864 #define is_zero64(v) ((v) == 0) 00865 #define is_neg64(v) ((v) < 0) 00866 00867 00868 /* 00869 * New 64-bit equivalents to the 64-bit intrinsics. Also no-ops, 00870 * to make writing the code easier. 00871 */ 00872 static SINT64 _dshiftl64(SINT64 op1, SINT64 op2, SINT64 shcnt) 00873 { 00874 return(_dshiftl(op1, op2, shcnt)); 00875 } 00876 00877 static SINT64 _dshiftr64(SINT64 op1, SINT64 op2, SINT64 shcnt) 00878 { 00879 return(_dshiftr(op1, op2, shcnt)); 00880 } 00881 00882 static SINT64 _mask64(SINT64 bits) 00883 { 00884 return(_mask(bits)); 00885 } 00886 00887 static SINT64 _leadz64(SINT64 val) 00888 { 00889 return(_leadz(val)); 00890 } 00891 00892 static SINT64 _popcnt64(SINT64 val) 00893 { 00894 return(_popcnt(val)); 00895 } 00896 00897 static SINT64 _poppar64(SINT64 val) 00898 { 00899 return(_poppar(val)); 00900 } 00901 00902 00903 main() 00904 { 00905 test_bitor(); 00906 test_bitand(); 00907 test_bitxor(); 00908 test_bitcomplement(); 00909 test_shiftl(); 00910 test_shiftr(); 00911 test_dshiftl(); 00912 test_dshiftr(); 00913 test_ishft(); 00914 test_ishftc(); 00915 test_ibits(); 00916 test_mask(); 00917 test_leadz(); 00918 test_popcnt(); 00919 test_poppar(); 00920 test_arstatus(); 00921 test_add(); 00922 test_subtract(); 00923 test_negate(); 00924 test_abs(); 00925 test_multiply(); 00926 test_divide(); 00927 test_modulo(); 00928 test_compare(); 00929 exit(0); 00930 } 00931 00932 00933 /*====================================================================== 00934 * 00935 * BIT OPERATORS 00936 * 00937 */ 00938 00939 #define TEST_BINARY_BIT_OP_SIGNED(size, opr, func) \ 00940 do { \ 00941 int i, j; \ 00942 \ 00943 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 00944 \ 00945 for (i=0; i<num_cool_ints; i++) \ 00946 { \ 00947 for (j=0; j<num_cool_ints; j++) \ 00948 { \ 00949 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) opr \ 00950 LS##size(&cool_ints[j])); \ 00951 \ 00952 act_status[j] = is_zero##size(act_result[j]) \ 00953 ? AR_STAT_ZERO : AR_STAT_OK; \ 00954 if (is_neg##size(act_result[j])) \ 00955 act_status[j] |= AR_STAT_NEGATIVE; \ 00956 \ 00957 test_result[j].part1 = 0; \ 00958 test_result[j].part2 = 0; \ 00959 test_result[j].part3 = 0; \ 00960 test_result[j].part4 = 0; \ 00961 \ 00962 test_status[j] = func((AR_DATA *)&test_result[j], \ 00963 &sint##size##_artype, \ 00964 (AR_DATA *)&cool_ints[i], \ 00965 &sint##size##_artype, \ 00966 (AR_DATA *)&cool_ints[j], \ 00967 &sint##size##_artype); \ 00968 \ 00969 if (LU64(&test_result[j]) != act_result[j]) \ 00970 { \ 00971 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 00972 abort(); \ 00973 } \ 00974 \ 00975 if (act_status[j] != test_status[j]) \ 00976 { \ 00977 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 00978 abort(); \ 00979 } \ 00980 } \ 00981 } \ 00982 \ 00983 printf("PASSED\n"); \ 00984 } while (0) 00985 00986 00987 #define TEST_BINARY_BIT_OP_UNSIGNED(size, opr, func) \ 00988 do { \ 00989 int i, j; \ 00990 \ 00991 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 00992 \ 00993 for (i=0; i<num_cool_ints; i++) \ 00994 { \ 00995 for (j=0; j<num_cool_ints; j++) \ 00996 { \ 00997 act_result[j] = DSEXT##size(LU##size(&cool_ints[i]) opr \ 00998 LU##size(&cool_ints[j])); \ 00999 \ 01000 act_status[j] = is_zero##size(act_result[j]) \ 01001 ? AR_STAT_ZERO \ 01002 : AR_STAT_OK; \ 01003 \ 01004 test_result[j].part1 = 0; \ 01005 test_result[j].part2 = 0; \ 01006 test_result[j].part3 = 0; \ 01007 test_result[j].part4 = 0; \ 01008 \ 01009 test_status[j] = func((AR_DATA *)&test_result[j], \ 01010 &uint##size##_artype, \ 01011 (AR_DATA *)&cool_ints[i], \ 01012 &uint##size##_artype, \ 01013 (AR_DATA *)&cool_ints[j], \ 01014 &uint##size##_artype); \ 01015 \ 01016 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 01017 { \ 01018 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 01019 abort(); \ 01020 } \ 01021 \ 01022 if (act_status[j] != test_status[j]) \ 01023 { \ 01024 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 01025 abort(); \ 01026 } \ 01027 } \ 01028 } \ 01029 \ 01030 printf("PASSED\n"); \ 01031 } while (0) 01032 01033 01034 #define TEST_BINARY_BIT_OP_TYPES(opr, func) \ 01035 do { \ 01036 int i, j, k; \ 01037 \ 01038 printf(" Testing: types %-10s: ", #opr); \ 01039 \ 01040 for (i=0; i<num_ar_types; i++) \ 01041 { \ 01042 for (j=0; j<num_ar_types; j++) \ 01043 { \ 01044 for (k=0; k<num_ar_types; k++) \ 01045 { \ 01046 act_status[k] = AR_STAT_OK; \ 01047 if (ar_types[i] != ar_types[j] || \ 01048 ar_types[j] != ar_types[k] || \ 01049 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 01050 act_status[k] = AR_STAT_INVALID_TYPE; \ 01051 \ 01052 test_status[k] = func((AR_DATA *)&test_result[1], \ 01053 &ar_types[i], \ 01054 (AR_DATA *)&cool_ints[1], \ 01055 &ar_types[j], \ 01056 (AR_DATA *)&cool_ints[1], \ 01057 &ar_types[k]); \ 01058 \ 01059 if ((act_status[k] ^ test_status[k]) & \ 01060 AR_STAT_INVALID_TYPE) \ 01061 { \ 01062 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 01063 i, j, k); \ 01064 abort(); \ 01065 } \ 01066 } \ 01067 } \ 01068 } \ 01069 \ 01070 printf("PASSED\n"); \ 01071 } while (0) 01072 01073 01074 #define TEST_UNARY_BIT_OP_SIGNED(size, opr, func) \ 01075 do { \ 01076 int j; \ 01077 \ 01078 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 01079 \ 01080 for (j=0; j<num_cool_ints; j++) \ 01081 { \ 01082 act_result[j] = DSEXT##size(opr LS##size(&cool_ints[j])); \ 01083 \ 01084 act_status[j] = is_zero##size(act_result[j]) \ 01085 ? AR_STAT_ZERO \ 01086 : AR_STAT_OK; \ 01087 if (is_neg##size(act_result[j])) \ 01088 act_status[j] |= AR_STAT_NEGATIVE; \ 01089 \ 01090 test_result[j].part1 = 0; \ 01091 test_result[j].part2 = 0; \ 01092 test_result[j].part3 = 0; \ 01093 test_result[j].part4 = 0; \ 01094 \ 01095 test_status[j] = func((AR_DATA *)&test_result[j], \ 01096 &sint##size##_artype, \ 01097 (AR_DATA *)&cool_ints[j], \ 01098 &sint##size##_artype); \ 01099 \ 01100 if (LU64(&test_result[j]) != act_result[j]) \ 01101 { \ 01102 printf(" ERROR: incorrect result at %d\n", j); \ 01103 abort(); \ 01104 } \ 01105 \ 01106 if (act_status[j] != test_status[j]) \ 01107 { \ 01108 printf(" ERROR: incorrect status at %d\n", j); \ 01109 abort(); \ 01110 } \ 01111 } \ 01112 \ 01113 printf("PASSED\n"); \ 01114 } while (0) 01115 01116 01117 #define TEST_UNARY_BIT_OP_UNSIGNED(size, opr, func) \ 01118 do { \ 01119 int j; \ 01120 \ 01121 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 01122 \ 01123 for (j=0; j<num_cool_ints; j++) \ 01124 { \ 01125 act_result[j] = DSEXT##size(opr LU##size(&cool_ints[j])); \ 01126 \ 01127 act_status[j] = is_zero##size(act_result[j]) \ 01128 ? AR_STAT_ZERO \ 01129 : AR_STAT_OK; \ 01130 \ 01131 test_result[j].part1 = 0; \ 01132 test_result[j].part2 = 0; \ 01133 test_result[j].part3 = 0; \ 01134 test_result[j].part4 = 0; \ 01135 \ 01136 test_status[j] = func((AR_DATA *)&test_result[j], \ 01137 &uint##size##_artype, \ 01138 (AR_DATA *)&cool_ints[j], \ 01139 &uint##size##_artype); \ 01140 \ 01141 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 01142 { \ 01143 printf(" ERROR: incorrect result at %d\n", j); \ 01144 abort(); \ 01145 } \ 01146 \ 01147 if (act_status[j] != test_status[j]) \ 01148 { \ 01149 printf(" ERROR: incorrect status at %d\n", j); \ 01150 abort(); \ 01151 } \ 01152 } \ 01153 \ 01154 printf("PASSED\n"); \ 01155 } while (0) 01156 01157 01158 #define TEST_UNARY_BIT_OP_TYPES(opr, func) \ 01159 do { \ 01160 int j, k; \ 01161 \ 01162 printf(" Testing: types %-10s: ", #opr); \ 01163 \ 01164 for (j=0; j<num_ar_types; j++) \ 01165 { \ 01166 for (k=0; k<num_ar_types; k++) \ 01167 { \ 01168 act_status[k] = AR_STAT_OK; \ 01169 if (ar_types[j] != ar_types[k] || \ 01170 !IS_SUPPORTED_INT_TYPE(ar_types[j])) \ 01171 act_status[k] = AR_STAT_INVALID_TYPE; \ 01172 \ 01173 test_status[k] = func((AR_DATA *)&test_result[1], \ 01174 &ar_types[j], \ 01175 (AR_DATA *)&cool_ints[1], \ 01176 &ar_types[k]); \ 01177 \ 01178 if ((act_status[k] ^ test_status[k]) & \ 01179 AR_STAT_INVALID_TYPE) \ 01180 { \ 01181 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 01182 abort(); \ 01183 } \ 01184 } \ 01185 } \ 01186 \ 01187 printf("PASSED\n"); \ 01188 } while (0) 01189 01190 01191 test_bitor() 01192 { 01193 01194 TEST_BINARY_BIT_OP_SIGNED( 8, |, AR_bitor ); 01195 TEST_BINARY_BIT_OP_UNSIGNED( 8, |, AR_bitor ); 01196 01197 TEST_BINARY_BIT_OP_SIGNED( 16, |, AR_bitor ); 01198 TEST_BINARY_BIT_OP_UNSIGNED(16, |, AR_bitor ); 01199 01200 TEST_BINARY_BIT_OP_SIGNED( 32, |, AR_bitor ); 01201 TEST_BINARY_BIT_OP_UNSIGNED(32, |, AR_bitor ); 01202 01203 TEST_BINARY_BIT_OP_SIGNED( 46, |, AR_bitor ); 01204 01205 TEST_BINARY_BIT_OP_SIGNED( 64, |, AR_bitor ); 01206 TEST_BINARY_BIT_OP_UNSIGNED(64, |, AR_bitor ); 01207 01208 TEST_BINARY_BIT_OP_TYPES( |, AR_bitor ); 01209 01210 } /* test_bitor */ 01211 01212 01213 test_bitand() 01214 { 01215 01216 TEST_BINARY_BIT_OP_SIGNED( 8, &, AR_bitand); 01217 TEST_BINARY_BIT_OP_UNSIGNED( 8, &, AR_bitand); 01218 01219 TEST_BINARY_BIT_OP_SIGNED( 16, &, AR_bitand); 01220 TEST_BINARY_BIT_OP_UNSIGNED(16, &, AR_bitand); 01221 01222 TEST_BINARY_BIT_OP_SIGNED( 32, &, AR_bitand); 01223 TEST_BINARY_BIT_OP_UNSIGNED(32, &, AR_bitand); 01224 01225 TEST_BINARY_BIT_OP_SIGNED( 46, &, AR_bitand); 01226 01227 TEST_BINARY_BIT_OP_SIGNED( 64, &, AR_bitand); 01228 TEST_BINARY_BIT_OP_UNSIGNED(64, &, AR_bitand); 01229 01230 TEST_BINARY_BIT_OP_TYPES( &, AR_bitand); 01231 01232 } /* test_bitand */ 01233 01234 01235 test_bitxor() 01236 { 01237 01238 TEST_BINARY_BIT_OP_SIGNED( 8, ^, AR_bitxor); 01239 TEST_BINARY_BIT_OP_UNSIGNED( 8, ^, AR_bitxor); 01240 01241 TEST_BINARY_BIT_OP_SIGNED( 16, ^, AR_bitxor); 01242 TEST_BINARY_BIT_OP_UNSIGNED(16, ^, AR_bitxor); 01243 01244 TEST_BINARY_BIT_OP_SIGNED( 32, ^, AR_bitxor); 01245 TEST_BINARY_BIT_OP_UNSIGNED(32, ^, AR_bitxor); 01246 01247 TEST_BINARY_BIT_OP_SIGNED( 46, ^, AR_bitxor); 01248 01249 TEST_BINARY_BIT_OP_SIGNED( 64, ^, AR_bitxor); 01250 TEST_BINARY_BIT_OP_UNSIGNED(64, ^, AR_bitxor); 01251 01252 TEST_BINARY_BIT_OP_TYPES( ^, AR_bitxor); 01253 01254 } /* test_bitxor */ 01255 01256 01257 test_bitcomplement() 01258 { 01259 01260 TEST_UNARY_BIT_OP_SIGNED( 8, ~, AR_bitcomplement); 01261 TEST_UNARY_BIT_OP_UNSIGNED( 8, ~, AR_bitcomplement); 01262 01263 TEST_UNARY_BIT_OP_SIGNED( 16, ~, AR_bitcomplement); 01264 TEST_UNARY_BIT_OP_UNSIGNED(16, ~, AR_bitcomplement); 01265 01266 TEST_UNARY_BIT_OP_SIGNED( 32, ~, AR_bitcomplement); 01267 TEST_UNARY_BIT_OP_UNSIGNED(32, ~, AR_bitcomplement); 01268 01269 TEST_UNARY_BIT_OP_SIGNED( 46, ~, AR_bitcomplement); 01270 01271 TEST_UNARY_BIT_OP_SIGNED( 64, ~, AR_bitcomplement); 01272 TEST_UNARY_BIT_OP_UNSIGNED(64, ~, AR_bitcomplement); 01273 01274 TEST_UNARY_BIT_OP_TYPES( ~, AR_bitcomplement); 01275 01276 } /* test_bitcomplement */ 01277 01278 01279 #undef TEST_BINARY_BIT_OP_SIGNED 01280 #undef TEST_BINARY_BIT_OP_UNSIGNED 01281 #undef TEST_BINARY_BIT_OP_TYPES 01282 #undef TEST_UNARY_BIT_OP_SIGNED 01283 #undef TEST_UNARY_BIT_OP_UNSIGNED 01284 #undef TEST_UNARY_BIT_OP_TYPES 01285 01286 01287 /*====================================================================== 01288 * 01289 * SHIFT OPERATORS 01290 * 01291 */ 01292 01293 #define TEST_SHIFT_OP_SIGNED(size, max_shift, opr, func) \ 01294 do { \ 01295 int i, j; \ 01296 \ 01297 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 01298 \ 01299 for (i=0; i<num_cool_ints; i++) \ 01300 { \ 01301 for (j=0; j<num_cool_ints; j++) \ 01302 { \ 01303 if (LS##size(&cool_ints[j]) >= max_shift || \ 01304 LS##size(&cool_ints[j]) < 0) \ 01305 { /* status is undefined, result is zero */ \ 01306 act_status[j] = AR_STAT_UNDEFINED; \ 01307 act_result[j] = 0; \ 01308 } \ 01309 else \ 01310 { \ 01311 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) opr \ 01312 LS##size(&cool_ints[j])); \ 01313 \ 01314 if (size >= 46 && \ 01315 strcmp(#opr, ">>") == 0 && \ 01316 LS64(&cool_ints[i]) < 0) \ 01317 { /* the first operand is negative */ \ 01318 /* fill vacated bit(s) with sign bit */ \ 01319 act_result[j] |= (SINT64) \ 01320 ~(-1 >> LS46(&cool_ints[j])); \ 01321 } \ 01322 \ 01323 act_status[j] = is_zero##size(act_result[j]) \ 01324 ? AR_STAT_ZERO \ 01325 : AR_STAT_OK; \ 01326 if (is_neg##size(act_result[j])) \ 01327 act_status[j] |= AR_STAT_NEGATIVE; \ 01328 } \ 01329 \ 01330 test_result[j].part1 = 0; \ 01331 test_result[j].part2 = 0; \ 01332 test_result[j].part3 = 0; \ 01333 test_result[j].part4 = 0; \ 01334 \ 01335 test_status[j] = func((AR_DATA *)&test_result[j], \ 01336 &sint##size##_artype, \ 01337 (AR_DATA *)&cool_ints[i], \ 01338 &sint##size##_artype, \ 01339 (AR_DATA *)&cool_ints[j], \ 01340 &sint##size##_artype); \ 01341 \ 01342 if (LU64(&test_result[j]) != act_result[j]) \ 01343 { \ 01344 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 01345 abort(); \ 01346 } \ 01347 \ 01348 if (act_status[j] != test_status[j]) \ 01349 { \ 01350 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 01351 abort(); \ 01352 } \ 01353 } \ 01354 } \ 01355 \ 01356 printf("PASSED\n"); \ 01357 } while (0) 01358 01359 01360 #define TEST_SHIFT_OP_UNSIGNED(size, max_shift, opr, func) \ 01361 do { \ 01362 int i, j; \ 01363 \ 01364 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 01365 \ 01366 for (i=0; i<num_cool_ints; i++) \ 01367 { \ 01368 for (j=0; j<num_cool_ints; j++) \ 01369 { \ 01370 if (LU##size(&cool_ints[j]) >= max_shift) \ 01371 { /* status is undefined, result is zero */ \ 01372 act_status[j] = AR_STAT_UNDEFINED; \ 01373 act_result[j] = 0; \ 01374 } \ 01375 else \ 01376 { \ 01377 act_result[j] = DSEXT##size(LU##size(&cool_ints[i]) opr \ 01378 LU##size(&cool_ints[j])); \ 01379 \ 01380 act_status[j] = is_zero##size(act_result[j]) \ 01381 ? AR_STAT_ZERO \ 01382 : AR_STAT_OK; \ 01383 } \ 01384 \ 01385 test_result[j].part1 = 0; \ 01386 test_result[j].part2 = 0; \ 01387 test_result[j].part3 = 0; \ 01388 test_result[j].part4 = 0; \ 01389 \ 01390 test_status[j] = func((AR_DATA *)&test_result[j], \ 01391 &uint##size##_artype, \ 01392 (AR_DATA *)&cool_ints[i], \ 01393 &uint##size##_artype, \ 01394 (AR_DATA *)&cool_ints[j], \ 01395 &uint##size##_artype); \ 01396 \ 01397 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 01398 { \ 01399 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 01400 abort(); \ 01401 } \ 01402 \ 01403 if (act_status[j] != test_status[j]) \ 01404 { \ 01405 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 01406 abort(); \ 01407 } \ 01408 } \ 01409 } \ 01410 \ 01411 printf("PASSED\n"); \ 01412 } while (0) 01413 01414 01415 #define TEST_SHIFT_OP_TYPES(opr, func) \ 01416 do { \ 01417 int i, j, k; \ 01418 \ 01419 printf(" Testing: types %-10s: ", #opr); \ 01420 \ 01421 for (i=0; i<num_ar_types; i++) \ 01422 { \ 01423 for (j=0; j<num_ar_types; j++) \ 01424 { \ 01425 for (k=0; k<num_ar_types; k++) \ 01426 { \ 01427 act_status[k] = AR_STAT_OK; \ 01428 if (ar_types[i] != ar_types[j] || \ 01429 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 01430 act_status[k] = AR_STAT_INVALID_TYPE; \ 01431 \ 01432 test_status[k] = func((AR_DATA *)&test_result[1], \ 01433 &ar_types[i], \ 01434 (AR_DATA *)&cool_ints[1], \ 01435 &ar_types[j], \ 01436 (AR_DATA *)&cool_ints[1], \ 01437 &ar_types[k]); \ 01438 \ 01439 if ((act_status[k] ^ test_status[k]) & \ 01440 AR_STAT_INVALID_TYPE) \ 01441 { \ 01442 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 01443 i, j, k); \ 01444 abort(); \ 01445 } \ 01446 } \ 01447 } \ 01448 } \ 01449 \ 01450 printf("PASSED\n"); \ 01451 } while (0) 01452 01453 01454 test_shiftl() 01455 { 01456 01457 TEST_SHIFT_OP_SIGNED( 8, 8, <<, AR_shiftl); 01458 TEST_SHIFT_OP_UNSIGNED( 8, 8, <<, AR_shiftl); 01459 01460 TEST_SHIFT_OP_SIGNED( 16, 16, <<, AR_shiftl); 01461 TEST_SHIFT_OP_UNSIGNED(16, 16, <<, AR_shiftl); 01462 01463 TEST_SHIFT_OP_SIGNED( 32, 32, <<, AR_shiftl); 01464 TEST_SHIFT_OP_UNSIGNED(32, 32, <<, AR_shiftl); 01465 01466 TEST_SHIFT_OP_SIGNED( 46, 64, <<, AR_shiftl); 01467 01468 TEST_SHIFT_OP_SIGNED( 64, 64, <<, AR_shiftl); 01469 TEST_SHIFT_OP_UNSIGNED(64, 64, <<, AR_shiftl); 01470 01471 TEST_SHIFT_OP_TYPES( <<, AR_shiftl); 01472 01473 } /* test_shiftl */ 01474 01475 01476 test_shiftr() 01477 { 01478 01479 TEST_SHIFT_OP_SIGNED( 8, 8, >>, AR_shiftr); 01480 TEST_SHIFT_OP_UNSIGNED( 8, 8, >>, AR_shiftr); 01481 01482 TEST_SHIFT_OP_SIGNED( 16, 16, >>, AR_shiftr); 01483 TEST_SHIFT_OP_UNSIGNED(16, 16, >>, AR_shiftr); 01484 01485 TEST_SHIFT_OP_SIGNED( 32, 32, >>, AR_shiftr); 01486 TEST_SHIFT_OP_UNSIGNED(32, 32, >>, AR_shiftr); 01487 01488 TEST_SHIFT_OP_SIGNED( 46, 64, >>, AR_shiftr); 01489 01490 TEST_SHIFT_OP_SIGNED( 64, 64, >>, AR_shiftr); 01491 TEST_SHIFT_OP_UNSIGNED(64, 64, >>, AR_shiftr); 01492 01493 TEST_SHIFT_OP_TYPES( >>, AR_shiftr); 01494 01495 } /* test_shiftr */ 01496 01497 01498 #undef TEST_SHIFT_OP_SIGNED 01499 #undef TEST_SHIFT_OP_UNSIGNED 01500 #undef TEST_SHIFT_OP_TYPES 01501 01502 01503 #define TEST_DSHIFT_OP_SIGNED(size, max_shift, opr) \ 01504 do { \ 01505 int i, j, k; \ 01506 \ 01507 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 01508 \ 01509 for (i=0; i<num_cool_ints; i++) \ 01510 { \ 01511 for (j=0; j<num_cool_ints; j++) \ 01512 { \ 01513 for (k=0; k<num_dshift_vals; k++) \ 01514 { \ 01515 if (LS##size(&dshift_vals[k]) > max_shift || \ 01516 LS##size(&dshift_vals[k]) < 0) \ 01517 { /* status is undefined, result is zero */ \ 01518 act_status[k] = AR_STAT_UNDEFINED; \ 01519 act_result[k] = 0; \ 01520 } \ 01521 else \ 01522 { \ 01523 act_result[k] = DSEXT##size( \ 01524 opr##size( \ 01525 LS##size(&cool_ints[i]), \ 01526 LS##size(&cool_ints[j]), \ 01527 LS##size(&dshift_vals[k]))); \ 01528 \ 01529 act_status[k] = is_zero##size(act_result[k]) \ 01530 ? AR_STAT_ZERO \ 01531 : AR_STAT_OK; \ 01532 if (is_neg##size(act_result[k])) \ 01533 act_status[k] |= AR_STAT_NEGATIVE; \ 01534 } \ 01535 \ 01536 test_result[k].part1 = 0; \ 01537 test_result[k].part2 = 0; \ 01538 test_result[k].part3 = 0; \ 01539 test_result[k].part4 = 0; \ 01540 \ 01541 test_status[k] = AR##opr((AR_DATA *)&test_result[k], \ 01542 &sint##size##_artype, \ 01543 (AR_DATA *)&cool_ints[i], \ 01544 &sint##size##_artype, \ 01545 (AR_DATA *)&cool_ints[j], \ 01546 &sint##size##_artype, \ 01547 (AR_DATA *)&dshift_vals[k], \ 01548 &sint##size##_artype); \ 01549 \ 01550 if (LU64(&test_result[k]) != (UINT64)act_result[k]) \ 01551 { \ 01552 printf(" ERROR: incorrect result at %d,%d,%d\n", \ 01553 i, j, k); \ 01554 abort(); \ 01555 } \ 01556 \ 01557 if (act_status[k] != test_status[k]) \ 01558 { \ 01559 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 01560 i, j, k); \ 01561 abort(); \ 01562 } \ 01563 } \ 01564 } \ 01565 } \ 01566 \ 01567 printf("PASSED\n"); \ 01568 } while (0) 01569 01570 01571 #define TEST_DSHIFT_OP_UNSIGNED(size, max_shift, opr) \ 01572 do { \ 01573 int i, j, k; \ 01574 \ 01575 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 01576 \ 01577 for (i=0; i<num_cool_ints; i++) \ 01578 { \ 01579 for (j=0; j<num_cool_ints; j++) \ 01580 { \ 01581 for (k=0; k<num_dshift_vals; k++) \ 01582 { \ 01583 if (LU##size(&dshift_vals[k]) > max_shift) \ 01584 { /* status is undefined, result is zero */ \ 01585 act_status[k] = AR_STAT_UNDEFINED; \ 01586 act_result[k] = 0; \ 01587 } \ 01588 else \ 01589 { \ 01590 act_result[k] = DSEXT##size( \ 01591 opr##size( \ 01592 LU##size(&cool_ints[i]), \ 01593 LU##size(&cool_ints[j]), \ 01594 LU##size(&dshift_vals[k]))); \ 01595 \ 01596 act_status[k] = is_zero##size(act_result[k]) \ 01597 ? AR_STAT_ZERO \ 01598 : AR_STAT_OK; \ 01599 } \ 01600 \ 01601 test_result[k].part1 = 0; \ 01602 test_result[k].part2 = 0; \ 01603 test_result[k].part3 = 0; \ 01604 test_result[k].part4 = 0; \ 01605 \ 01606 test_status[k] = AR##opr((AR_DATA *)&test_result[k], \ 01607 &uint##size##_artype, \ 01608 (AR_DATA *)&cool_ints[i], \ 01609 &uint##size##_artype, \ 01610 (AR_DATA *)&cool_ints[j], \ 01611 &uint##size##_artype, \ 01612 (AR_DATA *)&dshift_vals[k], \ 01613 &uint##size##_artype); \ 01614 \ 01615 if (LU64(&test_result[k]) != (UINT64)act_result[k]) \ 01616 { \ 01617 printf(" ERROR: incorrect result at %d,%d,%d\n", \ 01618 i, j, k); \ 01619 abort(); \ 01620 } \ 01621 \ 01622 if (act_status[k] != test_status[k]) \ 01623 { \ 01624 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 01625 i, j, k); \ 01626 abort(); \ 01627 } \ 01628 } \ 01629 } \ 01630 } \ 01631 \ 01632 printf("PASSED\n"); \ 01633 } while (0) 01634 01635 01636 #define TEST_DSHIFT_OP_TYPES(opr) \ 01637 do { \ 01638 int h, i, j, k; \ 01639 \ 01640 printf(" Testing: types %-10s: ", #opr); \ 01641 \ 01642 for (h=0; h<num_ar_types; h++) \ 01643 { \ 01644 for (i=0; i<num_ar_types; i++) \ 01645 { \ 01646 for (j=0; j<num_ar_types; j++) \ 01647 { \ 01648 for (k=0; k<num_ar_types; k++) \ 01649 { \ 01650 act_status[k] = AR_STAT_OK; \ 01651 if (ar_types[h] != ar_types[i] || \ 01652 ar_types[i] != ar_types[j] || \ 01653 !IS_SUPPORTED_INT_TYPE(ar_types[h])) \ 01654 act_status[k] = AR_STAT_INVALID_TYPE; \ 01655 \ 01656 test_status[k] = AR##opr((AR_DATA *)&test_result[1], \ 01657 &ar_types[h], \ 01658 (AR_DATA *)&cool_ints[1], \ 01659 &ar_types[i], \ 01660 (AR_DATA *)&cool_ints[1], \ 01661 &ar_types[j], \ 01662 (AR_DATA *)&dshift_vals[1], \ 01663 &ar_types[k]); \ 01664 \ 01665 if ((act_status[k] ^ test_status[k]) & \ 01666 AR_STAT_INVALID_TYPE) { \ 01667 printf(" ERROR: incorrect status at " \ 01668 "%d,%d,%d,%d\n", \ 01669 h, i, j, k); \ 01670 abort(); \ 01671 } \ 01672 } \ 01673 } \ 01674 } \ 01675 } \ 01676 \ 01677 printf("PASSED\n"); \ 01678 } while (0) 01679 01680 01681 test_dshiftl() 01682 { 01683 01684 TEST_DSHIFT_OP_SIGNED( 8, 8, _dshiftl); 01685 TEST_DSHIFT_OP_UNSIGNED( 8, 8, _dshiftl); 01686 01687 TEST_DSHIFT_OP_SIGNED( 16, 16, _dshiftl); 01688 TEST_DSHIFT_OP_UNSIGNED(16, 16, _dshiftl); 01689 01690 TEST_DSHIFT_OP_SIGNED( 32, 32, _dshiftl); 01691 TEST_DSHIFT_OP_UNSIGNED(32, 32, _dshiftl); 01692 01693 TEST_DSHIFT_OP_SIGNED( 46, 64, _dshiftl); 01694 01695 TEST_DSHIFT_OP_SIGNED( 64, 64, _dshiftl); 01696 TEST_DSHIFT_OP_UNSIGNED(64, 64, _dshiftl); 01697 01698 TEST_DSHIFT_OP_TYPES( _dshiftl); 01699 01700 } /* test_dshiftl */ 01701 01702 01703 test_dshiftr() 01704 { 01705 01706 TEST_DSHIFT_OP_SIGNED( 8, 8, _dshiftr); 01707 TEST_DSHIFT_OP_UNSIGNED( 8, 8, _dshiftr); 01708 01709 TEST_DSHIFT_OP_SIGNED( 16, 16, _dshiftr); 01710 TEST_DSHIFT_OP_UNSIGNED(16, 16, _dshiftr); 01711 01712 TEST_DSHIFT_OP_SIGNED( 32, 32, _dshiftr); 01713 TEST_DSHIFT_OP_UNSIGNED(32, 32, _dshiftr); 01714 01715 TEST_DSHIFT_OP_SIGNED( 46, 64, _dshiftr); 01716 01717 TEST_DSHIFT_OP_SIGNED( 64, 64, _dshiftr); 01718 TEST_DSHIFT_OP_UNSIGNED(64, 64, _dshiftr); 01719 01720 TEST_DSHIFT_OP_TYPES( _dshiftr); 01721 01722 } /* test_dshiftr */ 01723 01724 01725 #undef TEST_DSHIFT_OP_SIGNED 01726 #undef TEST_DSHIFT_OP_UNSIGNED 01727 #undef TEST_DSHIFT_OP_TYPES 01728 01729 01730 static 01731 void 01732 test_ishft_signed(int size) 01733 { 01734 int i, j; 01735 01736 printf(" Testing: SIGNED %2d INT %-10s: ", size, "ISHFT"); 01737 01738 for (i=0; i<num_cool_ints; i++) 01739 { 01740 for (j=0; j<num_cool_ints; j++) 01741 { 01742 SINT64 shift; 01743 01744 test_result[j].part1 = 0; 01745 test_result[j].part2 = 0; 01746 test_result[j].part3 = 0; 01747 test_result[j].part4 = 0; 01748 01749 switch (size) 01750 { 01751 case 8: 01752 shift = LS8(&cool_ints[j]); 01753 if ((shift > 0 && shift > size) || 01754 (shift < 0 && shift < -size)) 01755 { /* status is undefined, result is zero */ 01756 act_status[j] = AR_STAT_UNDEFINED; 01757 act_result[j] = 0; 01758 } 01759 else 01760 { 01761 if (shift > 0) 01762 act_result[j] = DSEXT8(LU8(&cool_ints[i]) << 01763 shift); 01764 else 01765 act_result[j] = DSEXT8(LU8(&cool_ints[i]) >> 01766 (-shift)); 01767 01768 act_status[j] = is_zero8(act_result[j]) 01769 ? AR_STAT_ZERO 01770 : AR_STAT_OK; 01771 if (is_neg8(act_result[j])) 01772 act_status[j] |= AR_STAT_NEGATIVE; 01773 } 01774 01775 test_status[j] = AR_ishft((AR_DATA *)&test_result[j], 01776 &sint8_artype, 01777 (AR_DATA *)&cool_ints[i], 01778 &sint8_artype, 01779 (AR_DATA *)&cool_ints[j], 01780 &sint8_artype); 01781 break; 01782 01783 case 16: 01784 shift = LS16(&cool_ints[j]); 01785 if ((shift > 0 && shift > size) || 01786 (shift < 0 && shift < -size)) 01787 { /* status is undefined, result is zero */ 01788 act_status[j] = AR_STAT_UNDEFINED; 01789 act_result[j] = 0; 01790 } 01791 else 01792 { 01793 if (shift > 0) 01794 act_result[j] = DSEXT16(LU16(&cool_ints[i]) << 01795 shift); 01796 else 01797 act_result[j] = DSEXT16(LU16(&cool_ints[i]) >> 01798 (-shift)); 01799 01800 act_status[j] = is_zero16(act_result[j]) 01801 ? AR_STAT_ZERO 01802 : AR_STAT_OK; 01803 if (is_neg16(act_result[j])) 01804 act_status[j] |= AR_STAT_NEGATIVE; 01805 } 01806 01807 test_status[j] = AR_ishft((AR_DATA *)&test_result[j], 01808 &sint16_artype, 01809 (AR_DATA *)&cool_ints[i], 01810 &sint16_artype, 01811 (AR_DATA *)&cool_ints[j], 01812 &sint16_artype); 01813 break; 01814 01815 case 32: 01816 shift = LS32(&cool_ints[j]); 01817 if ((shift > 0 && shift > size) || 01818 (shift < 0 && shift < -size)) 01819 { /* status is undefined, result is zero */ 01820 act_status[j] = AR_STAT_UNDEFINED; 01821 act_result[j] = 0; 01822 } 01823 else 01824 { 01825 if (shift > 0) 01826 act_result[j] = DSEXT32(LU32(&cool_ints[i]) << 01827 shift); 01828 else 01829 act_result[j] = DSEXT32(LU32(&cool_ints[i]) >> 01830 (-shift)); 01831 01832 act_status[j] = is_zero32(act_result[j]) 01833 ? AR_STAT_ZERO 01834 : AR_STAT_OK; 01835 if (is_neg32(act_result[j])) 01836 act_status[j] |= AR_STAT_NEGATIVE; 01837 } 01838 01839 test_status[j] = AR_ishft((AR_DATA *)&test_result[j], 01840 &sint32_artype, 01841 (AR_DATA *)&cool_ints[i], 01842 &sint32_artype, 01843 (AR_DATA *)&cool_ints[j], 01844 &sint32_artype); 01845 break; 01846 01847 case 46: 01848 case 64: 01849 shift = LS64(&cool_ints[j]); 01850 if ((shift > 0 && shift > 64) || 01851 (shift < 0 && shift < -64)) 01852 { /* status is undefined, result is zero */ 01853 act_status[j] = AR_STAT_UNDEFINED; 01854 act_result[j] = 0; 01855 } 01856 else 01857 { 01858 if (shift > 0) 01859 #if defined __sun 01860 act_result[j] = DSEXT64(shftl64(LU64(&cool_ints[i]), 01861 shift)); 01862 #else 01863 act_result[j] = DSEXT64(LU64(&cool_ints[i]) << 01864 shift); 01865 #endif 01866 else 01867 #if defined __sun 01868 act_result[j] = DSEXT64(shftr64(LU64(&cool_ints[i]), 01869 (-shift))); 01870 #else 01871 act_result[j] = DSEXT64(LU64(&cool_ints[i]) >> 01872 (-shift)); 01873 #endif 01874 01875 act_status[j] = is_zero64(act_result[j]) 01876 ? AR_STAT_ZERO 01877 : AR_STAT_OK; 01878 if (is_neg64(act_result[j])) 01879 act_status[j] |= AR_STAT_NEGATIVE; 01880 } 01881 01882 test_status[j] = AR_ishft((AR_DATA *)&test_result[j], 01883 &sint64_artype, 01884 (AR_DATA *)&cool_ints[i], 01885 &sint64_artype, 01886 (AR_DATA *)&cool_ints[j], 01887 &sint64_artype); 01888 break; 01889 } 01890 01891 if (LU64(&test_result[j]) != (UINT64)act_result[j]) 01892 { 01893 printf(" ERROR: incorrect result at %d,%d\n", i, j); 01894 abort(); 01895 } 01896 01897 if (act_status[j] != test_status[j]) 01898 { 01899 printf(" ERROR: incorrect status at %d,%d\n", i, j); 01900 abort(); 01901 } 01902 } 01903 } 01904 01905 printf("PASSED\n"); 01906 } 01907 01908 01909 #define TEST_ISHFT_TYPES \ 01910 do { \ 01911 int i, j, k; \ 01912 \ 01913 printf(" Testing: types %-10s: ", "ISHFT"); \ 01914 \ 01915 for (i=0; i<num_ar_types; i++) \ 01916 { \ 01917 for (j=0; j<num_ar_types; j++) \ 01918 { \ 01919 for (k=0; k<num_ar_types; k++) \ 01920 { \ 01921 act_status[k] = AR_STAT_OK; \ 01922 if (ar_types[i] != ar_types[j] || \ 01923 !IS_SUPPORTED_INT_TYPE(ar_types[i]) || \ 01924 !IS_SUPPORTED_INT_TYPE(ar_types[k])) \ 01925 act_status[k] = AR_STAT_INVALID_TYPE; \ 01926 \ 01927 test_status[k] = AR_ishft((AR_DATA *)&test_result[1], \ 01928 &ar_types[i], \ 01929 (AR_DATA *)&cool_ints[1], \ 01930 &ar_types[j], \ 01931 (AR_DATA *)&cool_ints[1], \ 01932 &ar_types[k]); \ 01933 \ 01934 if ((act_status[k] ^ test_status[k]) & \ 01935 AR_STAT_INVALID_TYPE) \ 01936 { \ 01937 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 01938 i, j, k); \ 01939 abort(); \ 01940 } \ 01941 } \ 01942 } \ 01943 } \ 01944 \ 01945 printf("PASSED\n"); \ 01946 } while (0) 01947 01948 01949 test_ishft() 01950 { 01951 01952 test_ishft_signed( 8); 01953 01954 test_ishft_signed(16); 01955 01956 test_ishft_signed(32); 01957 01958 test_ishft_signed(46); 01959 01960 test_ishft_signed(64); 01961 01962 TEST_ISHFT_TYPES; 01963 01964 } /* test_ishft */ 01965 01966 01967 #undef TEST_ISHFT_TYPES 01968 01969 01970 static 01971 void 01972 test_ishftc_signed(int size) 01973 { 01974 int i, j; 01975 01976 printf(" Testing: SIGNED %2d INT %-10s: ", size, "ISHFTC"); 01977 01978 if (size == 46) 01979 size = 64; 01980 01981 for (i=0; i<num_cool_ints; i++) 01982 { 01983 for (j=0; j<num_cool_ints; j++) 01984 { 01985 SINT64 width; 01986 SINT64 max_shift; 01987 SINT64 shift; 01988 SINT64 unch_mask; 01989 SINT64 rot_mask; 01990 01991 switch (size) 01992 { 01993 case 8: 01994 width = LS8(&cool_ints[j]); 01995 break; 01996 01997 case 16: 01998 width = LS16(&cool_ints[j]); 01999 break; 02000 02001 case 32: 02002 width = LS32(&cool_ints[j]); 02003 break; 02004 02005 case 46: 02006 case 64: 02007 width = LS64(&cool_ints[j]); 02008 break; 02009 } 02010 02011 if (width < 1 || width > size) { 02012 max_shift = 0; 02013 unch_mask = 0; 02014 rot_mask = 0; 02015 } 02016 else { 02017 max_shift = width + 1; 02018 #if defined(__sun) 02019 unch_mask = _mask(64 - width); 02020 #else 02021 unch_mask = MASKL(64 - width); 02022 #endif 02023 rot_mask = ~unch_mask; 02024 } 02025 02026 for (shift = -(max_shift + 1); shift < max_shift; shift++) 02027 { 02028 UINT64 opnd; 02029 ar_data shift_data; 02030 02031 test_result[j].part1 = 0; 02032 test_result[j].part2 = 0; 02033 test_result[j].part3 = 0; 02034 test_result[j].part4 = 0; 02035 02036 act_status[j] = AR_STAT_OK; 02037 02038 if (width < 1 || 02039 width > size || 02040 (shift < 0 && shift < -size) || 02041 (shift >= 0 && shift > size)) 02042 { /* status is undefined, result is zero */ 02043 act_status[j] = AR_STAT_UNDEFINED; 02044 act_result[j] = 0; 02045 } 02046 02047 switch (size) 02048 { 02049 case 8: 02050 if ((shift < 0 && shift < -width) || 02051 (shift >= 0 && shift > width)) 02052 { 02053 act_status[j] = AR_STAT_UNDEFINED; 02054 act_result[j] = 0; 02055 } 02056 else if (act_status[j] == AR_STAT_OK) 02057 { 02058 opnd = LU8(&cool_ints[i]); 02059 02060 if (shift == 0) 02061 act_result[j] = opnd; 02062 else if (shift > 0) 02063 act_result[j] = (opnd & unch_mask) | 02064 (((opnd << shift) | 02065 ((opnd & rot_mask) >> 02066 (width - shift))) & 02067 rot_mask); 02068 else 02069 act_result[j] = (opnd & unch_mask) | 02070 ((((opnd & rot_mask) >> -shift) | 02071 (opnd << (width + shift))) & 02072 rot_mask); 02073 act_result[j] = DSEXT8(act_result[j]); 02074 02075 act_status[j] = is_zero8(act_result[j]) 02076 ? AR_STAT_ZERO 02077 : AR_STAT_OK; 02078 if (is_neg8(act_result[j])) 02079 act_status[j] |= AR_STAT_NEGATIVE; 02080 } 02081 02082 ZERO_INT8_UPPER(&shift_data); 02083 shift_data.ar_i8.part5 = shift & 0xFF; 02084 02085 test_status[j] = AR_ishftc((AR_DATA *)&test_result[j], 02086 &sint8_artype, 02087 (AR_DATA *)&cool_ints[i], 02088 &sint8_artype, 02089 (AR_DATA *)&shift_data, 02090 &sint8_artype, 02091 (AR_DATA *)&cool_ints[j], 02092 &sint8_artype); 02093 break; 02094 02095 case 16: 02096 if ((shift < 0 && shift < -width) || 02097 (shift >= 0 && shift > width)) 02098 { 02099 act_status[j] = AR_STAT_UNDEFINED; 02100 act_result[j] = 0; 02101 } 02102 else if (act_status[j] == AR_STAT_OK) 02103 { 02104 opnd = LU16(&cool_ints[i]); 02105 02106 if (shift == 0) 02107 act_result[j] = opnd; 02108 else if (shift > 0) 02109 act_result[j] = (opnd & unch_mask) | 02110 (((opnd << shift) | 02111 ((opnd & rot_mask) >> 02112 (width - shift))) & 02113 rot_mask); 02114 else 02115 act_result[j] = (opnd & unch_mask) | 02116 ((((opnd & rot_mask) >> -shift) | 02117 (opnd << (width + shift))) & 02118 rot_mask); 02119 act_result[j] = DSEXT16(act_result[j]); 02120 02121 act_status[j] = is_zero16(act_result[j]) 02122 ? AR_STAT_ZERO 02123 : AR_STAT_OK; 02124 if (is_neg16(act_result[j])) 02125 act_status[j] |= AR_STAT_NEGATIVE; 02126 } 02127 02128 ZERO_INT16_UPPER(&shift_data); 02129 shift_data.ar_i64.part4 = shift & 0xFFFF; 02130 02131 test_status[j] = AR_ishftc((AR_DATA *)&test_result[j], 02132 &sint16_artype, 02133 (AR_DATA *)&cool_ints[i], 02134 &sint16_artype, 02135 (AR_DATA *)&shift_data, 02136 &sint16_artype, 02137 (AR_DATA *)&cool_ints[j], 02138 &sint16_artype); 02139 break; 02140 02141 case 32: 02142 if ((shift < 0 && shift < -width) || 02143 (shift >= 0 && shift > width)) 02144 { 02145 act_status[j] = AR_STAT_UNDEFINED; 02146 act_result[j] = 0; 02147 } 02148 else if (act_status[j] == AR_STAT_OK) 02149 { 02150 opnd = LU32(&cool_ints[i]); 02151 02152 if (shift == 0) 02153 act_result[j] = opnd; 02154 else if (shift > 0) 02155 act_result[j] = (opnd & unch_mask) | 02156 (((opnd << shift) | 02157 ((opnd & rot_mask) >> 02158 (width - shift))) & 02159 rot_mask); 02160 else 02161 act_result[j] = (opnd & unch_mask) | 02162 ((((opnd & rot_mask) >> -shift) | 02163 (opnd << (width + shift))) & 02164 rot_mask); 02165 act_result[j] = DSEXT32(act_result[j]); 02166 02167 act_status[j] = is_zero32(act_result[j]) 02168 ? AR_STAT_ZERO 02169 : AR_STAT_OK; 02170 if (is_neg32(act_result[j])) 02171 act_status[j] |= AR_STAT_NEGATIVE; 02172 } 02173 02174 ZERO_INT32_UPPER(&shift_data); 02175 shift_data.ar_i64.part3 = (shift >> 16) & 0xFFFF; 02176 shift_data.ar_i64.part4 = (shift ) & 0xFFFF; 02177 02178 test_status[j] = AR_ishftc((AR_DATA *)&test_result[j], 02179 &sint32_artype, 02180 (AR_DATA *)&cool_ints[i], 02181 &sint32_artype, 02182 (AR_DATA *)&shift_data, 02183 &sint32_artype, 02184 (AR_DATA *)&cool_ints[j], 02185 &sint32_artype); 02186 break; 02187 02188 case 46: 02189 case 64: 02190 if ((shift < 0 && shift < -width) || 02191 (shift >= 0 && shift > width)) 02192 { 02193 act_status[j] = AR_STAT_UNDEFINED; 02194 act_result[j] = 0; 02195 } 02196 else if (act_status[j] == AR_STAT_OK) 02197 { 02198 opnd = LU64(&cool_ints[i]); 02199 02200 if (shift == 0) 02201 act_result[j] = opnd; 02202 else if (shift > 0) 02203 #if defined __sun 02204 act_result[j] = (opnd & unch_mask) | 02205 ((shftl64(opnd, shift) | 02206 shftr64((opnd & rot_mask), 02207 (width - shift))) & 02208 rot_mask); 02209 #else 02210 act_result[j] = (opnd & unch_mask) | 02211 (((opnd << shift) | 02212 ((opnd & rot_mask) >> 02213 (width - shift))) & 02214 rot_mask); 02215 #endif 02216 else 02217 #if defined __sun 02218 act_result[j] = (opnd & unch_mask) | 02219 ((shftr64((opnd & rot_mask), 02220 (-shift)) | 02221 shftl64(opnd, (width + shift))) & 02222 rot_mask); 02223 #else 02224 act_result[j] = (opnd & unch_mask) | 02225 ((((opnd & rot_mask) >> -shift) | 02226 (opnd << (width + shift))) & 02227 rot_mask); 02228 #endif 02229 act_result[j] = DSEXT64(act_result[j]); 02230 02231 act_status[j] = is_zero64(act_result[j]) 02232 ? AR_STAT_ZERO 02233 : AR_STAT_OK; 02234 if (is_neg64(act_result[j])) 02235 act_status[j] |= AR_STAT_NEGATIVE; 02236 } 02237 02238 shift_data.ar_i64.part1 = (shift >> 48) & 0xFFFF; 02239 shift_data.ar_i64.part2 = (shift >> 32) & 0xFFFF; 02240 shift_data.ar_i64.part3 = (shift >> 16) & 0xFFFF; 02241 shift_data.ar_i64.part4 = (shift ) & 0xFFFF; 02242 02243 test_status[j] = AR_ishftc((AR_DATA *)&test_result[j], 02244 &sint64_artype, 02245 (AR_DATA *)&cool_ints[i], 02246 &sint64_artype, 02247 (AR_DATA *)&shift_data, 02248 &sint64_artype, 02249 (AR_DATA *)&cool_ints[j], 02250 &sint64_artype); 02251 break; 02252 } 02253 02254 if (LU64(&test_result[j]) != (UINT64)act_result[j]) 02255 { 02256 printf(" ERROR: incorrect result at %d,%d,%d\n", 02257 i, j, (int) shift); 02258 abort(); 02259 } 02260 02261 if (act_status[j] != test_status[j]) 02262 { 02263 printf(" ERROR: incorrect status at %d,%d,%d\n", 02264 i, j, (int) shift); 02265 abort(); 02266 } 02267 } 02268 } 02269 } 02270 02271 printf("PASSED\n"); 02272 } 02273 02274 02275 #define TEST_ISHFTC_TYPES \ 02276 do { \ 02277 int i, j, k, l; \ 02278 \ 02279 printf(" Testing: types %-10s: ", "ISHFTC"); \ 02280 \ 02281 for (i=0; i<num_ar_types; i++) \ 02282 { \ 02283 for (j=0; j<num_ar_types; j++) \ 02284 { \ 02285 for (k=0; k<num_ar_types; k++) \ 02286 { \ 02287 for (l=0; l<num_ar_types; l++) \ 02288 { \ 02289 act_status[l] = AR_STAT_OK; \ 02290 if (ar_types[i] != ar_types[j] || \ 02291 !IS_SUPPORTED_INT_TYPE(ar_types[i]) || \ 02292 !IS_SUPPORTED_INT_TYPE(ar_types[k]) || \ 02293 !IS_SUPPORTED_INT_TYPE(ar_types[l])) \ 02294 act_status[l] = AR_STAT_INVALID_TYPE; \ 02295 \ 02296 test_status[l] = AR_ishftc((AR_DATA *)&test_result[1],\ 02297 &ar_types[i], \ 02298 (AR_DATA *)&cool_ints[1], \ 02299 &ar_types[j], \ 02300 (AR_DATA *)&cool_ints[1], \ 02301 &ar_types[l], \ 02302 (AR_DATA *)&cool_ints[1], \ 02303 &ar_types[k]); \ 02304 \ 02305 if ((act_status[l] ^ test_status[l]) & \ 02306 AR_STAT_INVALID_TYPE) \ 02307 { \ 02308 printf(" ERROR: incorrect status at %d,%d,%d,%d" \ 02309 "\n", \ 02310 i, j, k, l); \ 02311 abort(); \ 02312 } \ 02313 } \ 02314 } \ 02315 } \ 02316 } \ 02317 \ 02318 printf("PASSED\n"); \ 02319 } while (0) 02320 02321 02322 test_ishftc() 02323 { 02324 02325 test_ishftc_signed( 8); 02326 02327 test_ishftc_signed(16); 02328 02329 test_ishftc_signed(32); 02330 02331 test_ishftc_signed(46); 02332 02333 test_ishftc_signed(64); 02334 02335 TEST_ISHFTC_TYPES; 02336 02337 } /* test_ishftc */ 02338 02339 02340 #undef TEST_ISHFTC_TYPES 02341 02342 02343 /*====================================================================== 02344 * 02345 * IBITS OPERATOR 02346 * 02347 */ 02348 02349 static 02350 void 02351 test_ibits_signed(int size) 02352 { 02353 int i, j; 02354 02355 printf(" Testing: SIGNED %2d INT %-10s: ", size, "IBITS"); 02356 02357 if (size == 46) 02358 size = 64; 02359 02360 for (i=0; i<num_cool_ints; i++) 02361 { 02362 for (j=0; j<num_cool_ints; j++) 02363 { 02364 SINT64 width; 02365 SINT64 max_shift; 02366 SINT64 shift; 02367 SINT64 mask; 02368 02369 switch (size) 02370 { 02371 case 8: 02372 width = LS8(&cool_ints[j]); 02373 break; 02374 02375 case 16: 02376 width = LS16(&cool_ints[j]); 02377 break; 02378 02379 case 32: 02380 width = LS32(&cool_ints[j]); 02381 break; 02382 02383 case 46: 02384 case 64: 02385 width = LS64(&cool_ints[j]); 02386 break; 02387 } 02388 02389 if (width < 0 || width > size) { 02390 max_shift = 0; 02391 mask = 0; 02392 } 02393 else { 02394 max_shift = width + 1; 02395 #if defined(__sun) 02396 mask = _mask(128 - width); 02397 #else 02398 mask = MASKR(width); 02399 #endif 02400 } 02401 02402 for (shift = -1; shift < max_shift + 1; shift++) 02403 { 02404 UINT64 opnd; 02405 ar_data shift_data; 02406 02407 test_result[j].part1 = 0; 02408 test_result[j].part2 = 0; 02409 test_result[j].part3 = 0; 02410 test_result[j].part4 = 0; 02411 02412 act_status[j] = AR_STAT_OK; 02413 02414 if (width < 0 || 02415 shift < 0 || shift > (size - width)) 02416 { /* status is undefined, result is zero */ 02417 act_status[j] = AR_STAT_UNDEFINED; 02418 act_result[j] = 0; 02419 } 02420 02421 switch (size) 02422 { 02423 case 8: 02424 if (act_status[j] == AR_STAT_OK) 02425 { 02426 opnd = LU8(&cool_ints[i]); 02427 02428 if (shift == 0) 02429 act_result[j] = opnd & mask; 02430 else if (shift == size) 02431 act_result[j] = 0; 02432 else 02433 act_result[j] = (opnd >> shift) & mask; 02434 02435 act_status[j] = is_zero8(act_result[j]) 02436 ? AR_STAT_ZERO 02437 : AR_STAT_OK; 02438 if (is_neg8(act_result[j])) 02439 act_status[j] |= AR_STAT_NEGATIVE; 02440 } 02441 02442 ZERO_INT8_UPPER(&shift_data); 02443 shift_data.ar_i8.part5 = shift & 0xFF; 02444 02445 test_status[j] = AR_ibits((AR_DATA *)&test_result[j], 02446 &sint8_artype, 02447 (AR_DATA *)&cool_ints[i], 02448 &sint8_artype, 02449 (AR_DATA *)&shift_data, 02450 &sint8_artype, 02451 (AR_DATA *)&cool_ints[j], 02452 &sint8_artype); 02453 break; 02454 02455 case 16: 02456 if (act_status[j] == AR_STAT_OK) 02457 { 02458 opnd = LU16(&cool_ints[i]); 02459 02460 if (shift == 0) 02461 act_result[j] = opnd & mask; 02462 else if (shift == size) 02463 act_result[j] = 0; 02464 else 02465 act_result[j] = (opnd >> shift) & mask; 02466 02467 act_status[j] = is_zero16(act_result[j]) 02468 ? AR_STAT_ZERO 02469 : AR_STAT_OK; 02470 if (is_neg16(act_result[j])) 02471 act_status[j] |= AR_STAT_NEGATIVE; 02472 } 02473 02474 ZERO_INT16_UPPER(&shift_data); 02475 shift_data.ar_i64.part4 = shift & 0xFFFF; 02476 02477 test_status[j] = AR_ibits((AR_DATA *)&test_result[j], 02478 &sint16_artype, 02479 (AR_DATA *)&cool_ints[i], 02480 &sint16_artype, 02481 (AR_DATA *)&shift_data, 02482 &sint16_artype, 02483 (AR_DATA *)&cool_ints[j], 02484 &sint16_artype); 02485 break; 02486 02487 case 32: 02488 if (act_status[j] == AR_STAT_OK) 02489 { 02490 opnd = LU32(&cool_ints[i]); 02491 02492 if (shift == 0) 02493 act_result[j] = opnd & mask; 02494 else if (shift == size) 02495 act_result[j] = 0; 02496 else 02497 act_result[j] = (opnd >> shift) & mask; 02498 02499 act_status[j] = is_zero32(act_result[j]) 02500 ? AR_STAT_ZERO 02501 : AR_STAT_OK; 02502 if (is_neg32(act_result[j])) 02503 act_status[j] |= AR_STAT_NEGATIVE; 02504 } 02505 02506 ZERO_INT32_UPPER(&shift_data); 02507 shift_data.ar_i64.part3 = (shift >> 16) & 0xFFFF; 02508 shift_data.ar_i64.part4 = (shift ) & 0xFFFF; 02509 02510 test_status[j] = AR_ibits((AR_DATA *)&test_result[j], 02511 &sint32_artype, 02512 (AR_DATA *)&cool_ints[i], 02513 &sint32_artype, 02514 (AR_DATA *)&shift_data, 02515 &sint32_artype, 02516 (AR_DATA *)&cool_ints[j], 02517 &sint32_artype); 02518 break; 02519 02520 case 46: 02521 case 64: 02522 if (act_status[j] == AR_STAT_OK) 02523 { 02524 opnd = LU64(&cool_ints[i]); 02525 02526 if (shift == 0) 02527 act_result[j] = opnd & mask; 02528 else if (shift == size) 02529 act_result[j] = 0; 02530 else 02531 #if defined __sun 02532 act_result[j] = shftr64(opnd, shift) & mask; 02533 #else 02534 act_result[j] = (opnd >> shift) & mask; 02535 #endif 02536 02537 act_status[j] = is_zero64(act_result[j]) 02538 ? AR_STAT_ZERO 02539 : AR_STAT_OK; 02540 if (is_neg64(act_result[j])) 02541 act_status[j] |= AR_STAT_NEGATIVE; 02542 } 02543 02544 shift_data.ar_i64.part1 = (shift >> 48) & 0xFFFF; 02545 shift_data.ar_i64.part2 = (shift >> 32) & 0xFFFF; 02546 shift_data.ar_i64.part3 = (shift >> 16) & 0xFFFF; 02547 shift_data.ar_i64.part4 = (shift ) & 0xFFFF; 02548 02549 test_status[j] = AR_ibits((AR_DATA *)&test_result[j], 02550 &sint64_artype, 02551 (AR_DATA *)&cool_ints[i], 02552 &sint64_artype, 02553 (AR_DATA *)&shift_data, 02554 &sint64_artype, 02555 (AR_DATA *)&cool_ints[j], 02556 &sint64_artype); 02557 break; 02558 } 02559 02560 if (LU64(&test_result[j]) != (UINT64)act_result[j]) 02561 { 02562 printf(" ERROR: incorrect result at %d,%d,%d\n", 02563 i, j, (int) shift); 02564 abort(); 02565 } 02566 02567 if (act_status[j] != test_status[j]) 02568 { 02569 printf(" ERROR: incorrect status at %d,%d,%d\n", 02570 i, j, (int) shift); 02571 abort(); 02572 } 02573 } 02574 } 02575 } 02576 02577 printf("PASSED\n"); 02578 } 02579 02580 02581 #define TEST_IBITS_TYPES \ 02582 do { \ 02583 int i, j, k, l; \ 02584 \ 02585 printf(" Testing: types %-10s: ", "IBITS"); \ 02586 \ 02587 for (i=0; i<num_ar_types; i++) \ 02588 { \ 02589 for (j=0; j<num_ar_types; j++) \ 02590 { \ 02591 for (k=0; k<num_ar_types; k++) \ 02592 { \ 02593 for (l=0; l<num_ar_types; l++) \ 02594 { \ 02595 act_status[l] = AR_STAT_OK; \ 02596 if (ar_types[i] != ar_types[j] || \ 02597 !IS_SUPPORTED_INT_TYPE(ar_types[i]) || \ 02598 !IS_SUPPORTED_INT_TYPE(ar_types[k]) || \ 02599 !IS_SUPPORTED_INT_TYPE(ar_types[l])) \ 02600 act_status[l] = AR_STAT_INVALID_TYPE; \ 02601 \ 02602 test_status[l] = AR_ibits((AR_DATA *)&test_result[1],\ 02603 &ar_types[i], \ 02604 (AR_DATA *)&cool_ints[1], \ 02605 &ar_types[j], \ 02606 (AR_DATA *)&cool_ints[1], \ 02607 &ar_types[l], \ 02608 (AR_DATA *)&cool_ints[1], \ 02609 &ar_types[k]); \ 02610 \ 02611 if ((act_status[l] ^ test_status[l]) & \ 02612 AR_STAT_INVALID_TYPE) \ 02613 { \ 02614 printf(" ERROR: incorrect status at %d,%d,%d,%d" \ 02615 "\n", \ 02616 i, j, k, l); \ 02617 abort(); \ 02618 } \ 02619 } \ 02620 } \ 02621 } \ 02622 } \ 02623 \ 02624 printf("PASSED\n"); \ 02625 } while (0) 02626 02627 02628 test_ibits() 02629 { 02630 02631 test_ibits_signed( 8); 02632 02633 test_ibits_signed(16); 02634 02635 test_ibits_signed(32); 02636 02637 test_ibits_signed(46); 02638 02639 test_ibits_signed(64); 02640 02641 TEST_IBITS_TYPES; 02642 02643 } /* test_ibits */ 02644 02645 02646 #undef TEST_IBITS_TYPES 02647 02648 02649 /*====================================================================== 02650 * 02651 * MASK/LEADZ/POP OPERATORS 02652 * 02653 */ 02654 02655 #define TEST_MASK_OP_SIGNED(size, max_shift) \ 02656 do { \ 02657 int i, j; \ 02658 \ 02659 printf(" Testing: SIGNED %2d INT %-10s: ", size, "_mask"); \ 02660 \ 02661 for (j=0; j<num_cool_ints; j++) \ 02662 { \ 02663 if (LS##size(&cool_ints[j]) > max_shift || \ 02664 LS##size(&cool_ints[j]) < 0) \ 02665 { /* status is undefined, result is zero */ \ 02666 act_result[j] = 0; \ 02667 act_status[j] = AR_STAT_UNDEFINED; \ 02668 } \ 02669 else \ 02670 { \ 02671 act_result[j] = DSEXT##size( \ 02672 _mask##size(LS##size(&cool_ints[j]))); \ 02673 act_status[j] = is_zero##size(act_result[j]) \ 02674 ? AR_STAT_ZERO : AR_STAT_OK; \ 02675 if (is_neg##size(act_result[j])) \ 02676 act_status[j] |= AR_STAT_NEGATIVE; \ 02677 } \ 02678 \ 02679 test_result[j].part1 = 0; \ 02680 test_result[j].part2 = 0; \ 02681 test_result[j].part3 = 0; \ 02682 test_result[j].part4 = 0; \ 02683 \ 02684 test_status[j] = AR_mask((AR_DATA *)&test_result[j], \ 02685 &sint##size##_artype, \ 02686 (AR_DATA *)&cool_ints[j], \ 02687 &sint##size##_artype); \ 02688 \ 02689 if (LU64(&test_result[j]) != act_result[j]) \ 02690 { \ 02691 printf(" ERROR: incorrect result at %d\n", j); \ 02692 abort(); \ 02693 } \ 02694 \ 02695 if (act_status[j] != test_status[j]) \ 02696 { \ 02697 printf(" ERROR: incorrect status at %d\n", j); \ 02698 abort(); \ 02699 } \ 02700 } \ 02701 \ 02702 printf("PASSED\n"); \ 02703 } while (0) 02704 02705 02706 #define TEST_MASK_OP_UNSIGNED(size, max_shift) \ 02707 do { \ 02708 int i, j; \ 02709 \ 02710 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "_mask"); \ 02711 \ 02712 for (j=0; j<num_cool_ints; j++) \ 02713 { \ 02714 if (LU##size(&cool_ints[j]) > max_shift) \ 02715 { /* status is undefined, result is zero */ \ 02716 act_result[j] = 0; \ 02717 act_status[j] = AR_STAT_UNDEFINED; \ 02718 } \ 02719 else \ 02720 { \ 02721 act_result[j] = DSEXT##size( \ 02722 _mask##size(LU##size(&cool_ints[j]))); \ 02723 act_status[j] = is_zero##size(act_result[j]) \ 02724 ? AR_STAT_ZERO : AR_STAT_OK; \ 02725 } \ 02726 \ 02727 test_result[j].part1 = 0; \ 02728 test_result[j].part2 = 0; \ 02729 test_result[j].part3 = 0; \ 02730 test_result[j].part4 = 0; \ 02731 \ 02732 test_status[j] = AR_mask((AR_DATA *)&test_result[j], \ 02733 &uint##size##_artype, \ 02734 (AR_DATA *)&cool_ints[j], \ 02735 &uint##size##_artype); \ 02736 \ 02737 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 02738 { \ 02739 printf(" ERROR: incorrect result at %d\n", j); \ 02740 abort(); \ 02741 } \ 02742 \ 02743 if (act_status[j] != test_status[j]) \ 02744 { \ 02745 printf(" ERROR: incorrect status at %d\n", j); \ 02746 abort(); \ 02747 } \ 02748 } \ 02749 \ 02750 printf("PASSED\n"); \ 02751 } while (0) 02752 02753 02754 #define TEST_MASK_OP_TYPES \ 02755 do { \ 02756 int j, k; \ 02757 \ 02758 printf(" Testing: types %-10s: ", "_mask"); \ 02759 \ 02760 for (j=0; j<num_ar_types; j++) \ 02761 { \ 02762 for (k=0; k<num_ar_types; k++) \ 02763 { \ 02764 act_status[k] = AR_STAT_OK; \ 02765 if (ar_types[j] != ar_types[k] || \ 02766 !IS_SUPPORTED_INT_TYPE(ar_types[j])) \ 02767 act_status[k] = AR_STAT_INVALID_TYPE; \ 02768 \ 02769 test_status[k] = AR_mask((AR_DATA *)&test_result[1], \ 02770 &ar_types[j], \ 02771 (AR_DATA *)&cool_ints[1], \ 02772 &ar_types[k]); \ 02773 \ 02774 if ((act_status[k] ^ test_status[k]) & \ 02775 AR_STAT_INVALID_TYPE) \ 02776 { \ 02777 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 02778 abort(); \ 02779 } \ 02780 } \ 02781 } \ 02782 \ 02783 printf("PASSED\n"); \ 02784 } while (0) 02785 02786 02787 #define TEST_LP_OP_SIGNED(size, opr, func) \ 02788 do { \ 02789 int i, j; \ 02790 \ 02791 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 02792 \ 02793 for (j=0; j<num_cool_ints; j++) \ 02794 { \ 02795 act_result[j] = opr##size(LS##size(&cool_ints[j])); \ 02796 \ 02797 act_status[j] = is_zero##size(act_result[j]) \ 02798 ? AR_STAT_ZERO : AR_STAT_OK; \ 02799 if (is_neg##size(act_result[j])) \ 02800 act_status[j] |= AR_STAT_NEGATIVE; \ 02801 \ 02802 test_result[j].part1 = 0; \ 02803 test_result[j].part2 = 0; \ 02804 test_result[j].part3 = 0; \ 02805 test_result[j].part4 = 0; \ 02806 \ 02807 test_status[j] = func((AR_DATA *)&test_result[j], \ 02808 &sint##size##_artype, \ 02809 (AR_DATA *)&cool_ints[j], \ 02810 &sint##size##_artype); \ 02811 \ 02812 if (LU64(&test_result[j]) != act_result[j]) \ 02813 { \ 02814 printf(" ERROR: incorrect result at %d\n", j); \ 02815 abort(); \ 02816 } \ 02817 \ 02818 if (act_status[j] != test_status[j]) \ 02819 { \ 02820 printf(" ERROR: incorrect status at %d\n", j); \ 02821 abort(); \ 02822 } \ 02823 } \ 02824 \ 02825 printf("PASSED\n"); \ 02826 } while (0) 02827 02828 02829 #define TEST_LP_OP_UNSIGNED(size, opr, func) \ 02830 do { \ 02831 int i, j; \ 02832 \ 02833 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 02834 \ 02835 for (j=0; j<num_cool_ints; j++) \ 02836 { \ 02837 act_result[j] = opr##size(LU##size(&cool_ints[j])); \ 02838 act_status[j] = is_zero##size(act_result[j]) \ 02839 ? AR_STAT_ZERO : AR_STAT_OK; \ 02840 \ 02841 test_result[j].part1 = 0; \ 02842 test_result[j].part2 = 0; \ 02843 test_result[j].part3 = 0; \ 02844 test_result[j].part4 = 0; \ 02845 \ 02846 test_status[j] = func((AR_DATA *)&test_result[j], \ 02847 &uint##size##_artype, \ 02848 (AR_DATA *)&cool_ints[j], \ 02849 &uint##size##_artype); \ 02850 \ 02851 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 02852 { \ 02853 printf(" ERROR: incorrect result at %d\n", j); \ 02854 abort(); \ 02855 } \ 02856 \ 02857 if (act_status[j] != test_status[j]) \ 02858 { \ 02859 printf(" ERROR: incorrect status at %d\n", j); \ 02860 abort(); \ 02861 } \ 02862 } \ 02863 \ 02864 printf("PASSED\n"); \ 02865 } while (0) 02866 02867 02868 #define TEST_LP_OP_TYPES(opr, func) \ 02869 do { \ 02870 int j, k; \ 02871 \ 02872 printf(" Testing: types %-10s: ", #opr); \ 02873 \ 02874 for (j=0; j<num_ar_types; j++) \ 02875 { \ 02876 for (k=0; k<num_ar_types; k++) \ 02877 { \ 02878 act_status[k] = AR_STAT_OK; \ 02879 if (!IS_SUPPORTED_INT_TYPE(ar_types[j]) || \ 02880 !IS_SUPPORTED_INT_TYPE(ar_types[k])) \ 02881 act_status[k] = AR_STAT_INVALID_TYPE; \ 02882 \ 02883 test_status[k] = func((AR_DATA *)&test_result[1], \ 02884 &ar_types[j], \ 02885 (AR_DATA *)&cool_ints[1], \ 02886 &ar_types[k]); \ 02887 \ 02888 if ((act_status[k] ^ test_status[k]) & \ 02889 AR_STAT_INVALID_TYPE) \ 02890 { \ 02891 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 02892 abort(); \ 02893 } \ 02894 } \ 02895 } \ 02896 \ 02897 printf("PASSED\n"); \ 02898 } while (0) 02899 02900 02901 test_mask() 02902 { 02903 02904 TEST_MASK_OP_SIGNED( 8, 16); 02905 TEST_MASK_OP_UNSIGNED( 8, 16); 02906 02907 TEST_MASK_OP_SIGNED( 16, 32); 02908 TEST_MASK_OP_UNSIGNED(16, 32); 02909 02910 TEST_MASK_OP_SIGNED( 32, 64); 02911 TEST_MASK_OP_UNSIGNED(32, 64); 02912 02913 TEST_MASK_OP_SIGNED( 46, 128); 02914 02915 TEST_MASK_OP_SIGNED( 64, 128); 02916 TEST_MASK_OP_UNSIGNED(64, 128); 02917 02918 TEST_MASK_OP_TYPES; 02919 02920 } /* test_mask */ 02921 02922 02923 test_leadz() 02924 { 02925 02926 TEST_LP_OP_SIGNED( 8, _leadz , AR_leadz ); 02927 TEST_LP_OP_UNSIGNED( 8, _leadz , AR_leadz ); 02928 02929 TEST_LP_OP_SIGNED( 16, _leadz , AR_leadz ); 02930 TEST_LP_OP_UNSIGNED(16, _leadz , AR_leadz ); 02931 02932 TEST_LP_OP_SIGNED( 32, _leadz , AR_leadz ); 02933 TEST_LP_OP_UNSIGNED(32, _leadz , AR_leadz ); 02934 02935 TEST_LP_OP_SIGNED( 46, _leadz , AR_leadz ); 02936 02937 TEST_LP_OP_SIGNED( 64, _leadz , AR_leadz ); 02938 TEST_LP_OP_UNSIGNED(64, _leadz , AR_leadz ); 02939 02940 TEST_LP_OP_TYPES( _leadz , AR_leadz ); 02941 02942 } /* test_leadz */ 02943 02944 02945 test_popcnt() 02946 { 02947 02948 TEST_LP_OP_SIGNED( 8, _popcnt, AR_popcnt); 02949 TEST_LP_OP_UNSIGNED( 8, _popcnt, AR_popcnt); 02950 02951 TEST_LP_OP_SIGNED( 16, _popcnt, AR_popcnt); 02952 TEST_LP_OP_UNSIGNED(16, _popcnt, AR_popcnt); 02953 02954 TEST_LP_OP_SIGNED( 32, _popcnt, AR_popcnt); 02955 TEST_LP_OP_UNSIGNED(32, _popcnt, AR_popcnt); 02956 02957 TEST_LP_OP_SIGNED( 46, _popcnt, AR_popcnt); 02958 02959 TEST_LP_OP_SIGNED( 64, _popcnt, AR_popcnt); 02960 TEST_LP_OP_UNSIGNED(64, _popcnt, AR_popcnt); 02961 02962 TEST_LP_OP_TYPES( _popcnt, AR_popcnt); 02963 02964 } /* test_popcnt */ 02965 02966 02967 test_poppar() 02968 { 02969 02970 TEST_LP_OP_SIGNED( 8, _poppar, AR_poppar); 02971 TEST_LP_OP_UNSIGNED( 8, _poppar, AR_poppar); 02972 02973 TEST_LP_OP_SIGNED( 16, _poppar, AR_poppar); 02974 TEST_LP_OP_UNSIGNED(16, _poppar, AR_poppar); 02975 02976 TEST_LP_OP_SIGNED( 32, _poppar, AR_poppar); 02977 TEST_LP_OP_UNSIGNED(32, _poppar, AR_poppar); 02978 02979 TEST_LP_OP_SIGNED( 46, _poppar, AR_poppar); 02980 02981 TEST_LP_OP_SIGNED( 64, _poppar, AR_poppar); 02982 TEST_LP_OP_UNSIGNED(64, _poppar, AR_poppar); 02983 02984 TEST_LP_OP_TYPES( _poppar, AR_poppar); 02985 02986 } /* test_poppar */ 02987 02988 02989 #undef TEST_MASK_SIGNED 02990 #undef TEST_MASK_UNSIGNED 02991 #undef TEST_MASK_TYPES 02992 #undef TEST_LP_OP_SIGNED 02993 #undef TEST_LP_OP_UNSIGNED 02994 #undef TEST_LP_OP_TYPES 02995 02996 02997 /*====================================================================== 02998 * 02999 * STATUS 03000 * 03001 */ 03002 03003 #define TEST_STATUS_SIGNED(size) \ 03004 do { \ 03005 int j; \ 03006 \ 03007 printf(" Testing: SIGNED %2d INT %-10s: ", size, "status"); \ 03008 \ 03009 for (j=0; j<num_cool_ints; j++) \ 03010 { \ 03011 act_status[j] = is_zero##size( \ 03012 DSEXT##size(LS##size(&cool_ints[j]))) \ 03013 ? AR_STAT_ZERO : AR_STAT_OK; \ 03014 \ 03015 if (is_neg##size(LS##size(&cool_ints[j]))) \ 03016 act_status[j] |= AR_STAT_NEGATIVE; \ 03017 \ 03018 test_status[j] = AR_status((AR_DATA *)&cool_ints[j], \ 03019 &sint##size##_artype); \ 03020 \ 03021 if (act_status[j] != test_status[j]) \ 03022 { \ 03023 printf(" ERROR: incorrect status at %d\n", j); \ 03024 abort(); \ 03025 } \ 03026 } \ 03027 \ 03028 printf("PASSED\n"); \ 03029 } while (0) 03030 03031 03032 #define TEST_STATUS_UNSIGNED(size) \ 03033 do { \ 03034 int j; \ 03035 \ 03036 printf(" Testing: SIGNED %2d INT %-10s: ", size, "status"); \ 03037 \ 03038 for (j=0; j<num_cool_ints; j++) \ 03039 { \ 03040 act_status[j] = is_zero##size(LU##size(&cool_ints[j])) \ 03041 ? AR_STAT_ZERO : AR_STAT_OK; \ 03042 \ 03043 test_status[j] = AR_status((AR_DATA *)&cool_ints[j], \ 03044 &uint##size##_artype); \ 03045 \ 03046 if (act_status[j] != test_status[j]) \ 03047 { \ 03048 printf(" ERROR: incorrect status at %d\n", j); \ 03049 abort(); \ 03050 } \ 03051 } \ 03052 \ 03053 printf("PASSED\n"); \ 03054 } while (0) 03055 03056 03057 #define TEST_STATUS_TYPES \ 03058 do { \ 03059 int k; \ 03060 \ 03061 printf(" Testing: types %-10s: ", "status"); \ 03062 \ 03063 for (k=0; k<num_ar_types; k++) \ 03064 { \ 03065 test_status[k] = AR_status((AR_DATA *)&cool_ints[1], \ 03066 &ar_types[k]); \ 03067 \ 03068 if (test_status[k] & AR_STAT_INVALID_TYPE) \ 03069 { \ 03070 printf(" ERROR: incorrect status at %d\n", k); \ 03071 abort(); \ 03072 } \ 03073 } \ 03074 \ 03075 printf("PASSED\n"); \ 03076 } while (0) 03077 03078 03079 test_arstatus() 03080 { 03081 03082 TEST_STATUS_SIGNED( 8); 03083 TEST_STATUS_UNSIGNED( 8); 03084 03085 TEST_STATUS_SIGNED( 16); 03086 TEST_STATUS_UNSIGNED(16); 03087 03088 TEST_STATUS_SIGNED( 32); 03089 TEST_STATUS_UNSIGNED(32); 03090 03091 TEST_STATUS_SIGNED( 46); 03092 03093 TEST_STATUS_SIGNED( 64); 03094 TEST_STATUS_UNSIGNED(64); 03095 03096 TEST_STATUS_TYPES; 03097 03098 } /* test_arstatus */ 03099 03100 03101 #undef TEST_STATUS_SIGNED 03102 #undef TEST_STATUS_UNSIGNED 03103 #undef TEST_STATUS_TYPES 03104 03105 03106 /*====================================================================== 03107 * 03108 * ARITHMETIC 03109 * 03110 */ 03111 03112 03113 #define TEST_ADDSUB_OP_SIGNED(size, opr, func) \ 03114 do { \ 03115 int i, j; \ 03116 \ 03117 printf(" Testing: SIGNED %2d INT %-10s: ", size, #opr); \ 03118 \ 03119 for (i=0; i<num_cool_ints; i++) \ 03120 { \ 03121 for (j=0; j<num_cool_ints; j++) \ 03122 { \ 03123 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) opr \ 03124 LS##size(&cool_ints[j])); \ 03125 \ 03126 act_status[j] = is_zero##size(act_result[j]) \ 03127 ? AR_STAT_ZERO : AR_STAT_OK; \ 03128 if (is_neg##size(act_result[j])) \ 03129 act_status[j] |= AR_STAT_NEGATIVE; \ 03130 \ 03131 /* Overflow check. */ \ 03132 if ((strcmp(#opr, "+") == 0 && \ 03133 is_neg##size(LS##size(&cool_ints[i])) == \ 03134 is_neg##size(LS##size(&cool_ints[j])) && \ 03135 is_neg##size(LS##size(&cool_ints[i])) != \ 03136 is_neg##size(act_result[j])) || \ 03137 (strcmp(#opr, "-") == 0 && \ 03138 is_neg##size(LS##size(&cool_ints[i])) != \ 03139 is_neg##size(LS##size(&cool_ints[j])) && \ 03140 is_neg##size(LS##size(&cool_ints[i])) != \ 03141 is_neg##size(act_result[j]))) \ 03142 { \ 03143 act_status[j] |= AR_STAT_OVERFLOW; \ 03144 } \ 03145 \ 03146 test_result[j].part1 = 0; \ 03147 test_result[j].part2 = 0; \ 03148 test_result[j].part3 = 0; \ 03149 test_result[j].part4 = 0; \ 03150 \ 03151 test_status[j] = func((AR_DATA *)&test_result[j], \ 03152 &sint##size##_artype, \ 03153 (AR_DATA *)&cool_ints[i], \ 03154 &sint##size##_artype, \ 03155 (AR_DATA *)&cool_ints[j], \ 03156 &sint##size##_artype); \ 03157 \ 03158 if (LU64(&test_result[j]) != act_result[j]) \ 03159 { \ 03160 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03161 abort(); \ 03162 } \ 03163 \ 03164 if (act_status[j] != test_status[j]) \ 03165 { \ 03166 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03167 abort(); \ 03168 } \ 03169 } \ 03170 } \ 03171 \ 03172 printf("PASSED\n"); \ 03173 } while (0) 03174 03175 03176 #define TEST_ADDSUB_OP_UNSIGNED(size, opr, func) \ 03177 do { \ 03178 int i, j; \ 03179 \ 03180 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, #opr); \ 03181 \ 03182 for (i=0; i<num_cool_ints; i++) \ 03183 { \ 03184 for (j=0; j<num_cool_ints; j++) \ 03185 { \ 03186 act_result[j] = DSEXT##size(LU##size(&cool_ints[i]) opr \ 03187 LU##size(&cool_ints[j])); \ 03188 \ 03189 act_status[j] = is_zero##size(act_result[j]) \ 03190 ? AR_STAT_ZERO : AR_STAT_OK; \ 03191 \ 03192 test_result[j].part1 = 0; \ 03193 test_result[j].part2 = 0; \ 03194 test_result[j].part3 = 0; \ 03195 test_result[j].part4 = 0; \ 03196 \ 03197 test_status[j] = func((AR_DATA *)&test_result[j], \ 03198 &uint##size##_artype, \ 03199 (AR_DATA *)&cool_ints[i], \ 03200 &uint##size##_artype, \ 03201 (AR_DATA *)&cool_ints[j], \ 03202 &uint##size##_artype); \ 03203 \ 03204 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 03205 { \ 03206 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03207 abort(); \ 03208 } \ 03209 \ 03210 if (act_status[j] != test_status[j]) \ 03211 { \ 03212 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03213 abort(); \ 03214 } \ 03215 } \ 03216 } \ 03217 \ 03218 printf("PASSED\n"); \ 03219 } while (0) 03220 03221 03222 #define TEST_ADDSUB_OP_TYPES(opr, func) \ 03223 do { \ 03224 int i, j, k; \ 03225 \ 03226 printf(" Testing: types %-10s: ", #opr); \ 03227 \ 03228 for (i=0; i<num_ar_types; i++) \ 03229 { \ 03230 for (j=0; j<num_ar_types; j++) \ 03231 { \ 03232 for (k=0; k<num_ar_types; k++) \ 03233 { \ 03234 act_status[k] = AR_STAT_OK; \ 03235 if (ar_types[i] != ar_types[j] || \ 03236 ar_types[j] != ar_types[k] || \ 03237 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 03238 act_status[k] = AR_STAT_INVALID_TYPE; \ 03239 \ 03240 test_status[k] = func((AR_DATA *)&test_result[1], \ 03241 &ar_types[i], \ 03242 (AR_DATA *)&cool_ints[1], \ 03243 &ar_types[j], \ 03244 (AR_DATA *)&cool_ints[1], \ 03245 &ar_types[k]); \ 03246 \ 03247 if ((act_status[k] ^ test_status[k]) & \ 03248 AR_STAT_INVALID_TYPE) \ 03249 { \ 03250 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 03251 i, j, k); \ 03252 abort(); \ 03253 } \ 03254 } \ 03255 } \ 03256 } \ 03257 \ 03258 printf("PASSED\n"); \ 03259 } while (0) 03260 03261 03262 test_add() 03263 { 03264 03265 TEST_ADDSUB_OP_SIGNED( 8, +, AR_add); 03266 TEST_ADDSUB_OP_UNSIGNED( 8, +, AR_add); 03267 03268 TEST_ADDSUB_OP_SIGNED( 16, +, AR_add); 03269 TEST_ADDSUB_OP_UNSIGNED(16, +, AR_add); 03270 03271 TEST_ADDSUB_OP_SIGNED( 32, +, AR_add); 03272 TEST_ADDSUB_OP_UNSIGNED(32, +, AR_add); 03273 03274 TEST_ADDSUB_OP_SIGNED( 46, +, AR_add); 03275 03276 TEST_ADDSUB_OP_SIGNED( 64, +, AR_add); 03277 TEST_ADDSUB_OP_UNSIGNED(64, +, AR_add); 03278 03279 TEST_ADDSUB_OP_TYPES( +, AR_add); 03280 03281 } /* test_add */ 03282 03283 03284 test_subtract() 03285 { 03286 03287 TEST_ADDSUB_OP_SIGNED( 8, -, AR_subtract); 03288 TEST_ADDSUB_OP_UNSIGNED( 8, -, AR_subtract); 03289 03290 TEST_ADDSUB_OP_SIGNED( 16, -, AR_subtract); 03291 TEST_ADDSUB_OP_UNSIGNED(16, -, AR_subtract); 03292 03293 TEST_ADDSUB_OP_SIGNED( 32, -, AR_subtract); 03294 TEST_ADDSUB_OP_UNSIGNED(32, -, AR_subtract); 03295 03296 TEST_ADDSUB_OP_SIGNED( 46, -, AR_subtract); 03297 03298 TEST_ADDSUB_OP_SIGNED( 64, -, AR_subtract); 03299 TEST_ADDSUB_OP_UNSIGNED(64, -, AR_subtract); 03300 03301 TEST_ADDSUB_OP_TYPES( -, AR_subtract); 03302 03303 } /* test_subtract */ 03304 03305 03306 #undef ADDSUB_OP_SIGNED 03307 #undef ADDSUB_OP_UNSIGNED 03308 #undef ADDSUB_OP_TYPES 03309 03310 03311 #define TEST_NEG_OP_SIGNED(size) \ 03312 do { \ 03313 int j; \ 03314 \ 03315 printf(" Testing: SIGNED %2d INT %-10s: ", size, "unary -"); \ 03316 \ 03317 for (j=0; j<num_cool_ints; j++) \ 03318 { \ 03319 act_result[j] = DSEXT##size(- LS##size(&cool_ints[j])); \ 03320 \ 03321 if (is_zero##size(act_result[j])) \ 03322 { /* result is zero */ \ 03323 act_status[j] = AR_STAT_ZERO; \ 03324 } \ 03325 else \ 03326 { /* result is non-zero */ \ 03327 if (is_neg##size(LS##size(&cool_ints[j])) == \ 03328 is_neg##size(act_result[j])) \ 03329 { /* The sign bit of the operand and the result match. \ 03330 Overflow except negate of maximum negative int. */ \ 03331 if(LS##size(&cool_ints[j]) != \ 03332 LS##size((AR_INT_64*)&act_result[j])) \ 03333 act_status[j] = AR_STAT_OVERFLOW; \ 03334 else \ 03335 act_status[j] = AR_STAT_SEMIVALID; \ 03336 } \ 03337 else \ 03338 { /* No overflow. */ \ 03339 act_status[j] = AR_STAT_OK; \ 03340 } \ 03341 } \ 03342 \ 03343 if (is_neg##size(act_result[j])) \ 03344 act_status[j] |= AR_STAT_NEGATIVE; \ 03345 \ 03346 test_result[j].part1 = 0; \ 03347 test_result[j].part2 = 0; \ 03348 test_result[j].part3 = 0; \ 03349 test_result[j].part4 = 0; \ 03350 \ 03351 test_status[j] = AR_negate((AR_DATA *)&test_result[j], \ 03352 &sint##size##_artype, \ 03353 (AR_DATA *)&cool_ints[j], \ 03354 &sint##size##_artype); \ 03355 \ 03356 if (LU64(&test_result[j]) != act_result[j]) \ 03357 { \ 03358 printf(" ERROR: incorrect result at %d\n", j); \ 03359 abort(); \ 03360 } \ 03361 \ 03362 if (act_status[j] != test_status[j]) \ 03363 { \ 03364 printf(" ERROR: incorrect status at %d\n", j); \ 03365 abort(); \ 03366 } \ 03367 } \ 03368 \ 03369 printf("PASSED\n"); \ 03370 } while (0) 03371 03372 03373 #define TEST_NEG_OP_UNSIGNED(size) \ 03374 do { \ 03375 int j; \ 03376 \ 03377 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "unary -"); \ 03378 \ 03379 for (j=0; j<num_cool_ints; j++) \ 03380 { \ 03381 act_result[j] = DSEXT##size(- LU##size(&cool_ints[j])); \ 03382 \ 03383 act_status[j] = is_zero##size(act_result[j]) \ 03384 ? AR_STAT_ZERO : AR_STAT_OK; \ 03385 \ 03386 test_result[j].part1 = 0; \ 03387 test_result[j].part2 = 0; \ 03388 test_result[j].part3 = 0; \ 03389 test_result[j].part4 = 0; \ 03390 \ 03391 test_status[j] = AR_negate((AR_DATA *)&test_result[j], \ 03392 &uint##size##_artype, \ 03393 (AR_DATA *)&cool_ints[j], \ 03394 &uint##size##_artype); \ 03395 \ 03396 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 03397 { \ 03398 printf(" ERROR: incorrect result at %d\n", j); \ 03399 abort(); \ 03400 } \ 03401 \ 03402 if (act_status[j] != test_status[j]) \ 03403 { \ 03404 printf(" ERROR: incorrect status at %d\n", j); \ 03405 abort(); \ 03406 } \ 03407 } \ 03408 \ 03409 printf("PASSED\n"); \ 03410 } while (0) 03411 03412 03413 #define TEST_NEG_OP_TYPES \ 03414 do { \ 03415 int j, k; \ 03416 \ 03417 printf(" Testing: types %-10s: ", "unary -"); \ 03418 \ 03419 for (j=0; j<num_ar_types; j++) \ 03420 { \ 03421 for (k=0; k<num_ar_types; k++) \ 03422 { \ 03423 act_status[k] = AR_STAT_OK; \ 03424 if (ar_types[j] != ar_types[k] || \ 03425 !IS_SUPPORTED_INT_TYPE(ar_types[j])) \ 03426 act_status[k] = AR_STAT_INVALID_TYPE; \ 03427 \ 03428 test_status[k] = AR_negate((AR_DATA *)&test_result[1], \ 03429 &ar_types[j], \ 03430 (AR_DATA *)&cool_ints[1], \ 03431 &ar_types[k]); \ 03432 \ 03433 if ((act_status[k] ^ test_status[k]) & \ 03434 AR_STAT_INVALID_TYPE) \ 03435 { \ 03436 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 03437 abort(); \ 03438 } \ 03439 } \ 03440 } \ 03441 \ 03442 printf("PASSED\n"); \ 03443 } while (0) 03444 03445 03446 test_negate() 03447 { 03448 03449 TEST_NEG_OP_SIGNED( 8); 03450 TEST_NEG_OP_UNSIGNED( 8); 03451 03452 TEST_NEG_OP_SIGNED( 16); 03453 TEST_NEG_OP_UNSIGNED(16); 03454 03455 TEST_NEG_OP_SIGNED( 32); 03456 TEST_NEG_OP_UNSIGNED(32); 03457 03458 TEST_NEG_OP_SIGNED( 46); 03459 03460 TEST_NEG_OP_SIGNED( 64); 03461 TEST_NEG_OP_UNSIGNED(64); 03462 03463 TEST_NEG_OP_TYPES; 03464 03465 } /* test_negate */ 03466 03467 03468 #undef TEST_NEG_SIGNED 03469 #undef TEST_NEG_UNSIGNED 03470 #undef TEST_NEG_TYPES 03471 03472 03473 #define TEST_ABS_OP_SIGNED(size) \ 03474 do { \ 03475 int j; \ 03476 \ 03477 printf(" Testing: SIGNED %2d INT %-10s: ", size, "abs"); \ 03478 \ 03479 for (j=0; j<num_cool_ints; j++) \ 03480 { \ 03481 if (is_neg##size(LS##size(&cool_ints[j]))) \ 03482 act_result[j] = DSEXT##size( - LS##size(&cool_ints[j])); \ 03483 else \ 03484 act_result[j] = DSEXT##size( LS##size(&cool_ints[j])); \ 03485 \ 03486 act_status[j] = is_zero##size(act_result[j]) \ 03487 ? AR_STAT_ZERO : AR_STAT_OK; \ 03488 \ 03489 if (is_neg##size(act_result[j])) \ 03490 { /* The result can be negative only if it overflows. */ \ 03491 act_status[j] |= AR_STAT_NEGATIVE; \ 03492 act_status[j] |= AR_STAT_OVERFLOW; \ 03493 } \ 03494 \ 03495 test_result[j].part1 = 0; \ 03496 test_result[j].part2 = 0; \ 03497 test_result[j].part3 = 0; \ 03498 test_result[j].part4 = 0; \ 03499 \ 03500 test_status[j] = AR_abs((AR_DATA *)&test_result[j], \ 03501 &sint##size##_artype, \ 03502 (AR_DATA *)&cool_ints[j], \ 03503 &sint##size##_artype); \ 03504 \ 03505 if (LU64(&test_result[j]) != act_result[j]) \ 03506 { \ 03507 printf(" ERROR: incorrect result at %d\n", j); \ 03508 abort(); \ 03509 } \ 03510 \ 03511 if (act_status[j] != test_status[j]) \ 03512 { \ 03513 printf(" ERROR: incorrect status at %d\n", j); \ 03514 abort(); \ 03515 } \ 03516 } \ 03517 \ 03518 printf("PASSED\n"); \ 03519 } while (0) 03520 03521 03522 #define TEST_ABS_OP_UNSIGNED(size) \ 03523 do { \ 03524 int j; \ 03525 \ 03526 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "abs"); \ 03527 \ 03528 for (j=0; j<num_cool_ints; j++) \ 03529 { \ 03530 act_result[j] = DSEXT##size(LU64(&cool_ints[j])); \ 03531 \ 03532 act_status[j] = is_zero##size(act_result[j]) \ 03533 ? AR_STAT_ZERO : AR_STAT_OK; \ 03534 \ 03535 test_result[j].part1 = 0; \ 03536 test_result[j].part2 = 0; \ 03537 test_result[j].part3 = 0; \ 03538 test_result[j].part4 = 0; \ 03539 \ 03540 test_status[j] = AR_abs((AR_DATA *)&test_result[j], \ 03541 &uint##size##_artype, \ 03542 (AR_DATA *)&cool_ints[j], \ 03543 &uint##size##_artype); \ 03544 \ 03545 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 03546 { \ 03547 printf(" ERROR: incorrect result at %d\n", j); \ 03548 abort(); \ 03549 } \ 03550 \ 03551 if (act_status[j] != test_status[j]) \ 03552 { \ 03553 printf(" ERROR: incorrect status at %d\n", j); \ 03554 abort(); \ 03555 } \ 03556 } \ 03557 \ 03558 printf("PASSED\n"); \ 03559 } while (0) 03560 03561 03562 #define TEST_ABS_OP_TYPES \ 03563 do { \ 03564 int j, k; \ 03565 \ 03566 printf(" Testing: types %-10s: ", "abs"); \ 03567 \ 03568 for (j=0; j<num_ar_types; j++) \ 03569 { \ 03570 for (k=0; k<num_ar_types; k++) \ 03571 { \ 03572 act_status[k] = AR_STAT_OK; \ 03573 if (ar_types[j] != ar_types[k] || \ 03574 !IS_SUPPORTED_INT_TYPE(ar_types[j])) \ 03575 act_status[k] = AR_STAT_INVALID_TYPE; \ 03576 \ 03577 test_status[k] = AR_abs((AR_DATA *)&test_result[1], \ 03578 &ar_types[j], \ 03579 (AR_DATA *)&cool_ints[1], \ 03580 &ar_types[k]); \ 03581 \ 03582 if ((act_status[k] ^ test_status[k]) & \ 03583 AR_STAT_INVALID_TYPE) \ 03584 { \ 03585 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 03586 abort(); \ 03587 } \ 03588 } \ 03589 } \ 03590 \ 03591 printf("PASSED\n"); \ 03592 } while (0) 03593 03594 03595 test_abs() 03596 { 03597 03598 TEST_ABS_OP_SIGNED( 8); 03599 TEST_ABS_OP_UNSIGNED( 8); 03600 03601 TEST_ABS_OP_SIGNED( 16); 03602 TEST_ABS_OP_UNSIGNED(16); 03603 03604 TEST_ABS_OP_SIGNED( 32); 03605 TEST_ABS_OP_UNSIGNED(32); 03606 03607 TEST_ABS_OP_SIGNED( 46); 03608 03609 TEST_ABS_OP_SIGNED( 64); 03610 TEST_ABS_OP_UNSIGNED(64); 03611 03612 TEST_ABS_OP_TYPES; 03613 03614 } /* test_abs */ 03615 03616 03617 #undef TEST_ABS_OP_SIGNED 03618 #undef TEST_ABS_OP_UNSIGNED 03619 #undef TEST_ABS_OP_TYPES 03620 03621 03622 #define TEST_MUL_OP_SIGNED(size) \ 03623 do { \ 03624 int i, j; \ 03625 \ 03626 printf(" Testing: SIGNED %2d INT %-10s: ", size, "*"); \ 03627 \ 03628 for (i=0; i<num_cool_ints; i++) \ 03629 { \ 03630 for (j=0; j<num_cool_ints; j++) \ 03631 { \ 03632 if (size == 46) \ 03633 act_result[j] = (SINT64)(LS64(&cool_ints[i]) * \ 03634 LS64(&cool_ints[j])); \ 03635 else \ 03636 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) * \ 03637 LS##size(&cool_ints[j])); \ 03638 \ 03639 act_status[j] = is_zero##size(act_result[j]) \ 03640 ? AR_STAT_ZERO : AR_STAT_OK; \ 03641 if (is_neg##size(act_result[j])) \ 03642 act_status[j] |= AR_STAT_NEGATIVE; \ 03643 \ 03644 /* Overflow checks. */ \ 03645 if (size == 46) \ 03646 { \ 03647 if (((LS64(&cool_ints[i]) & ((~((SINT64) 0)) << 45)) \ 03648 != 0) && \ 03649 ((LS64(&cool_ints[i]) & ((~((SINT64) 0)) << 45)) \ 03650 != ((~((SINT64) 0)) << 45))) \ 03651 { /* first operand too big to be represented as a \ 03652 46-bit int */ \ 03653 act_status[j] |= AR_STAT_OVERFLOW; \ 03654 } \ 03655 else \ 03656 if (((LS64(&cool_ints[j]) & ((~((SINT64) 0)) << 45)) \ 03657 != 0) && \ 03658 ((LS64(&cool_ints[j]) & ((~((SINT64) 0)) << 45)) \ 03659 != ((~((SINT64) 0)) << 45))) \ 03660 { /* second operand too big to be represented as a \ 03661 46-bit int */ \ 03662 act_status[j] |= AR_STAT_OVERFLOW; \ 03663 } \ 03664 else \ 03665 if (((act_result[j] & ((~((SINT64) 0)) << 45)) \ 03666 != 0) && \ 03667 ((act_result[j] & ((~((SINT64) 0)) << 45)) \ 03668 != ((~((SINT64) 0)) << 45))) \ 03669 { /* result too big to be represented as a \ 03670 46-bit int */ \ 03671 act_status[j] |= AR_STAT_OVERFLOW; \ 03672 } \ 03673 } \ 03674 \ 03675 if (LS##size(&cool_ints[i]) != 0 && \ 03676 LS##size(&cool_ints[j]) != 0) \ 03677 { /* Check for overflow if neither operand is zero. \ 03678 (If either is zero, an overflow can not occur \ 03679 and dealing with zeros in the checks below \ 03680 causes headaches.) */ \ 03681 if (is_neg##size(LS##size(&cool_ints[i]) ^ \ 03682 LS##size(&cool_ints[j]) ^ \ 03683 act_result[j])) \ 03684 { /* The sign of the result does not match the XOR \ 03685 of the signs of the two operands. Overflow. */ \ 03686 act_status[j] |= AR_STAT_OVERFLOW; \ 03687 } \ 03688 else if ((SEXT##size(act_result[j]) / \ 03689 LS##size(&cool_ints[i])) != \ 03690 LS##size(&cool_ints[j])) \ 03691 { /* The above test does not catch all overflows. \ 03692 This test catches all remaining overflows by \ 03693 checking to see that the result divided by the \ 03694 the first operand equals the second operand. */ \ 03695 act_status[j] |= AR_STAT_OVERFLOW; \ 03696 } \ 03697 } \ 03698 \ 03699 test_result[j].part1 = 0; \ 03700 test_result[j].part2 = 0; \ 03701 test_result[j].part3 = 0; \ 03702 test_result[j].part4 = 0; \ 03703 \ 03704 test_status[j] = AR_multiply((AR_DATA *)&test_result[j], \ 03705 &sint##size##_artype, \ 03706 (AR_DATA *)&cool_ints[i], \ 03707 &sint##size##_artype, \ 03708 (AR_DATA *)&cool_ints[j], \ 03709 &sint##size##_artype); \ 03710 \ 03711 if (LU64(&test_result[j]) != act_result[j]) \ 03712 { \ 03713 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03714 abort(); \ 03715 } \ 03716 \ 03717 if (act_status[j] != test_status[j]) \ 03718 { \ 03719 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03720 abort(); \ 03721 } \ 03722 } \ 03723 } \ 03724 \ 03725 printf("PASSED\n"); \ 03726 } while (0) 03727 03728 03729 #define TEST_MUL_OP_UNSIGNED(size) \ 03730 do { \ 03731 int i, j; \ 03732 \ 03733 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "*"); \ 03734 \ 03735 for (i=0; i<num_cool_ints; i++) \ 03736 { \ 03737 for (j=0; j<num_cool_ints; j++) \ 03738 { \ 03739 act_result[j] = DSEXT##size(LU##size(&cool_ints[i]) * \ 03740 LU##size(&cool_ints[j])); \ 03741 \ 03742 act_status[j] = is_zero##size(act_result[j]) \ 03743 ? AR_STAT_ZERO : AR_STAT_OK; \ 03744 \ 03745 test_result[j].part1 = 0; \ 03746 test_result[j].part2 = 0; \ 03747 test_result[j].part3 = 0; \ 03748 test_result[j].part4 = 0; \ 03749 \ 03750 test_status[j] = AR_multiply((AR_DATA *)&test_result[j], \ 03751 &uint##size##_artype, \ 03752 (AR_DATA *)&cool_ints[i], \ 03753 &uint##size##_artype, \ 03754 (AR_DATA *)&cool_ints[j], \ 03755 &uint##size##_artype); \ 03756 \ 03757 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 03758 { \ 03759 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03760 abort(); \ 03761 } \ 03762 \ 03763 if (act_status[j] != test_status[j]) \ 03764 { \ 03765 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03766 abort(); \ 03767 } \ 03768 } \ 03769 } \ 03770 \ 03771 printf("PASSED\n"); \ 03772 } while (0) 03773 03774 03775 #define TEST_MUL_OP_TYPES \ 03776 do { \ 03777 int i, j, k; \ 03778 \ 03779 printf(" Testing: types %-10s: ", "*"); \ 03780 \ 03781 for (i=0; i<num_ar_types; i++) \ 03782 { \ 03783 for (j=0; j<num_ar_types; j++) \ 03784 { \ 03785 for (k=0; k<num_ar_types; k++) \ 03786 { \ 03787 act_status[k] = AR_STAT_OK; \ 03788 if (ar_types[i] != ar_types[j] || \ 03789 ar_types[j] != ar_types[k] || \ 03790 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 03791 act_status[k] = AR_STAT_INVALID_TYPE; \ 03792 \ 03793 test_status[k] = AR_multiply((AR_DATA *)&test_result[1], \ 03794 &ar_types[i], \ 03795 (AR_DATA *)&cool_ints[1], \ 03796 &ar_types[j], \ 03797 (AR_DATA *)&cool_ints[1], \ 03798 &ar_types[k]); \ 03799 \ 03800 if ((act_status[k] ^ test_status[k]) & \ 03801 AR_STAT_INVALID_TYPE) \ 03802 { \ 03803 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 03804 i, j, k); \ 03805 abort(); \ 03806 } \ 03807 } \ 03808 } \ 03809 } \ 03810 \ 03811 printf("PASSED\n"); \ 03812 } while (0) 03813 03814 03815 test_multiply() 03816 { 03817 03818 TEST_MUL_OP_SIGNED( 8); 03819 TEST_MUL_OP_UNSIGNED( 8); 03820 03821 TEST_MUL_OP_SIGNED( 16); 03822 TEST_MUL_OP_UNSIGNED(16); 03823 03824 TEST_MUL_OP_SIGNED( 32); 03825 TEST_MUL_OP_UNSIGNED(32); 03826 03827 TEST_MUL_OP_SIGNED( 46); 03828 03829 TEST_MUL_OP_SIGNED( 64); 03830 TEST_MUL_OP_UNSIGNED(64); 03831 03832 TEST_MUL_OP_TYPES; 03833 03834 } /* test_multiply */ 03835 03836 03837 #undef TEST_MUL_OP_SIGNED 03838 #undef TEST_MUL_OP_UNSIGNED 03839 #undef TEST_MUL_OP_TYPES 03840 03841 03842 #define TEST_DIV_OP_SIGNED(size) \ 03843 do { \ 03844 int i, j; \ 03845 \ 03846 printf(" Testing: SIGNED %2d INT %-10s: ", size, "/"); \ 03847 \ 03848 for (i=0; i<num_cool_ints; i++) \ 03849 { \ 03850 for (j=0; j<num_cool_ints; j++) \ 03851 { \ 03852 act_status[j] = AR_STAT_OK; \ 03853 \ 03854 if (LS##size(&cool_ints[j]) == 0) \ 03855 { /* divide by zero */ \ 03856 act_result[j] = 0; \ 03857 act_status[j] |= AR_STAT_OVERFLOW; \ 03858 } \ 03859 else if (size == 46) \ 03860 { /* 46-bit divide */ \ 03861 /* not divide by zero */ \ 03862 /* Perform division using 64-bit precision to avoid \ 03863 "fastmd" problems. */ \ 03864 act_result[j] = (SINT64)(LS64(&cool_ints[i]) / \ 03865 LS64(&cool_ints[j])); \ 03866 \ 03867 if (((LS64(&cool_ints[i]) & ((~((SINT64) 0)) << 45)) \ 03868 != 0) && \ 03869 ((LS64(&cool_ints[i]) & ((~((SINT64) 0)) << 45)) \ 03870 != ((~((SINT64) 0)) << 45))) \ 03871 { /* first operand too big to be represented as a \ 03872 46-bit int */ \ 03873 act_status[j] |= AR_STAT_OVERFLOW; \ 03874 } \ 03875 else if (((LS64(&cool_ints[j]) & ((~((SINT64) 0)) << 45))\ 03876 != 0) && \ 03877 ((LS64(&cool_ints[j]) & ((~((SINT64) 0)) << 45))\ 03878 != ((~((SINT64) 0)) << 45))) \ 03879 { /* second operand too big to be represented as a \ 03880 46-bit int */ \ 03881 act_status[j] |= AR_STAT_OVERFLOW; \ 03882 } \ 03883 else if (((act_result[j] & ((~((SINT64) 0)) << 45)) \ 03884 != 0) && \ 03885 ((act_result[j] & ((~((SINT64) 0)) << 45)) \ 03886 != ((~((SINT64) 0)) << 45))) \ 03887 { /* result too big to be represented as a \ 03888 46-bit int */ \ 03889 act_status[j] |= AR_STAT_OVERFLOW; \ 03890 } \ 03891 else if (!is_zero##size(act_result [j]) && \ 03892 (LS64(&cool_ints[i]) ^ \ 03893 LS64(&cool_ints[j]) ^ \ 03894 act_result[j]) < 0) \ 03895 { /* Overflow. */ \ 03896 act_status[j] |= AR_STAT_OVERFLOW; \ 03897 } \ 03898 } \ 03899 else \ 03900 { /* not 46-bit divide */ \ 03901 /* not divide by zero */ \ 03902 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) / \ 03903 LS##size(&cool_ints[j])); \ 03904 \ 03905 if (!is_zero##size(act_result[j]) && \ 03906 is_neg##size(LS##size(&cool_ints[i]) ^ \ 03907 LS##size(&cool_ints[j]) ^ \ 03908 act_result[j])) \ 03909 { /* Overflow. */ \ 03910 act_status[j] |= AR_STAT_OVERFLOW; \ 03911 } \ 03912 } \ 03913 \ 03914 if (is_zero##size(act_result[j])) \ 03915 act_status[j] |= AR_STAT_ZERO; \ 03916 \ 03917 if (is_neg##size(act_result[j])) \ 03918 act_status[j] |= AR_STAT_NEGATIVE; \ 03919 \ 03920 test_result[j].part1 = 0; \ 03921 test_result[j].part2 = 0; \ 03922 test_result[j].part3 = 0; \ 03923 test_result[j].part4 = 0; \ 03924 \ 03925 test_status[j] = AR_divide((AR_DATA *)&test_result[j], \ 03926 &sint##size##_artype, \ 03927 (AR_DATA *)&cool_ints[i], \ 03928 &sint##size##_artype, \ 03929 (AR_DATA *)&cool_ints[j], \ 03930 &sint##size##_artype); \ 03931 \ 03932 if (LU64(&test_result[j]) != act_result[j]) \ 03933 { \ 03934 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03935 abort(); \ 03936 } \ 03937 \ 03938 if (act_status[j] != test_status[j]) \ 03939 { \ 03940 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03941 abort(); \ 03942 } \ 03943 } \ 03944 } \ 03945 \ 03946 printf("PASSED\n"); \ 03947 } while (0) 03948 03949 03950 #define TEST_DIV_OP_UNSIGNED(size) \ 03951 do { \ 03952 int i, j; \ 03953 \ 03954 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "/"); \ 03955 \ 03956 for (i=0; i<num_cool_ints; i++) \ 03957 { \ 03958 for (j=0; j<num_cool_ints; j++) \ 03959 { \ 03960 act_status[j] = AR_STAT_OK; \ 03961 \ 03962 if (LU##size(&cool_ints[j]) == 0) \ 03963 { /* divide by zero */ \ 03964 act_result[j] = 0; \ 03965 act_status[j] |= AR_STAT_OVERFLOW; \ 03966 } \ 03967 else \ 03968 { /* not divide by zero */ \ 03969 act_result[j] = LU##size(&cool_ints[i]) / \ 03970 LU##size(&cool_ints[j]); \ 03971 } \ 03972 \ 03973 if (is_zero##size(act_result[j])) \ 03974 act_status[j] |= AR_STAT_ZERO; \ 03975 \ 03976 test_result[j].part1 = 0; \ 03977 test_result[j].part2 = 0; \ 03978 test_result[j].part3 = 0; \ 03979 test_result[j].part4 = 0; \ 03980 \ 03981 test_status[j] = AR_divide((AR_DATA *)&test_result[j], \ 03982 &uint##size##_artype, \ 03983 (AR_DATA *)&cool_ints[i], \ 03984 &uint##size##_artype, \ 03985 (AR_DATA *)&cool_ints[j], \ 03986 &uint##size##_artype); \ 03987 \ 03988 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 03989 { \ 03990 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 03991 abort(); \ 03992 } \ 03993 \ 03994 if (act_status[j] != test_status[j]) \ 03995 { \ 03996 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 03997 abort(); \ 03998 } \ 03999 } \ 04000 } \ 04001 \ 04002 printf("PASSED\n"); \ 04003 } while (0) 04004 04005 04006 #define TEST_DIV_OP_TYPES \ 04007 do { \ 04008 int i, j, k; \ 04009 \ 04010 printf(" Testing: types %-10s: ", "/"); \ 04011 \ 04012 for (i=0; i<num_ar_types; i++) \ 04013 { \ 04014 for (j=0; j<num_ar_types; j++) \ 04015 { \ 04016 for (k=0; k<num_ar_types; k++) \ 04017 { \ 04018 act_status[k] = AR_STAT_OK; \ 04019 if (ar_types[i] != ar_types[j] || \ 04020 ar_types[j] != ar_types[k] || \ 04021 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 04022 act_status[k] = AR_STAT_INVALID_TYPE; \ 04023 \ 04024 test_status[k] = AR_divide((AR_DATA *)&test_result[1], \ 04025 &ar_types[i], \ 04026 (AR_DATA *)&cool_ints[1], \ 04027 &ar_types[j], \ 04028 (AR_DATA *)&cool_ints[1], \ 04029 &ar_types[k]); \ 04030 \ 04031 if ((act_status[k] ^ test_status[k]) & \ 04032 AR_STAT_INVALID_TYPE) \ 04033 { \ 04034 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 04035 i, j, k); \ 04036 abort(); \ 04037 } \ 04038 } \ 04039 } \ 04040 } \ 04041 \ 04042 printf("PASSED\n"); \ 04043 } while (0) 04044 04045 04046 test_divide() 04047 { 04048 TEST_DIV_OP_SIGNED( 8); 04049 TEST_DIV_OP_UNSIGNED( 8); 04050 04051 TEST_DIV_OP_SIGNED( 16); 04052 TEST_DIV_OP_UNSIGNED(16); 04053 04054 TEST_DIV_OP_SIGNED( 32); 04055 TEST_DIV_OP_UNSIGNED(32); 04056 04057 TEST_DIV_OP_SIGNED( 46); 04058 04059 TEST_DIV_OP_SIGNED( 64); 04060 TEST_DIV_OP_UNSIGNED(64); 04061 04062 TEST_DIV_OP_TYPES; 04063 04064 } /* test_divide */ 04065 04066 04067 #undef TEST_DIV_OP_SIGNED 04068 #undef TEST_DIV_OP_UNSIGNED 04069 #undef TEST_DIV_OP_TYPES 04070 04071 04072 #define TEST_MOD_OP_SIGNED(size) \ 04073 do { \ 04074 int i, j; \ 04075 \ 04076 printf(" Testing: SIGNED %2d INT %-10s: ", size, "%"); \ 04077 \ 04078 for (i=0; i<num_cool_ints; i++) \ 04079 { \ 04080 for (j=0; j<num_cool_ints; j++) \ 04081 { \ 04082 act_status[j] = AR_STAT_OK; \ 04083 \ 04084 if (LS##size(&cool_ints[j]) == 0) \ 04085 { /* modulo by zero */ \ 04086 act_result[j] = 0; \ 04087 act_status[j] |= AR_STAT_OVERFLOW; \ 04088 } \ 04089 else \ 04090 { /* not modulo by zero */ \ 04091 act_result[j] = DSEXT##size(LS##size(&cool_ints[i]) % \ 04092 LS##size(&cool_ints[j])); \ 04093 \ 04094 if (!is_zero##size(act_result[j]) && \ 04095 is_neg##size(LS##size(&cool_ints[i]) ^ \ 04096 act_result[j])) \ 04097 { /* Overflow. */ \ 04098 act_status[j] |= AR_STAT_OVERFLOW; \ 04099 } \ 04100 } \ 04101 \ 04102 if (is_zero##size(act_result[j])) \ 04103 act_status[j] |= AR_STAT_ZERO; \ 04104 \ 04105 if (is_neg##size(act_result[j])) \ 04106 act_status[j] |= AR_STAT_NEGATIVE; \ 04107 \ 04108 test_result[j].part1 = 0; \ 04109 test_result[j].part2 = 0; \ 04110 test_result[j].part3 = 0; \ 04111 test_result[j].part4 = 0; \ 04112 \ 04113 test_status[j] = AR_modulo((AR_DATA *)&test_result[j], \ 04114 &sint##size##_artype, \ 04115 (AR_DATA *)&cool_ints[i], \ 04116 &sint##size##_artype, \ 04117 (AR_DATA *)&cool_ints[j], \ 04118 &sint##size##_artype); \ 04119 \ 04120 if (LU64(&test_result[j]) != act_result[j]) \ 04121 { \ 04122 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 04123 abort(); \ 04124 } \ 04125 \ 04126 if (act_status[j] != test_status[j]) \ 04127 { \ 04128 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 04129 abort(); \ 04130 } \ 04131 } \ 04132 } \ 04133 \ 04134 printf("PASSED\n"); \ 04135 } while (0) 04136 04137 04138 #define TEST_MOD_OP_UNSIGNED(size) \ 04139 do { \ 04140 int i, j; \ 04141 \ 04142 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "%"); \ 04143 \ 04144 for (i=0; i<num_cool_ints; i++) \ 04145 { \ 04146 for (j=0; j<num_cool_ints; j++) \ 04147 { \ 04148 act_status[j] = AR_STAT_OK; \ 04149 \ 04150 if (LU##size(&cool_ints[j]) == 0) \ 04151 { /* modulo by zero */ \ 04152 act_result[j] = 0; \ 04153 act_status[j] |= AR_STAT_OVERFLOW; \ 04154 } \ 04155 else \ 04156 { /* not modulo by zero */ \ 04157 act_result[j] = LU##size(&cool_ints[i]) % \ 04158 LU##size(&cool_ints[j]); \ 04159 } \ 04160 \ 04161 if (is_zero##size(act_result[j])) \ 04162 act_status[j] |= AR_STAT_ZERO; \ 04163 \ 04164 test_result[j].part1 = 0; \ 04165 test_result[j].part2 = 0; \ 04166 test_result[j].part3 = 0; \ 04167 test_result[j].part4 = 0; \ 04168 \ 04169 test_status[j] = AR_modulo((AR_DATA *)&test_result[j], \ 04170 &uint##size##_artype, \ 04171 (AR_DATA *)&cool_ints[i], \ 04172 &uint##size##_artype, \ 04173 (AR_DATA *)&cool_ints[j], \ 04174 &uint##size##_artype); \ 04175 \ 04176 if (LU64(&test_result[j]) != (UINT64)act_result[j]) \ 04177 { \ 04178 printf(" ERROR: incorrect result at %d,%d\n", i, j); \ 04179 abort(); \ 04180 } \ 04181 \ 04182 if (act_status[j] != test_status[j]) \ 04183 { \ 04184 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 04185 abort(); \ 04186 } \ 04187 } \ 04188 } \ 04189 \ 04190 printf("PASSED\n"); \ 04191 } while (0) 04192 04193 04194 #define TEST_MOD_OP_TYPES \ 04195 do { \ 04196 int i, j, k; \ 04197 \ 04198 printf(" Testing: types %-10s: ", "%"); \ 04199 \ 04200 for (i=0; i<num_ar_types; i++) \ 04201 { \ 04202 for (j=0; j<num_ar_types; j++) \ 04203 { \ 04204 for (k=0; k<num_ar_types; k++) \ 04205 { \ 04206 act_status[k] = AR_STAT_OK; \ 04207 if (ar_types[i] != ar_types[j] || \ 04208 ar_types[j] != ar_types[k] || \ 04209 !IS_SUPPORTED_INT_TYPE(ar_types[i])) \ 04210 act_status[k] = AR_STAT_INVALID_TYPE; \ 04211 \ 04212 test_status[k] = AR_modulo((AR_DATA *)&test_result[1], \ 04213 &ar_types[i], \ 04214 (AR_DATA *)&cool_ints[1], \ 04215 &ar_types[j], \ 04216 (AR_DATA *)&cool_ints[1], \ 04217 &ar_types[k]); \ 04218 \ 04219 if ((act_status[k] ^ test_status[k]) & \ 04220 AR_STAT_INVALID_TYPE) \ 04221 { \ 04222 printf(" ERROR: incorrect status at %d,%d,%d\n", \ 04223 i, j, k); \ 04224 abort(); \ 04225 } \ 04226 } \ 04227 } \ 04228 } \ 04229 \ 04230 printf("PASSED\n"); \ 04231 } while (0) 04232 04233 04234 test_modulo() 04235 { 04236 04237 TEST_MOD_OP_SIGNED( 8); 04238 TEST_MOD_OP_UNSIGNED( 8); 04239 04240 TEST_MOD_OP_SIGNED( 16); 04241 TEST_MOD_OP_UNSIGNED(16); 04242 04243 TEST_MOD_OP_SIGNED( 32); 04244 TEST_MOD_OP_UNSIGNED(32); 04245 04246 TEST_MOD_OP_SIGNED( 46); 04247 04248 TEST_MOD_OP_SIGNED( 64); 04249 TEST_MOD_OP_UNSIGNED(64); 04250 04251 TEST_MOD_OP_TYPES; 04252 04253 } /* test_modulo */ 04254 04255 04256 #undef TEST_MOD_OP_SIGNED 04257 #undef TEST_MOD_OP_UNSIGNED 04258 #undef TEST_MOD_OP_TYPES 04259 04260 04261 /*====================================================================== 04262 * 04263 * COMPARISONS 04264 * 04265 */ 04266 04267 04268 #define TEST_COMPARE_OP_SIGNED(size) \ 04269 do { \ 04270 int i, j; \ 04271 \ 04272 printf(" Testing: SIGNED %2d INT %-10s: ", size, "compare"); \ 04273 \ 04274 for (i=0; i<num_cool_ints; i++) \ 04275 { \ 04276 for (j=0; j<num_cool_ints; j++) \ 04277 { \ 04278 if (size == 46) { \ 04279 if (LS64(&cool_ints[i]) < \ 04280 LS64(&cool_ints[j])) \ 04281 act_status[j] = AR_Compare_LT; \ 04282 else if (LS64(&cool_ints[i]) > \ 04283 LS64(&cool_ints[j])) \ 04284 act_status[j] = AR_Compare_GT; \ 04285 else \ 04286 act_status[j] = AR_Compare_EQ; \ 04287 } \ 04288 else { \ 04289 if (LS##size(&cool_ints[i]) < \ 04290 LS##size(&cool_ints[j])) \ 04291 act_status[j] = AR_Compare_LT; \ 04292 else if (LS##size(&cool_ints[i]) > \ 04293 LS##size(&cool_ints[j])) \ 04294 act_status[j] = AR_Compare_GT; \ 04295 else \ 04296 act_status[j] = AR_Compare_EQ; \ 04297 } \ 04298 \ 04299 test_status[j] = AR_compare((AR_DATA *)&cool_ints[i], \ 04300 &sint##size##_artype, \ 04301 (AR_DATA *)&cool_ints[j], \ 04302 &sint##size##_artype); \ 04303 \ 04304 if (act_status[j] != test_status[j]) \ 04305 { \ 04306 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 04307 abort(); \ 04308 } \ 04309 } \ 04310 } \ 04311 \ 04312 printf("PASSED\n"); \ 04313 } while (0) 04314 04315 04316 #define TEST_COMPARE_OP_UNSIGNED(size) \ 04317 do { \ 04318 int i, j; \ 04319 \ 04320 printf(" Testing: UNSIGNED %2d INT %-10s: ", size, "compare"); \ 04321 \ 04322 for (i=0; i<num_cool_ints; i++) \ 04323 { \ 04324 for (j=0; j<num_cool_ints; j++) \ 04325 { \ 04326 if (LU##size(&cool_ints[i]) < LU##size(&cool_ints[j])) \ 04327 act_status[j] = AR_Compare_LT; \ 04328 else if (LU##size(&cool_ints[i]) > LU##size(&cool_ints[j])) \ 04329 act_status[j] = AR_Compare_GT; \ 04330 else \ 04331 act_status[j] = AR_Compare_EQ; \ 04332 \ 04333 test_status[j] = AR_compare((AR_DATA *)&cool_ints[i], \ 04334 &uint##size##_artype, \ 04335 (AR_DATA *)&cool_ints[j], \ 04336 &uint##size##_artype); \ 04337 \ 04338 if (act_status[j] != test_status[j]) \ 04339 { \ 04340 printf(" ERROR: incorrect status at %d,%d\n", i, j); \ 04341 abort(); \ 04342 } \ 04343 } \ 04344 } \ 04345 \ 04346 printf("PASSED\n"); \ 04347 } while (0) 04348 04349 04350 #define TEST_COMPARE_OP_TYPES \ 04351 do { \ 04352 int j, k; \ 04353 \ 04354 printf(" Testing: types %-10s: ", "compare"); \ 04355 \ 04356 for (j=0; j<num_ar_types; j++) \ 04357 { \ 04358 for (k=0; k<num_ar_types; k++) \ 04359 { \ 04360 act_status[k] = AR_STAT_OK; \ 04361 if (ar_types[j] != ar_types[k] || \ 04362 !IS_SUPPORTED_INT_TYPE(ar_types[j])) \ 04363 act_status[k] = AR_Compare_Invalid; \ 04364 \ 04365 test_status[k] = AR_compare((AR_DATA *)&cool_ints[1], \ 04366 &ar_types[j], \ 04367 (AR_DATA *)&cool_ints[1], \ 04368 &ar_types[k]); \ 04369 \ 04370 if ((act_status[k] == AR_Compare_Invalid) ^ \ 04371 (test_status[k] == AR_Compare_Invalid)) \ 04372 { \ 04373 printf(" ERROR: incorrect status at %d,%d\n", j, k); \ 04374 abort(); \ 04375 } \ 04376 } \ 04377 } \ 04378 \ 04379 printf("PASSED\n"); \ 04380 } while (0) 04381 04382 04383 test_compare() 04384 { 04385 04386 TEST_COMPARE_OP_SIGNED( 8); 04387 TEST_COMPARE_OP_UNSIGNED( 8); 04388 04389 TEST_COMPARE_OP_SIGNED( 16); 04390 TEST_COMPARE_OP_UNSIGNED(16); 04391 04392 TEST_COMPARE_OP_SIGNED( 32); 04393 TEST_COMPARE_OP_UNSIGNED(32); 04394 04395 TEST_COMPARE_OP_SIGNED( 46); 04396 04397 TEST_COMPARE_OP_SIGNED( 64); 04398 TEST_COMPARE_OP_UNSIGNED(64); 04399 04400 TEST_COMPARE_OP_TYPES; 04401 04402 } /* test_compare */ 04403 04404 04405 static char USMID [] = "\n%Z%%M% %I% %G% %U%\n"; 04406 static char rcsid [] = "$Id: testint.c,v 1.1.1.1 2002-05-22 20:06:19 dsystem Exp $";
1.7.6.1 
