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.1 of the GNU Lesser General Public License 00007 as 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 Lesser General Public 00021 License along with this program; if not, write the Free Software 00022 Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 00023 USA. 00024 00025 Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pky, 00026 Mountain View, CA 94043, or: 00027 00028 http://www.sgi.com 00029 00030 For further information regarding this notice, see: 00031 00032 http://oss.sgi.com/projects/GenInfo/NoticeExplan 00033 00034 */ 00035 00036 /* automatically generated file, do not edit */ 00037 00038 #include "f90_intrinsic.h" 00039 00040 void 00041 _EOSHIFT( 00042 DopeVectorType *result, 00043 DopeVectorType *array, 00044 DopeVectorType *shift, 00045 DopeVectorType *boundary, 00046 i4 *dim) 00047 { 00048 char * result_p, * result_b ; 00049 char * array_p, * array_b ; 00050 char * shift_p, * shift_b ; 00051 char * boundary_p, * boundary_b ; 00052 00053 size_t src_extent [MAX_NARY_DIMS] ; 00054 size_t src_stride [MAX_NARY_DIMS] ; 00055 size_t src_offset [MAX_NARY_DIMS] ; 00056 size_t counter[MAX_NARY_DIMS] ; 00057 00058 size_t res_stride [MAX_NARY_DIMS] ; 00059 size_t res_extent [MAX_NARY_DIMS] ; 00060 size_t res_offset [MAX_NARY_DIMS] ; 00061 00062 int32_t j,ii; 00063 char *rp, *ap ; 00064 int32_t res_rank ; 00065 int32_t shf_rank ; 00066 int32_t src_rank = GET_RANK_FROM_DESC(array) - 1; 00067 00068 size_t typ_sz = GET_ELEMENT_SZ_FROM_DESC(array); 00069 00070 size_t a_size,a_stride,r_stride, i,k ; 00071 int8_t zero_szd_source = FALSE; 00072 int8_t byte_aligned = FALSE; 00073 00074 size_t r_offs1,r_offs2 ; 00075 size_t a_offs,a_bump,r_bump ; 00076 size_t ll1,ll2; 00077 int64_t shft,shf_typ_sz ; 00078 char *rp1, *ap1, *ap2 ; 00079 int32_t ddim ; 00080 00081 size_t shf_stride [MAX_NARY_DIMS] ; 00082 size_t shf_offset [MAX_NARY_DIMS] ; 00083 size_t fill_stride [MAX_NARY_DIMS] ; 00084 size_t fill_offset [MAX_NARY_DIMS] ; 00085 size_t f_stride ; 00086 int32_t fill_rank ; 00087 size_t num_trues ; 00088 int32_t local_alloc ; 00089 size_t tot_ext ; 00090 size_t str_sz ; 00091 00092 size_t src_size ; 00093 00094 size_t res_sz; 00095 size_t xfer_sz; 00096 size_t tot_sz; 00097 00098 int8_t computed_shift = FALSE ; 00099 const r16 zero_fill = 0; 00100 const char zero_sp[17] = " " ; 00101 00102 ddim = (*dim) - 1 ; 00103 00104 if ((ddim > src_rank) || (ddim < 0)) 00105 ERROR(_LELVL_ABORT,FESCIDIM); 00106 00107 src_extent[0] = GET_EXTENT_FROM_DESC(array,ddim) ; 00108 src_stride[0] = GET_STRIDE_FROM_DESC(array,ddim) ; 00109 byte_aligned = GET_BYTEALIGNED_FROM_DESC(array) ; 00110 00111 for ( j = 0, k = 1 ; j <= src_rank ; j ++ ) { 00112 if (j != ddim ) { 00113 src_extent[k] = GET_EXTENT_FROM_DESC(array,j) ; 00114 src_stride[k] = GET_STRIDE_FROM_DESC(array,j) ; 00115 src_offset[k-1] = src_stride[k] - (src_stride [k-1] * (src_extent[k-1])) ; 00116 k++ ; 00117 } 00118 counter[j] = 0 ; 00119 fill_offset[j] = 0 ; 00120 shf_offset[j] = 0 ; 00121 zero_szd_source = zero_szd_source || (src_extent[j] == 0) ; 00122 } 00123 00124 if (!GET_ASSOCIATED_FROM_DESC(result)) { 00125 00126 size_t nbytes ; 00127 size_t ext ; 00128 char *p ; 00129 00130 SET_ADDRESS_IN_DESC(result,NULL); 00131 SET_ORIG_BS_IN_DESC(result,NULL) ; 00132 SET_ORIG_SZ_IN_DESC(result,0) ; 00133 00134 p = NULL ; 00135 tot_ext = 1 ; 00136 nbytes = typ_sz ; 00137 str_sz = MK_STRIDE(byte_aligned,typ_sz); 00138 00139 for ( i = 0 ; i <= src_rank ; i ++) { 00140 ext = GET_EXTENT_FROM_DESC(array,i) ; 00141 SET_LBOUND_IN_DESC(result,i,1); 00142 SET_EXTENT_IN_DESC(result,i,ext); 00143 SET_STRMULT_IN_DESC(result,i,tot_ext * str_sz ); 00144 tot_ext *= ext; 00145 nbytes *= ext; 00146 } 00147 00148 if (nbytes > 0) { 00149 p = (void *) malloc (nbytes); 00150 if (p == NULL) 00151 ERROR(_LELVL_ABORT, FENOMEMY); 00152 00153 SET_ADDRESS_IN_DESC(result,p); 00154 } 00155 00156 SET_ASSOCIATED_IN_DESC(result); 00157 SET_CONTIG_IN_DESC(result); 00158 if (GET_DV_ASCII_FROM_DESC(array)) { 00159 SET_CHARPTR_IN_DESC(result,p,typ_sz); 00160 } 00161 SET_ORIG_BS_IN_DESC(result,p) ; 00162 SET_ORIG_SZ_IN_DESC(result,nbytes * 8 ) ; 00163 } 00164 00165 res_stride[0] = GET_STRIDE_FROM_DESC(result,ddim) ; 00166 00167 for ( j = 0, k = 1 ; j <= src_rank ; j ++ ) { 00168 if (j != ddim ) { 00169 res_stride[k] = GET_STRIDE_FROM_DESC(result,j) ; 00170 res_offset[k-1] = res_stride[k] - (res_stride [k-1] * (src_extent[k-1])) ; 00171 k++ ; 00172 } 00173 } 00174 00175 shf_typ_sz = GET_ELEMENT_SZ_FROM_DESC(shift); 00176 shf_rank = GET_RANK_FROM_DESC(shift); 00177 shift_p = GET_ADDRESS_FROM_DESC(shift); 00178 00179 shf_stride[0] = 0 ; 00180 for ( j = 0 ; j < shf_rank ; j ++ ) { 00181 shf_stride[j] = GET_STRIDE_FROM_DESC(shift,j) ; 00182 } 00183 00184 for ( j = 1 ; j < shf_rank ; j ++ ) { 00185 shf_offset[j] = shf_stride[j] - (shf_stride [j-1] * (src_extent[j])) ; 00186 } 00187 00188 if (boundary != NULL) { 00189 boundary_p = GET_ADDRESS_FROM_DESC(boundary); 00190 fill_rank = GET_RANK_FROM_DESC(boundary) ; 00191 00192 fill_stride[0] = 0; 00193 for ( j = 0 ; j < fill_rank ; j ++ ) { 00194 fill_stride[j] = GET_STRIDE_FROM_DESC(boundary,j) ; 00195 } 00196 00197 fill_offset[0] = 0 ; 00198 for ( j = 1 ; j < fill_rank ; j ++ ) { 00199 fill_offset[j] = fill_stride[j] - (fill_stride [j-1] * (src_extent[j])) ; 00200 } 00201 00202 } else { 00203 00204 for ( j = 0 ; j <= src_rank ; j ++ ) { 00205 fill_stride[j] = 0 ; 00206 fill_offset[0] = 0 ; 00207 } 00208 if (GET_DV_ASCII_FROM_DESC(array)) 00209 boundary_p = (char *) & zero_sp; 00210 else 00211 boundary_p = (char *) & zero_fill; 00212 } 00213 a_bump = src_extent[0] * src_stride[0] ; 00214 r_bump = src_extent[0] * res_stride[0] ; 00215 00216 if (zero_szd_source) 00217 return ; 00218 00219 a_size = src_extent[0] ; 00220 a_stride = src_stride[0] ; 00221 r_stride = res_stride[0] ; 00222 f_stride = fill_stride[0] ; 00223 array_p = GET_ADDRESS_FROM_DESC(array); 00224 result_p = GET_ADDRESS_FROM_DESC(result); 00225 00226 if (typ_sz == sizeof(i1) && ALIGNED_i1(array_p) && ALIGNED_i1(result_p) && ALIGNED_i1(boundary_p)) { 00227 00228 while (counter[src_rank] < src_extent[src_rank] ) { 00229 i1 lfill = 0 ; 00230 00231 if (!computed_shift) { 00232 switch (shf_typ_sz) { 00233 case sizeof(i1): 00234 shft = * (i1 *)shift_p ; 00235 break ; 00236 case sizeof(i2): 00237 shft = * (i2 *)shift_p ; 00238 break ; 00239 case sizeof(i4): 00240 shft = * (i4 *)shift_p ; 00241 break ; 00242 case sizeof(i8): 00243 shft = * (i8 *)shift_p ; 00244 break ; 00245 } 00246 shift_p += shf_stride[0]; 00247 00248 if (shft < 0 ) { 00249 if (shft < (-(int64_t) src_extent[0])) 00250 shft = (-(int64_t) src_extent[0]); 00251 00252 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00253 ll2 = abs(shft) ; 00254 r_offs1 = res_stride[0] * ll2 ; 00255 r_offs2 = 0 ; 00256 a_offs = 0 ; 00257 00258 } else { 00259 if (shft > (int64_t)src_extent[0]) 00260 shft = (int64_t)src_extent[0] ; 00261 ll1 = ((int64_t)src_extent[0]) - shft ; 00262 ll2 = shft ; 00263 r_offs1 = 0 ; 00264 r_offs2 = res_stride[0] * ll1 ; 00265 a_offs = a_stride * ll2 ; 00266 } 00267 if (shf_rank == 0 ) 00268 computed_shift = TRUE; 00269 } 00270 ap1 = array_p + a_offs ; 00271 rp1 = result_p + r_offs1; 00272 00273 for ( k = 0 ; k < ll1 ; k ++ ) { 00274 *(i1 *)rp1 = *(i1 *)ap1 ; 00275 rp1 += r_stride ; 00276 ap1 += a_stride ; 00277 } 00278 00279 rp1 = result_p + r_offs2 ; 00280 lfill = *(i1 *) boundary_p ; 00281 00282 for ( k = 0 ; k < ll2 ; k ++ ) { 00283 *(i1 *)rp1 = lfill ; 00284 rp1 += r_stride ; 00285 } 00286 00287 array_p += a_bump ; 00288 result_p += r_bump ; 00289 boundary_p += f_stride ; 00290 00291 counter[0] = a_size ; 00292 j = 0 ; 00293 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00294 array_p += src_offset[j] ; 00295 result_p += res_offset[j] ; 00296 shift_p += shf_offset[j] ; 00297 boundary_p += fill_offset[j] ; 00298 counter[j+1]++ ; 00299 counter[j] = 0 ; 00300 j ++ ; 00301 } 00302 00303 } 00304 } else if (typ_sz == sizeof(i2) && ALIGNED_i2(array_p) && ALIGNED_i2(result_p) && ALIGNED_i2(boundary_p)) { 00305 00306 while (counter[src_rank] < src_extent[src_rank] ) { 00307 i2 lfill = 0 ; 00308 00309 if (!computed_shift) { 00310 switch (shf_typ_sz) { 00311 case sizeof(i1): 00312 shft = * (i1 *)shift_p ; 00313 break ; 00314 case sizeof(i2): 00315 shft = * (i2 *)shift_p ; 00316 break ; 00317 case sizeof(i4): 00318 shft = * (i4 *)shift_p ; 00319 break ; 00320 case sizeof(i8): 00321 shft = * (i8 *)shift_p ; 00322 break ; 00323 } 00324 shift_p += shf_stride[0]; 00325 00326 if (shft < 0 ) { 00327 if (shft < (-(int64_t) src_extent[0])) 00328 shft = (-(int64_t) src_extent[0]); 00329 00330 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00331 ll2 = abs(shft) ; 00332 r_offs1 = res_stride[0] * ll2 ; 00333 r_offs2 = 0 ; 00334 a_offs = 0 ; 00335 00336 } else { 00337 if (shft > (int64_t)src_extent[0]) 00338 shft = (int64_t)src_extent[0] ; 00339 ll1 = ((int64_t)src_extent[0]) - shft ; 00340 ll2 = shft ; 00341 r_offs1 = 0 ; 00342 r_offs2 = res_stride[0] * ll1 ; 00343 a_offs = a_stride * ll2 ; 00344 } 00345 if (shf_rank == 0 ) 00346 computed_shift = TRUE; 00347 } 00348 ap1 = array_p + a_offs ; 00349 rp1 = result_p + r_offs1; 00350 00351 for ( k = 0 ; k < ll1 ; k ++ ) { 00352 *(i2 *)rp1 = *(i2 *)ap1 ; 00353 rp1 += r_stride ; 00354 ap1 += a_stride ; 00355 } 00356 00357 rp1 = result_p + r_offs2 ; 00358 lfill = *(i2 *) boundary_p ; 00359 00360 for ( k = 0 ; k < ll2 ; k ++ ) { 00361 *(i2 *)rp1 = lfill ; 00362 rp1 += r_stride ; 00363 } 00364 00365 array_p += a_bump ; 00366 result_p += r_bump ; 00367 boundary_p += f_stride ; 00368 00369 counter[0] = a_size ; 00370 j = 0 ; 00371 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00372 array_p += src_offset[j] ; 00373 result_p += res_offset[j] ; 00374 shift_p += shf_offset[j] ; 00375 boundary_p += fill_offset[j] ; 00376 counter[j+1]++ ; 00377 counter[j] = 0 ; 00378 j ++ ; 00379 } 00380 00381 } 00382 } else if (typ_sz == sizeof(r4) && ALIGNED_r4(array_p) && ALIGNED_r4(result_p) && ALIGNED_r4(boundary_p)) { 00383 00384 while (counter[src_rank] < src_extent[src_rank] ) { 00385 r4 lfill = 0 ; 00386 00387 if (!computed_shift) { 00388 switch (shf_typ_sz) { 00389 case sizeof(i1): 00390 shft = * (i1 *)shift_p ; 00391 break ; 00392 case sizeof(i2): 00393 shft = * (i2 *)shift_p ; 00394 break ; 00395 case sizeof(i4): 00396 shft = * (i4 *)shift_p ; 00397 break ; 00398 case sizeof(i8): 00399 shft = * (i8 *)shift_p ; 00400 break ; 00401 } 00402 shift_p += shf_stride[0]; 00403 00404 if (shft < 0 ) { 00405 if (shft < (-(int64_t) src_extent[0])) 00406 shft = (-(int64_t) src_extent[0]); 00407 00408 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00409 ll2 = abs(shft) ; 00410 r_offs1 = res_stride[0] * ll2 ; 00411 r_offs2 = 0 ; 00412 a_offs = 0 ; 00413 00414 } else { 00415 if (shft > (int64_t)src_extent[0]) 00416 shft = (int64_t)src_extent[0] ; 00417 ll1 = ((int64_t)src_extent[0]) - shft ; 00418 ll2 = shft ; 00419 r_offs1 = 0 ; 00420 r_offs2 = res_stride[0] * ll1 ; 00421 a_offs = a_stride * ll2 ; 00422 } 00423 if (shf_rank == 0 ) 00424 computed_shift = TRUE; 00425 } 00426 ap1 = array_p + a_offs ; 00427 rp1 = result_p + r_offs1; 00428 00429 for ( k = 0 ; k < ll1 ; k ++ ) { 00430 *(r4 *)rp1 = *(r4 *)ap1 ; 00431 rp1 += r_stride ; 00432 ap1 += a_stride ; 00433 } 00434 00435 rp1 = result_p + r_offs2 ; 00436 lfill = *(r4 *) boundary_p ; 00437 00438 for ( k = 0 ; k < ll2 ; k ++ ) { 00439 *(r4 *)rp1 = lfill ; 00440 rp1 += r_stride ; 00441 } 00442 00443 array_p += a_bump ; 00444 result_p += r_bump ; 00445 boundary_p += f_stride ; 00446 00447 counter[0] = a_size ; 00448 j = 0 ; 00449 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00450 array_p += src_offset[j] ; 00451 result_p += res_offset[j] ; 00452 shift_p += shf_offset[j] ; 00453 boundary_p += fill_offset[j] ; 00454 counter[j+1]++ ; 00455 counter[j] = 0 ; 00456 j ++ ; 00457 } 00458 00459 } 00460 } else if (typ_sz == sizeof(r8) && ALIGNED_r8(array_p) && ALIGNED_r8(result_p) && ALIGNED_r8(boundary_p)) { 00461 00462 while (counter[src_rank] < src_extent[src_rank] ) { 00463 r8 lfill = 0 ; 00464 00465 if (!computed_shift) { 00466 switch (shf_typ_sz) { 00467 case sizeof(i1): 00468 shft = * (i1 *)shift_p ; 00469 break ; 00470 case sizeof(i2): 00471 shft = * (i2 *)shift_p ; 00472 break ; 00473 case sizeof(i4): 00474 shft = * (i4 *)shift_p ; 00475 break ; 00476 case sizeof(i8): 00477 shft = * (i8 *)shift_p ; 00478 break ; 00479 } 00480 shift_p += shf_stride[0]; 00481 00482 if (shft < 0 ) { 00483 if (shft < (-(int64_t) src_extent[0])) 00484 shft = (-(int64_t) src_extent[0]); 00485 00486 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00487 ll2 = abs(shft) ; 00488 r_offs1 = res_stride[0] * ll2 ; 00489 r_offs2 = 0 ; 00490 a_offs = 0 ; 00491 00492 } else { 00493 if (shft > (int64_t)src_extent[0]) 00494 shft = (int64_t)src_extent[0] ; 00495 ll1 = ((int64_t)src_extent[0]) - shft ; 00496 ll2 = shft ; 00497 r_offs1 = 0 ; 00498 r_offs2 = res_stride[0] * ll1 ; 00499 a_offs = a_stride * ll2 ; 00500 } 00501 if (shf_rank == 0 ) 00502 computed_shift = TRUE; 00503 } 00504 ap1 = array_p + a_offs ; 00505 rp1 = result_p + r_offs1; 00506 00507 for ( k = 0 ; k < ll1 ; k ++ ) { 00508 *(r8 *)rp1 = *(r8 *)ap1 ; 00509 rp1 += r_stride ; 00510 ap1 += a_stride ; 00511 } 00512 00513 rp1 = result_p + r_offs2 ; 00514 lfill = *(r8 *) boundary_p ; 00515 00516 for ( k = 0 ; k < ll2 ; k ++ ) { 00517 *(r8 *)rp1 = lfill ; 00518 rp1 += r_stride ; 00519 } 00520 00521 array_p += a_bump ; 00522 result_p += r_bump ; 00523 boundary_p += f_stride ; 00524 00525 counter[0] = a_size ; 00526 j = 0 ; 00527 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00528 array_p += src_offset[j] ; 00529 result_p += res_offset[j] ; 00530 shift_p += shf_offset[j] ; 00531 boundary_p += fill_offset[j] ; 00532 counter[j+1]++ ; 00533 counter[j] = 0 ; 00534 j ++ ; 00535 } 00536 00537 } 00538 } else if (typ_sz == sizeof(r16) && ALIGNED_r16(array_p) && ALIGNED_r16(result_p) && ALIGNED_r16(boundary_p)) { 00539 00540 while (counter[src_rank] < src_extent[src_rank] ) { 00541 r16 lfill = 0 ; 00542 00543 if (!computed_shift) { 00544 switch (shf_typ_sz) { 00545 case sizeof(i1): 00546 shft = * (i1 *)shift_p ; 00547 break ; 00548 case sizeof(i2): 00549 shft = * (i2 *)shift_p ; 00550 break ; 00551 case sizeof(i4): 00552 shft = * (i4 *)shift_p ; 00553 break ; 00554 case sizeof(i8): 00555 shft = * (i8 *)shift_p ; 00556 break ; 00557 } 00558 shift_p += shf_stride[0]; 00559 00560 if (shft < 0 ) { 00561 if (shft < (-(int64_t) src_extent[0])) 00562 shft = (-(int64_t) src_extent[0]); 00563 00564 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00565 ll2 = abs(shft) ; 00566 r_offs1 = res_stride[0] * ll2 ; 00567 r_offs2 = 0 ; 00568 a_offs = 0 ; 00569 00570 } else { 00571 if (shft > (int64_t)src_extent[0]) 00572 shft = (int64_t)src_extent[0] ; 00573 ll1 = ((int64_t)src_extent[0]) - shft ; 00574 ll2 = shft ; 00575 r_offs1 = 0 ; 00576 r_offs2 = res_stride[0] * ll1 ; 00577 a_offs = a_stride * ll2 ; 00578 } 00579 if (shf_rank == 0 ) 00580 computed_shift = TRUE; 00581 } 00582 ap1 = array_p + a_offs ; 00583 rp1 = result_p + r_offs1; 00584 00585 for ( k = 0 ; k < ll1 ; k ++ ) { 00586 *(r16 *)rp1 = *(r16 *)ap1 ; 00587 rp1 += r_stride ; 00588 ap1 += a_stride ; 00589 } 00590 00591 rp1 = result_p + r_offs2 ; 00592 lfill = *(r16 *) boundary_p ; 00593 00594 for ( k = 0 ; k < ll2 ; k ++ ) { 00595 *(r16 *)rp1 = lfill ; 00596 rp1 += r_stride ; 00597 } 00598 00599 array_p += a_bump ; 00600 result_p += r_bump ; 00601 boundary_p += f_stride ; 00602 00603 counter[0] = a_size ; 00604 j = 0 ; 00605 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00606 array_p += src_offset[j] ; 00607 result_p += res_offset[j] ; 00608 shift_p += shf_offset[j] ; 00609 boundary_p += fill_offset[j] ; 00610 counter[j+1]++ ; 00611 counter[j] = 0 ; 00612 j ++ ; 00613 } 00614 00615 } 00616 } else { 00617 while (counter[src_rank] < src_extent[src_rank] ) { 00618 char * lfill ; 00619 00620 if (!computed_shift) { 00621 switch (shf_typ_sz) { 00622 case sizeof(i1): 00623 shft = * (i1 *)shift_p ; 00624 break ; 00625 case sizeof(i2): 00626 shft = * (i2 *)shift_p ; 00627 break ; 00628 case sizeof(i4): 00629 shft = * (i4 *)shift_p ; 00630 break ; 00631 case sizeof(i8): 00632 shft = * (i8 *)shift_p ; 00633 break ; 00634 } 00635 shift_p += shf_stride[0]; 00636 00637 if (shft < 0 ) { 00638 if (shft < (-(int64_t) src_extent[0])) 00639 shft = (-(int64_t) src_extent[0]); 00640 00641 ll1 = ((int64_t)src_extent[0]) - abs(shft) ; 00642 ll2 = abs(shft) ; 00643 r_offs1 = res_stride[0] * ll2 ; 00644 r_offs2 = 0 ; 00645 a_offs = 0 ; 00646 00647 } else { 00648 if (shft > (int64_t)src_extent[0]) 00649 shft = (int64_t)src_extent[0] ; 00650 ll1 = ((int64_t)src_extent[0]) - shft ; 00651 ll2 = shft ; 00652 r_offs1 = 0 ; 00653 r_offs2 = res_stride[0] * ll1 ; 00654 a_offs = a_stride * ll2 ; 00655 } 00656 if (shf_rank == 0 ) 00657 computed_shift = TRUE; 00658 } 00659 ap1 = array_p + a_offs ; 00660 rp1 = result_p + r_offs1; 00661 00662 for ( k = 0 ; k < ll1 ; k ++ ) { 00663 ap = ap1 ; 00664 rp = rp1 ; 00665 if (typ_sz > BIGDEFAULTSZ) 00666 (void) memcpy (rp, ap, typ_sz); 00667 else 00668 for (j = 0 ; j < typ_sz ; j ++) *rp++ = *ap ++ ; 00669 rp1 += r_stride ; 00670 ap1 += a_stride ; 00671 } 00672 00673 rp1 = result_p + r_offs2 ; 00674 lfill = boundary_p ; 00675 00676 if (boundary != NULL) { 00677 for ( k = 0 ; k < ll2 ; k ++ ) { 00678 ap2 = lfill ; 00679 rp = rp1 ; 00680 if (typ_sz > BIGDEFAULTSZ) 00681 (void) memcpy (rp, ap2, typ_sz); 00682 else 00683 for (j = 0 ; j < typ_sz ; j ++) *rp++ = *ap2 ++ ; 00684 rp1 += r_stride ; 00685 } 00686 } else { 00687 for ( k = 0 ; k < ll2 ; k ++ ) { 00688 rp = rp1 ; 00689 for (j = 0 ; j < typ_sz ; j ++) *rp++ = *lfill ; 00690 rp1 += r_stride ; 00691 } 00692 } 00693 00694 array_p += a_bump ; 00695 result_p += r_bump ; 00696 boundary_p += f_stride ; 00697 00698 counter[0] = a_size ; 00699 j = 0 ; 00700 while ((counter[j] == src_extent[j]) && (j < src_rank)) { 00701 array_p += src_offset[j] ; 00702 result_p += res_offset[j] ; 00703 shift_p += shf_offset[j] ; 00704 boundary_p += fill_offset[j] ; 00705 counter[j+1]++ ; 00706 counter[j] = 0 ; 00707 j ++ ; 00708 } 00709 00710 } 00711 } 00712 }