src/ops/bit.ops

   1 /*
   2 ** bit.ops
   3 */
   4
   5  /* Signed shift operator that is compatible with PMC shifts.  This is
   6   * guaranteed to produce the same result as bitwise_left_shift_internal modulo
   7   * word size, ignoring the fact that Parrot integers are always signed.  This
   8   * usually gives the same answer regardless whether you shift PMC operands and
   9   * then assign to an I-reg, or move the operands to I-regs and do the shift
  10   * there -- except when the true result is between 2^{w-1} and 2^w (where w is
  11   * the word size), in which case the high order bit is taken as the sign,
  12   * giving a truncated result that is 2^w lower.
  13   */
  14 #define bit_shift_left(number, bits) \
  15     ((bits) >= 8*INTVAL_SIZE     ? 0                    \
  16      : (bits) >= 0               ? (number) << (bits)   \
  17      : (bits) > -8*INTVAL_SIZE   ? (number) >> -(bits)   \
  18      : 0)
  19
  20 VERSION = PARROT_VERSION;
  21
  22 =head1 NAME
  23
  24 bit.ops - Bitwise Operations
  25
  26 =head1 DESCRIPTION
  27
  28 Operations that deal with bits directly, either individually
  29 or in groups.
  30
  31 The variant with an appended B<s> like B<bands> work on strings.
  32
  33 The variants with a prepended B<n_> like <n_bnot> generate a new target PMC.
  34 If possible, they use the appropriate language type, specified with C<.HLL>.
  35
  36 =over 4
  37
  38 =cut
  39
  40 ###############################################################################
  41
  42 =item B<band>(inout INT, in INT)
  43
  44 Set the bits of $1 according to the B<and> of the corresponding bits
  45 from $1 and $2.
  46
  47 =item B<band>(out INT, in INT, in INT)
  48
  49 Set the bits of $1 according to the B<and> of the corresponding bits
  50 from $2 and $3.
  51
  52 =cut
  53
  54 inline op band(inout INT, in INT) :base_core {
  55   $1 &= $2;
  56   goto NEXT();
  57 }
  58
  59 inline op band(out INT, in INT, in INT) :base_core {
  60   $1 = $2 & $3;
  61   goto NEXT();
  62 }
  63
  64 =item B<bands>(inout STR, in STR)
  65
  66 Set the bits of $1 according to the B<and> of the corresponding bits
  67 from $1 and $2.
  68
  69 =item B<bands>(out STR, in STR, in STR)
  70
  71 Set the bits of $1 according to the B<and> of the corresponding bits
  72 from $2 and $3.
  73
  74 =cut
  75
  76 inline op bands(inout STR, in STR) :base_core {
  77   string_bitwise_and(interp, $1, $2, &$1);
  78   goto NEXT();
  79 }
  80
  81 inline op bands(out STR, in STR, in STR) :base_core {
  82   $1 = string_bitwise_and(interp, $2, $3, NULL);
  83   goto NEXT();
  84 }
  85
  86 ########################################
  87
  88 =item B<bnot>(inout INT)
  89
  90 =item B<bnot>(invar PMC)
  91
  92 Sets $1 to C<bitwise not> $1 inplace.
  93
  94 =item B<bnot>(out INT, in INT)
  95
  96 =item B<bnot>(out PMC, invar PMC)
  97
  98 =item B<n_bnot>(out PMC, invar PMC)
  99
 100 Set the bits of $1 to the B<not> of the corresponding bits from $2.
 101
 102 =cut
 103
 104 inline op bnot(inout INT) :base_core {
 105   $1 = ~ $1;
 106   goto NEXT();
 107 }
 108
 109 inline op bnot(out INT, in INT) :base_core {
 110   $1 = ~ $2;
 111   goto NEXT();
 112 }
 113
 114 inline op bnot(invar PMC) :base_core {
 115   $1->vtable->i_bitwise_not(interp, $1);
 116   goto NEXT();
 117 }
 118
 119 inline op bnot(out PMC, invar PMC) :base_core {
 120   $1 = $2->vtable->bitwise_not(interp, $2, $1);
 121   goto NEXT();
 122 }
 123
 124 inline op n_bnot(out PMC, invar PMC) :base_core {
 125   $1 = $2->vtable->bitwise_not(interp, $2, NULL);
 126   goto NEXT();
 127 }
 128
 129 =item B<bnots>(inout STR)
 130
 131 =item B<bnots>(invar PMC)
 132
 133 =item B<bnots>(out STR, in STR)
 134
 135 =item B<bnots>(out PMC, invar PMC)
 136
 137 =item B<n_bnots>(out PMC, invar PMC)
 138
 139 Set the bits of $1 to the B<not> of the corresponding bits from $2.
 140
 141 =cut
 142
 143 inline op bnots(inout STR) :base_core {
 144   string_bitwise_not(interp, $1, &$1);
 145   goto NEXT();
 146 }
 147
 148 inline op bnots(out STR, in STR) :base_core {
 149   string_bitwise_not(interp, $2, &$1);
 150   goto NEXT();
 151 }
 152
 153 inline op bnots(invar PMC) :base_core {
 154   $1->vtable->i_bitwise_nots(interp, $1);
 155   goto NEXT();
 156 }
 157
 158 inline op bnots(out PMC, invar PMC) :base_core {
 159   $1 = $2->vtable->bitwise_nots(interp, $2, $1);
 160   goto NEXT();
 161 }
 162
 163 inline op n_bnots(out PMC, invar PMC) :base_core {
 164   $1 = $2->vtable->bitwise_nots(interp, $2, NULL);
 165   goto NEXT();
 166 }
 167
 168 ########################################
 169
 170 =item B<bor>(inout INT, in INT)
 171
 172 Set the bits of $1 according to the B<or> of the corresponding bits
 173 from $1 and $2.
 174
 175 =item B<bor>(out INT, in INT, in INT)
 176
 177 Set the bits of $1 according to the B<or> of the corresponding bits
 178 from $2 and $3.
 179
 180 =cut
 181
 182 inline op bor(inout INT, in INT) :base_core {
 183   $1 |= $2;
 184   goto NEXT();
 185 }
 186
 187 inline op bor(out INT, in INT, in INT) :base_core {
 188   $1 = $2 | $3;
 189   goto NEXT();
 190 }
 191
 192 =item B<bors>(inout STR, in STR)
 193
 194 Set the bits of $1 according to the B<or> of the corresponding bits
 195 from $1 and $2.
 196
 197 =item B<bors>(out STR, in STR, in STR)
 198
 199 Set the bits of $1 according to the B<or> of the corresponding bits
 200 from $2 and $3.
 201
 202 =cut
 203
 204 inline op bors(inout STR, in STR) :base_core {
 205   string_bitwise_or(interp, $1, $2, &$1);
 206   goto NEXT();
 207 }
 208
 209 inline op bors(out STR, in STR, in STR) :base_core {
 210   $1 = string_bitwise_or(interp, $2, $3, NULL);
 211   goto NEXT();
 212 }
 213
 214 ########################################
 215
 216 =item B<shl>(inout INT, in INT)
 217
 218 Shift left $1 by $2 bits.
 219
 220 =item B<shl>(out INT, in INT, in INT)
 221
 222 Set $1 to the value of $2 shifted left by $3 bits.
 223
 224 =cut
 225
 226 inline op shl(inout INT, in INT) :base_core {
 227   $1 = bit_shift_left($1, $2);
 228   goto NEXT();
 229 }
 230
 231 inline op shl(out INT, in INT, in INT) :base_core {
 232   $1 = bit_shift_left($2, $3);
 233   goto NEXT();
 234 }
 235
 236 ########################################
 237
 238 =item B<shr>(inout INT, in INT)
 239
 240 Shift right $1 by $2 bits.
 241
 242 =item B<shr>(out INT, in INT, in INT)
 243
 244 Set $1 to the value of $2 shifted right by $3 bits.
 245
 246 =cut
 247
 248 inline op shr(inout INT, in INT) :base_core {
 249   INTVAL signed_shift = -$2;
 250   $1 = bit_shift_left($1, signed_shift);
 251   goto NEXT();
 252 }
 253
 254 inline op shr(out INT, in INT, in INT) :base_core {
 255   INTVAL signed_shift = -$3;
 256   $1 = bit_shift_left($2, signed_shift);
 257   goto NEXT();
 258 }
 259
 260 ########################################
 261
 262 =item B<lsr>(out INT, in INT)
 263
 264 Shift $1 logically shifted right by $2 bits.
 265
 266 =item B<lsr>(out INT, in INT, in INT)
 267
 268 Set $1 to the value of $2 logically shifted right by $3 bits.
 269
 270 =cut
 271
 272 inline op lsr(out INT, in INT) :base_core {
 273   /*
 274    * lvalue casts are evil, but this one isn't evil enough to kill.
 275    * it's just casting a signed integral to the equivalent unsigned.
 276    */
 277   LVALUE_CAST(UINTVAL, $1) >>= $2;
 278   goto NEXT();
 279 }
 280
 281 inline op lsr(out INT, in INT, in INT) :base_core {
 282   $1 = (INTVAL)((UINTVAL)$2 >> $3);
 283   goto NEXT();
 284 }
 285
 286 =item B<rot>(out INT, in INT, in INT, inconst INT)
 287
 288 Rotate $2 left or right by $3 and place result in $1.
 289 $4 is the amount of bits to rotate, 32 bit on a 32-bit CPU and 32 or 64
 290 on a 64-bit CPU. If the rotate count is negative a rotate right by ($3+$4)
 291 is performed.
 292
 293 =cut
 294
 295 inline op rot(out INT, in INT, in INT, inconst INT) {
 296   const INTVAL r = $2;
 297   INTVAL s = $3;
 298   const INTVAL w = $4;
 299   INTVAL d, t;
 300   if (s < 0)
 301     s += w;
 302   d = r << s;
 303   t = w - s;
 304   t = (INTVAL)((UINTVAL)r >> t);
 305   d |= t;
 306   $1 = d;
 307   goto NEXT();
 308 }
 309
 310
 311 }
 312
 313 ########################################
 314
 315 =item B<bxor>(inout INT, in INT)
 316
 317 Set the bits of $1 according to the B<xor> of the corresponding bits
 318 from $1 and $2.
 319
 320 =item B<bxor>(out INT, in INT, in INT)
 321
 322 Set the bits of $1 according to the B<xor> of the corresponding bits
 323 from $2 and $3.
 324
 325 =cut
 326
 327 inline op bxor(inout INT, in INT) :base_core {
 328   $1 ^= $2;
 329   goto NEXT();
 330 }
 331
 332 inline op bxor(out INT, in INT, in INT) :base_core {
 333   $1 = $2 ^ $3;
 334   goto NEXT();
 335 }
 336
 337 =item B<bxors>(inout STR, in STR)
 338
 339 Set the bits of $1 according to the B<xor> of the corresponding bits
 340 from $1 and $2.
 341
 342 =item B<bxors>(out STR, in STR, in STR)
 343
 344 Set the bits of $1 according to the B<xor> of the corresponding bits
 345 from $2 and $3.
 346
 347 =cut
 348
 349 inline op bxors(inout STR, in STR) :base_core {
 350   string_bitwise_xor(interp, $1, $2, &$1);
 351   goto NEXT();
 352 }
 353
 354 inline op bxors(out STR, in STR, in STR) :base_core {
 355   $1 = string_bitwise_xor(interp, $2, $3, NULL);
 356   goto NEXT();
 357 }
 358
 359 =back
 360
 361 =cut
 362
 363 ###############################################################################
 364
 365 =head1 COPYRIGHT
 366
 367 Copyright (C) 2001-2006, The Perl Foundation.
 368
 369 =head1 LICENSE
 370
 371 This program is free software. It is subject to the same license
 372 as the Parrot interpreter itself.
 373
 374 =cut
 375
 376 /*
 377  * Local variables:
 378  *   c-file-style: "parrot"
 379  * End:
 380  * vim: expandtab shiftwidth=4:
 381  */