src/byteorder.c

   1 /*
   2 Copyright (C) 2001-2009, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/byteorder.c - Byteordering functions
   8
   9 =head1 DESCRIPTION
  10
  11 These are assigned to a vtable when the PBC file is loaded.
  12
  13 If the vtable function for conversion from the native byteorder is called,
  14 it is a I<no op> and will work, but the caller should know if the
  15 byteorder in the PBC file is native and skip the conversion and just map
  16 it in.
  17
  18 =head2 Byte order handlers
  19
  20 Configure will have checked for supported word sizes.
  21
  22 =over 4
  23
  24 =cut
  25
  26 */
  27
  28 #include "parrot/parrot.h"
  29
  30 /* HEADERIZER HFILE: include/parrot/packfile.h */
  31
  32 /*
  33
  34 =item C<INTVAL fetch_iv_le(INTVAL w)>
  35
  36 This function converts a 4 or 8 byte C<INTVAL> into little endian
  37 format. If the native format is already little endian, then no
  38 conversion is done.
  39
  40 =cut
  41
  42 */
  43
  44 PARROT_WARN_UNUSED_RESULT
  45 PARROT_CONST_FUNCTION
  46 INTVAL
  47 fetch_iv_le(INTVAL w)
  48 {
  49     ASSERT_ARGS(fetch_iv_le)
  50 #if !PARROT_BIGENDIAN
  51     return w;
  52 #else
  53 #  if INTVAL_SIZE == 4
  54     return (w << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | (w >> 24);
  55 #  else
  56 #    if INTVAL_SIZE == 8
  57     INTVAL r;
  58
  59     r = w << 56;
  60     r |= (w & 0xff00) << 40;
  61     r |= (w & 0xff0000) << 24;
  62     r |= (w & 0xff000000) << 8;
  63     r |= (w & 0xff00000000) >> 8;
  64     r |= (w & 0xff0000000000) >> 24;
  65     r |= (w & 0xff000000000000) >> 40;
  66     r |= (w & 0xff00000000000000) >> 56;
  67     return r;
  68 #    else
  69     exit_fatal(1, "Unsupported INTVAL_SIZE=%d\n",
  70                INTVAL_SIZE);
  71 #    endif
  72 #  endif
  73 #endif
  74 }
  75
  76 /*
  77
  78 =item C<INTVAL fetch_iv_be(INTVAL w)>
  79
  80 This function converts a 4 or 8 byte C<INTVAL> into big endian format.
  81 If the native format is already big endian, then no conversion is done.
  82
  83 =cut
  84
  85 */
  86
  87 PARROT_WARN_UNUSED_RESULT
  88 PARROT_CONST_FUNCTION
  89 INTVAL
  90 fetch_iv_be(INTVAL w)
  91 {
  92     ASSERT_ARGS(fetch_iv_be)
  93 #if PARROT_BIGENDIAN
  94     return w;
  95 #else
  96 #  if INTVAL_SIZE == 4
  97     return (w << 24) | ((w & 0xff00) << 8) | ((w & 0xff0000) >> 8) | (w >> 24);
  98 #  else
  99 #    if INTVAL_SIZE == 8
 100     INTVAL r;
 101     r = w << 56;
 102     r |= (w & 0xff00) << 40;
 103     r |= (w & 0xff0000) << 24;
 104     r |= (w & 0xff000000) << 8;
 105     r |= (w & 0xff00000000) >> 8;
 106     r |= (w & 0xff0000000000) >> 24;
 107     r |= (w & 0xff000000000000) >> 40;
 108     r |= (w & 0xff00000000000000) >> 56;
 109     return r;
 110 #    else
 111     exit_fatal(1, "Unsupported INTVAL_SIZE=%d\n",
 112                INTVAL_SIZE);
 113 #    endif
 114 #  endif
 115 #endif
 116 }
 117
 118 /*
 119
 120 =item C<opcode_t fetch_op_be(opcode_t w)>
 121
 122 Same as C<fetch_iv_be> for opcode_t
 123
 124 =cut
 125
 126 */
 127
 128 PARROT_WARN_UNUSED_RESULT
 129 PARROT_CONST_FUNCTION
 130 opcode_t
 131 fetch_op_be(opcode_t w)
 132 {
 133     ASSERT_ARGS(fetch_op_be)
 134 #if PARROT_BIGENDIAN
 135     return w;
 136 #else
 137 #  if OPCODE_T_SIZE == 4
 138     return (w << 24) | ((w & 0x0000ff00) << 8) | ((w & 0x00ff0000) >> 8) |
 139         ((w & 0xff000000) >> 24);
 140 #  else
 141     opcode_t r;
 142
 143     r = w << 56;
 144     r |= (w & 0xff00) << 40;
 145     r |= (w & 0xff0000) << 24;
 146     r |= (w & 0xff000000) << 8;
 147     r |= (w & 0xff00000000) >> 8;
 148     r |= (w & 0xff0000000000) >> 24;
 149     r |= (w & 0xff000000000000) >> 40;
 150     r |= (w & 0xff00000000000000) >> 56;
 151     return r;
 152 #  endif
 153 #endif
 154 }
 155
 156 /*
 157
 158 =item C<opcode_t fetch_op_le(opcode_t w)>
 159
 160 Same as C<fetch_iv_le> for opcode_t
 161
 162 =cut
 163
 164 */
 165
 166 PARROT_WARN_UNUSED_RESULT
 167 PARROT_CONST_FUNCTION
 168 opcode_t
 169 fetch_op_le(opcode_t w)
 170 {
 171     ASSERT_ARGS(fetch_op_le)
 172 #if !PARROT_BIGENDIAN
 173     return w;
 174 #else
 175 #  if OPCODE_T_SIZE == 4
 176     return (w << 24) | ((w & 0x0000ff00) << 8) | ((w & 0x00ff0000) >> 8) |
 177         ((w & 0xff000000) >> 24);
 178 #  else
 179     opcode_t r;
 180
 181     r = w << 56;
 182     r |= (w & 0xff00) << 40;
 183     r |= (w & 0xff0000) << 24;
 184     r |= (w & 0xff000000) << 8;
 185     r |= (w & 0xff00000000) >> 8;
 186     r |= (w & 0xff0000000000) >> 24;
 187     r |= (w & 0xff000000000000) >> 40;
 188     r |= (w & 0xff00000000000000) >> 56;
 189     return r;
 190 #  endif
 191 #endif
 192 }
 193
 194 /*
 195
 196 =pod
 197
 198 Unrolled routines for swapping various sizes from 32-128 bits. These
 199 should only be used if alignment is unknown or we are pulling something
 200 out of a padded buffer.
 201
 202 =cut
 203
 204 */
 205
 206 /*
 207
 208 =item C<void fetch_buf_be_4(unsigned char *rb, const unsigned char *b)>
 209
 210 Converts a 4-byte big-endian buffer C<b> into a little-endian C<rb>.
 211
 212 =cut
 213
 214 */
 215
 216 void
 217 fetch_buf_be_4(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 218 {
 219     ASSERT_ARGS(fetch_buf_be_4)
 220 #if PARROT_BIGENDIAN
 221     memcpy(rb, b, 4);
 222 #else
 223     rb[0] = b[3];
 224     rb[1] = b[2];
 225     rb[2] = b[1];
 226     rb[3] = b[0];
 227 #endif
 228 }
 229
 230 /*
 231
 232 =item C<void fetch_buf_le_4(unsigned char *rb, const unsigned char *b)>
 233
 234 Converts a 4-byte little-endian buffer C<b> into a big-endian buffer C<rb>.
 235
 236 =cut
 237
 238 */
 239
 240 void
 241 fetch_buf_le_4(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 242 {
 243     ASSERT_ARGS(fetch_buf_le_4)
 244 #if !PARROT_BIGENDIAN
 245     memcpy(rb, b, 4);
 246 #else
 247     rb[0] = b[3];
 248     rb[1] = b[2];
 249     rb[2] = b[1];
 250     rb[3] = b[0];
 251 #endif
 252 }
 253
 254 /*
 255
 256 =item C<void fetch_buf_be_8(unsigned char *rb, const unsigned char *b)>
 257
 258 Converts an 8-byte big-endian buffer C<b> into a little-endian buffer C<rb>
 259
 260 =cut
 261
 262 */
 263
 264 void
 265 fetch_buf_be_8(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 266 {
 267     ASSERT_ARGS(fetch_buf_be_8)
 268 #if PARROT_BIGENDIAN
 269     memcpy(rb, b, 8);
 270 #else
 271     rb[0] = b[7];
 272     rb[1] = b[6];
 273     rb[2] = b[5];
 274     rb[3] = b[4];
 275     rb[4] = b[3];
 276     rb[5] = b[2];
 277     rb[6] = b[1];
 278     rb[7] = b[0];
 279 #endif
 280 }
 281
 282 /*
 283
 284 =item C<void fetch_buf_le_8(unsigned char *rb, const unsigned char *b)>
 285
 286 Converts an 8-byte little-endian buffer C<b> into a big-endian buffer C<rb>.
 287
 288 =cut
 289
 290 */
 291
 292 void
 293 fetch_buf_le_8(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 294 {
 295     ASSERT_ARGS(fetch_buf_le_8)
 296 #if !PARROT_BIGENDIAN
 297     memcpy(rb, b, 8);
 298 #else
 299     rb[0] = b[7];
 300     rb[1] = b[6];
 301     rb[2] = b[5];
 302     rb[3] = b[4];
 303     rb[4] = b[3];
 304     rb[5] = b[2];
 305     rb[6] = b[1];
 306     rb[7] = b[0];
 307 #endif
 308 }
 309
 310 /*
 311
 312 =item C<void fetch_buf_le_12(unsigned char *rb, const unsigned char *b)>
 313
 314 Converts a 12-byte little-endian buffer C<b> into a big-endian buffer C<b>.
 315
 316 =cut
 317
 318 */
 319
 320 void
 321 fetch_buf_le_12(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 322 {
 323     ASSERT_ARGS(fetch_buf_le_12)
 324 #if !PARROT_BIGENDIAN
 325     memcpy(rb, b, 12);
 326 #else
 327     rb[0] = b[11];
 328     rb[1] = b[10];
 329     rb[2] = b[9];
 330     rb[3] = b[8];
 331     rb[4] = b[7];
 332     rb[5] = b[6];
 333     rb[6] = b[5];
 334     rb[7] = b[4];
 335     rb[8] = b[3];
 336     rb[9] = b[2];
 337     rb[10] = b[1];
 338     rb[11] = b[0];
 339 #endif
 340 }
 341
 342 /*
 343
 344 =item C<void fetch_buf_be_12(unsigned char *rb, const unsigned char *b)>
 345
 346 Converts a 12-byte big-endian buffer C<b> into a little-endian buffer C<b>.
 347
 348 =cut
 349
 350 */
 351
 352 void
 353 fetch_buf_be_12(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 354 {
 355     ASSERT_ARGS(fetch_buf_be_12)
 356 #if PARROT_BIGENDIAN
 357     memcpy(rb, b, 12);
 358 #else
 359     rb[0] = b[11];
 360     rb[1] = b[10];
 361     rb[2] = b[9];
 362     rb[3] = b[8];
 363     rb[4] = b[7];
 364     rb[5] = b[6];
 365     rb[6] = b[5];
 366     rb[7] = b[4];
 367     rb[8] = b[3];
 368     rb[9] = b[2];
 369     rb[10] = b[1];
 370     rb[11] = b[0];
 371 #endif
 372 }
 373
 374 /*
 375
 376 =item C<void fetch_buf_le_16(unsigned char *rb, const unsigned char *b)>
 377
 378 Converts a 16-byte little-endian buffer C<b> into a big-endian buffer C<b>.
 379
 380 =cut
 381
 382 */
 383
 384 void
 385 fetch_buf_le_16(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 386 {
 387     ASSERT_ARGS(fetch_buf_le_16)
 388 #if !PARROT_BIGENDIAN
 389     memcpy(rb, b, 16);
 390 #else
 391     rb[0] = b[15];
 392     rb[1] = b[14];
 393     rb[2] = b[13];
 394     rb[3] = b[12];
 395     rb[4] = b[11];
 396     rb[5] = b[10];
 397     rb[6] = b[9];
 398     rb[7] = b[8];
 399     rb[8] = b[7];
 400     rb[9] = b[6];
 401     rb[10] = b[5];
 402     rb[11] = b[4];
 403     rb[12] = b[3];
 404     rb[13] = b[2];
 405     rb[14] = b[1];
 406     rb[15] = b[0];
 407 #endif
 408 }
 409
 410 /*
 411
 412 =item C<void fetch_buf_be_16(unsigned char *rb, const unsigned char *b)>
 413
 414 Converts a 16-byte big-endian buffer C<b> into a little-endian buffer C<b>.
 415
 416 =cut
 417
 418 */
 419
 420 void
 421 fetch_buf_be_16(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 422 {
 423     ASSERT_ARGS(fetch_buf_be_16)
 424 #if PARROT_BIGENDIAN
 425     memcpy(rb, b, 16);
 426 #else
 427     rb[0] = b[15];
 428     rb[1] = b[14];
 429     rb[2] = b[13];
 430     rb[3] = b[12];
 431     rb[4] = b[11];
 432     rb[5] = b[10];
 433     rb[6] = b[9];
 434     rb[7] = b[8];
 435     rb[8] = b[7];
 436     rb[9] = b[6];
 437     rb[10] = b[5];
 438     rb[11] = b[4];
 439     rb[12] = b[3];
 440     rb[13] = b[2];
 441     rb[14] = b[1];
 442     rb[15] = b[0];
 443 #endif
 444 }
 445
 446 /*
 447
 448 =item C<void fetch_buf_le_32(unsigned char *rb, const unsigned char *b)>
 449
 450 Converts a 32-byte little-endian buffer C<b> into a big-endian buffer C<b>.
 451
 452 =cut
 453
 454 */
 455
 456 void
 457 fetch_buf_le_32(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 458 {
 459     ASSERT_ARGS(fetch_buf_le_32)
 460 #if !PARROT_BIGENDIAN
 461     memcpy(rb, b, 32);
 462 #else
 463     rb[0] = b[31];
 464     rb[1] = b[30];
 465     rb[2] = b[29];
 466     rb[3] = b[28];
 467     rb[4] = b[27];
 468     rb[5] = b[26];
 469     rb[6] = b[25];
 470     rb[7] = b[24];
 471     rb[8] = b[23];
 472     rb[9] = b[22];
 473     rb[10] = b[21];
 474     rb[11] = b[20];
 475     rb[12] = b[19];
 476     rb[13] = b[18];
 477     rb[14] = b[17];
 478     rb[15] = b[16];
 479     rb[16] = b[15];
 480     rb[17] = b[14];
 481     rb[18] = b[13];
 482     rb[19] = b[12];
 483     rb[20] = b[11];
 484     rb[21] = b[10];
 485     rb[22] = b[9];
 486     rb[23] = b[8];
 487     rb[24] = b[7];
 488     rb[25] = b[6];
 489     rb[26] = b[5];
 490     rb[27] = b[4];
 491     rb[28] = b[3];
 492     rb[29] = b[2];
 493     rb[30] = b[1];
 494     rb[31] = b[0];
 495 #endif
 496 }
 497
 498 /*
 499
 500 =item C<void fetch_buf_be_32(unsigned char *rb, const unsigned char *b)>
 501
 502 Converts a 32-byte big-endian buffer C<b> into a little-endian buffer C<b>.
 503
 504 =cut
 505
 506 */
 507
 508 void
 509 fetch_buf_be_32(ARGOUT(unsigned char *rb), ARGIN(const unsigned char *b))
 510 {
 511     ASSERT_ARGS(fetch_buf_be_32)
 512 #if PARROT_BIGENDIAN
 513     memcpy(rb, b, 32);
 514 #else
 515     rb[0] = b[31];
 516     rb[1] = b[30];
 517     rb[2] = b[29];
 518     rb[3] = b[28];
 519     rb[4] = b[27];
 520     rb[5] = b[26];
 521     rb[6] = b[25];
 522     rb[7] = b[24];
 523     rb[8] = b[23];
 524     rb[9] = b[22];
 525     rb[10] = b[21];
 526     rb[11] = b[20];
 527     rb[12] = b[19];
 528     rb[13] = b[18];
 529     rb[14] = b[17];
 530     rb[15] = b[16];
 531     rb[16] = b[15];
 532     rb[17] = b[14];
 533     rb[18] = b[13];
 534     rb[19] = b[12];
 535     rb[20] = b[11];
 536     rb[21] = b[10];
 537     rb[22] = b[9];
 538     rb[23] = b[8];
 539     rb[24] = b[7];
 540     rb[25] = b[6];
 541     rb[26] = b[5];
 542     rb[27] = b[4];
 543     rb[28] = b[3];
 544     rb[29] = b[2];
 545     rb[30] = b[1];
 546     rb[31] = b[0];
 547 #endif
 548 }
 549
 550 /*
 551
 552 =back
 553
 554 =head1 HISTORY
 555
 556 Initial version by Melvin on 2002/05/01
 557
 558 =cut
 559
 560 */
 561
 562 /*
 563  * Local variables:
 564  *   c-file-style: "parrot"
 565  * End:
 566  * vim: expandtab shiftwidth=4:
 567  */