MdePkg/Library/BaseLib/BitField.c

   1 /** @file
   2   Bit field functions of BaseLib.
   3
   4   Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7 **/
   8
   9 #include "BaseLibInternals.h"
  10
  11 /**
  12   Worker function that returns a bit field from Operand.
  13
  14   Returns the bitfield specified by the StartBit and the EndBit from Operand.
  15
  16   @param  Operand   Operand on which to perform the bitfield operation.
  17   @param  StartBit  The ordinal of the least significant bit in the bit field.
  18   @param  EndBit    The ordinal of the most significant bit in the bit field.
  19
  20   @return The bit field read.
  21
  22 **/
  23 UINTN
  24 EFIAPI
  25 InternalBaseLibBitFieldReadUint (
  26   IN      UINTN  Operand,
  27   IN      UINTN  StartBit,
  28   IN      UINTN  EndBit
  29   )
  30 {
  31   //
  32   // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
  33   // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
  34   //
  35   return (Operand & ~((UINTN)-2 << EndBit)) >> StartBit;
  36 }
  37
  38 /**
  39   Worker function that reads a bit field from Operand, performs a bitwise OR,
  40   and returns the result.
  41
  42   Performs a bitwise OR between the bit field specified by StartBit and EndBit
  43   in Operand and the value specified by AndData. All other bits in Operand are
  44   preserved. The new value is returned.
  45
  46   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
  47
  48   @param  Operand   Operand on which to perform the bitfield operation.
  49   @param  StartBit  The ordinal of the least significant bit in the bit field.
  50   @param  EndBit    The ordinal of the most significant bit in the bit field.
  51   @param  OrData    The value to OR with the read value from the value.
  52
  53   @return The new value.
  54
  55 **/
  56 UINTN
  57 EFIAPI
  58 InternalBaseLibBitFieldOrUint (
  59   IN      UINTN  Operand,
  60   IN      UINTN  StartBit,
  61   IN      UINTN  EndBit,
  62   IN      UINTN  OrData
  63   )
  64 {
  65   //
  66   // Higher bits in OrData those are not used must be zero.
  67   //
  68   // EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
  69   // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
  70   //
  71   ASSERT ((OrData >> (EndBit - StartBit)) == ((OrData >> (EndBit - StartBit)) & 1));
  72
  73   //
  74   // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
  75   // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
  76   //
  77   return Operand | ((OrData << StartBit) & ~((UINTN)-2 << EndBit));
  78 }
  79
  80 /**
  81   Worker function that reads a bit field from Operand, performs a bitwise AND,
  82   and returns the result.
  83
  84   Performs a bitwise AND between the bit field specified by StartBit and EndBit
  85   in Operand and the value specified by AndData. All other bits in Operand are
  86   preserved. The new value is returned.
  87
  88   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
  89
  90   @param  Operand   Operand on which to perform the bitfield operation.
  91   @param  StartBit  The ordinal of the least significant bit in the bit field.
  92   @param  EndBit    The ordinal of the most significant bit in the bit field.
  93   @param  AndData    The value to And with the read value from the value.
  94
  95   @return The new value.
  96
  97 **/
  98 UINTN
  99 EFIAPI
 100 InternalBaseLibBitFieldAndUint (
 101   IN      UINTN  Operand,
 102   IN      UINTN  StartBit,
 103   IN      UINTN  EndBit,
 104   IN      UINTN  AndData
 105   )
 106 {
 107   //
 108   // Higher bits in AndData those are not used must be zero.
 109   //
 110   // EndBit - StartBit + 1 might be 32 while the result right shifting 32 on a 32bit integer is undefined,
 111   // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
 112   //
 113   ASSERT ((AndData >> (EndBit - StartBit)) == ((AndData >> (EndBit - StartBit)) & 1));
 114
 115   //
 116   // ~((UINTN)-2 << EndBit) is a mask in which bit[0] thru bit[EndBit]
 117   // are 1's while bit[EndBit + 1] thru the most significant bit are 0's.
 118   //
 119   return Operand & ~((~AndData << StartBit) & ~((UINTN)-2 << EndBit));
 120 }
 121
 122 /**
 123   Returns a bit field from an 8-bit value.
 124
 125   Returns the bitfield specified by the StartBit and the EndBit from Operand.
 126
 127   If 8-bit operations are not supported, then ASSERT().
 128   If StartBit is greater than 7, then ASSERT().
 129   If EndBit is greater than 7, then ASSERT().
 130   If EndBit is less than StartBit, then ASSERT().
 131
 132   @param  Operand   Operand on which to perform the bitfield operation.
 133   @param  StartBit  The ordinal of the least significant bit in the bit field.
 134                     Range 0..7.
 135   @param  EndBit    The ordinal of the most significant bit in the bit field.
 136                     Range 0..7.
 137
 138   @return The bit field read.
 139
 140 **/
 141 UINT8
 142 EFIAPI
 143 BitFieldRead8 (
 144   IN      UINT8  Operand,
 145   IN      UINTN  StartBit,
 146   IN      UINTN  EndBit
 147   )
 148 {
 149   ASSERT (EndBit < 8);
 150   ASSERT (StartBit <= EndBit);
 151   return (UINT8)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
 152 }
 153
 154 /**
 155   Writes a bit field to an 8-bit value, and returns the result.
 156
 157   Writes Value to the bit field specified by the StartBit and the EndBit in
 158   Operand. All other bits in Operand are preserved. The new 8-bit value is
 159   returned.
 160
 161   If 8-bit operations are not supported, then ASSERT().
 162   If StartBit is greater than 7, then ASSERT().
 163   If EndBit is greater than 7, then ASSERT().
 164   If EndBit is less than StartBit, then ASSERT().
 165   If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 166
 167   @param  Operand   Operand on which to perform the bitfield operation.
 168   @param  StartBit  The ordinal of the least significant bit in the bit field.
 169                     Range 0..7.
 170   @param  EndBit    The ordinal of the most significant bit in the bit field.
 171                     Range 0..7.
 172   @param  Value     The new value of the bit field.
 173
 174   @return The new 8-bit value.
 175
 176 **/
 177 UINT8
 178 EFIAPI
 179 BitFieldWrite8 (
 180   IN      UINT8  Operand,
 181   IN      UINTN  StartBit,
 182   IN      UINTN  EndBit,
 183   IN      UINT8  Value
 184   )
 185 {
 186   ASSERT (EndBit < 8);
 187   ASSERT (StartBit <= EndBit);
 188   return BitFieldAndThenOr8 (Operand, StartBit, EndBit, 0, Value);
 189 }
 190
 191 /**
 192   Reads a bit field from an 8-bit value, performs a bitwise OR, and returns the
 193   result.
 194
 195   Performs a bitwise OR between the bit field specified by StartBit
 196   and EndBit in Operand and the value specified by OrData. All other bits in
 197   Operand are preserved. The new 8-bit value is returned.
 198
 199   If 8-bit operations are not supported, then ASSERT().
 200   If StartBit is greater than 7, then ASSERT().
 201   If EndBit is greater than 7, then ASSERT().
 202   If EndBit is less than StartBit, then ASSERT().
 203   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 204
 205   @param  Operand   Operand on which to perform the bitfield operation.
 206   @param  StartBit  The ordinal of the least significant bit in the bit field.
 207                     Range 0..7.
 208   @param  EndBit    The ordinal of the most significant bit in the bit field.
 209                     Range 0..7.
 210   @param  OrData    The value to OR with the read value from the value.
 211
 212   @return The new 8-bit value.
 213
 214 **/
 215 UINT8
 216 EFIAPI
 217 BitFieldOr8 (
 218   IN      UINT8  Operand,
 219   IN      UINTN  StartBit,
 220   IN      UINTN  EndBit,
 221   IN      UINT8  OrData
 222   )
 223 {
 224   ASSERT (EndBit < 8);
 225   ASSERT (StartBit <= EndBit);
 226   return (UINT8)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
 227 }
 228
 229 /**
 230   Reads a bit field from an 8-bit value, performs a bitwise AND, and returns
 231   the result.
 232
 233   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 234   in Operand and the value specified by AndData. All other bits in Operand are
 235   preserved. The new 8-bit value is returned.
 236
 237   If 8-bit operations are not supported, then ASSERT().
 238   If StartBit is greater than 7, then ASSERT().
 239   If EndBit is greater than 7, then ASSERT().
 240   If EndBit is less than StartBit, then ASSERT().
 241   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 242
 243   @param  Operand   Operand on which to perform the bitfield operation.
 244   @param  StartBit  The ordinal of the least significant bit in the bit field.
 245                     Range 0..7.
 246   @param  EndBit    The ordinal of the most significant bit in the bit field.
 247                     Range 0..7.
 248   @param  AndData   The value to AND with the read value from the value.
 249
 250   @return The new 8-bit value.
 251
 252 **/
 253 UINT8
 254 EFIAPI
 255 BitFieldAnd8 (
 256   IN      UINT8  Operand,
 257   IN      UINTN  StartBit,
 258   IN      UINTN  EndBit,
 259   IN      UINT8  AndData
 260   )
 261 {
 262   ASSERT (EndBit < 8);
 263   ASSERT (StartBit <= EndBit);
 264   return (UINT8)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
 265 }
 266
 267 /**
 268   Reads a bit field from an 8-bit value, performs a bitwise AND followed by a
 269   bitwise OR, and returns the result.
 270
 271   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 272   in Operand and the value specified by AndData, followed by a bitwise
 273   OR with value specified by OrData. All other bits in Operand are
 274   preserved. The new 8-bit value is returned.
 275
 276   If 8-bit operations are not supported, then ASSERT().
 277   If StartBit is greater than 7, then ASSERT().
 278   If EndBit is greater than 7, then ASSERT().
 279   If EndBit is less than StartBit, then ASSERT().
 280   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 281   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 282
 283   @param  Operand   Operand on which to perform the bitfield operation.
 284   @param  StartBit  The ordinal of the least significant bit in the bit field.
 285                     Range 0..7.
 286   @param  EndBit    The ordinal of the most significant bit in the bit field.
 287                     Range 0..7.
 288   @param  AndData   The value to AND with the read value from the value.
 289   @param  OrData    The value to OR with the result of the AND operation.
 290
 291   @return The new 8-bit value.
 292
 293 **/
 294 UINT8
 295 EFIAPI
 296 BitFieldAndThenOr8 (
 297   IN      UINT8  Operand,
 298   IN      UINTN  StartBit,
 299   IN      UINTN  EndBit,
 300   IN      UINT8  AndData,
 301   IN      UINT8  OrData
 302   )
 303 {
 304   ASSERT (EndBit < 8);
 305   ASSERT (StartBit <= EndBit);
 306   return BitFieldOr8 (
 307            BitFieldAnd8 (Operand, StartBit, EndBit, AndData),
 308            StartBit,
 309            EndBit,
 310            OrData
 311            );
 312 }
 313
 314 /**
 315   Returns a bit field from a 16-bit value.
 316
 317   Returns the bitfield specified by the StartBit and the EndBit from Operand.
 318
 319   If 16-bit operations are not supported, then ASSERT().
 320   If StartBit is greater than 15, then ASSERT().
 321   If EndBit is greater than 15, then ASSERT().
 322   If EndBit is less than StartBit, then ASSERT().
 323
 324   @param  Operand   Operand on which to perform the bitfield operation.
 325   @param  StartBit  The ordinal of the least significant bit in the bit field.
 326                     Range 0..15.
 327   @param  EndBit    The ordinal of the most significant bit in the bit field.
 328                     Range 0..15.
 329
 330   @return The bit field read.
 331
 332 **/
 333 UINT16
 334 EFIAPI
 335 BitFieldRead16 (
 336   IN      UINT16  Operand,
 337   IN      UINTN   StartBit,
 338   IN      UINTN   EndBit
 339   )
 340 {
 341   ASSERT (EndBit < 16);
 342   ASSERT (StartBit <= EndBit);
 343   return (UINT16)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
 344 }
 345
 346 /**
 347   Writes a bit field to a 16-bit value, and returns the result.
 348
 349   Writes Value to the bit field specified by the StartBit and the EndBit in
 350   Operand. All other bits in Operand are preserved. The new 16-bit value is
 351   returned.
 352
 353   If 16-bit operations are not supported, then ASSERT().
 354   If StartBit is greater than 15, then ASSERT().
 355   If EndBit is greater than 15, then ASSERT().
 356   If EndBit is less than StartBit, then ASSERT().
 357   If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 358
 359   @param  Operand   Operand on which to perform the bitfield operation.
 360   @param  StartBit  The ordinal of the least significant bit in the bit field.
 361                     Range 0..15.
 362   @param  EndBit    The ordinal of the most significant bit in the bit field.
 363                     Range 0..15.
 364   @param  Value     The new value of the bit field.
 365
 366   @return The new 16-bit value.
 367
 368 **/
 369 UINT16
 370 EFIAPI
 371 BitFieldWrite16 (
 372   IN      UINT16  Operand,
 373   IN      UINTN   StartBit,
 374   IN      UINTN   EndBit,
 375   IN      UINT16  Value
 376   )
 377 {
 378   ASSERT (EndBit < 16);
 379   ASSERT (StartBit <= EndBit);
 380   return BitFieldAndThenOr16 (Operand, StartBit, EndBit, 0, Value);
 381 }
 382
 383 /**
 384   Reads a bit field from a 16-bit value, performs a bitwise OR, and returns the
 385   result.
 386
 387   Performs a bitwise OR between the bit field specified by StartBit
 388   and EndBit in Operand and the value specified by OrData. All other bits in
 389   Operand are preserved. The new 16-bit value is returned.
 390
 391   If 16-bit operations are not supported, then ASSERT().
 392   If StartBit is greater than 15, then ASSERT().
 393   If EndBit is greater than 15, then ASSERT().
 394   If EndBit is less than StartBit, then ASSERT().
 395   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 396
 397   @param  Operand   Operand on which to perform the bitfield operation.
 398   @param  StartBit  The ordinal of the least significant bit in the bit field.
 399                     Range 0..15.
 400   @param  EndBit    The ordinal of the most significant bit in the bit field.
 401                     Range 0..15.
 402   @param  OrData    The value to OR with the read value from the value.
 403
 404   @return The new 16-bit value.
 405
 406 **/
 407 UINT16
 408 EFIAPI
 409 BitFieldOr16 (
 410   IN      UINT16  Operand,
 411   IN      UINTN   StartBit,
 412   IN      UINTN   EndBit,
 413   IN      UINT16  OrData
 414   )
 415 {
 416   ASSERT (EndBit < 16);
 417   ASSERT (StartBit <= EndBit);
 418   return (UINT16)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
 419 }
 420
 421 /**
 422   Reads a bit field from a 16-bit value, performs a bitwise AND, and returns
 423   the result.
 424
 425   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 426   in Operand and the value specified by AndData. All other bits in Operand are
 427   preserved. The new 16-bit value is returned.
 428
 429   If 16-bit operations are not supported, then ASSERT().
 430   If StartBit is greater than 15, then ASSERT().
 431   If EndBit is greater than 15, then ASSERT().
 432   If EndBit is less than StartBit, then ASSERT().
 433   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 434
 435   @param  Operand   Operand on which to perform the bitfield operation.
 436   @param  StartBit  The ordinal of the least significant bit in the bit field.
 437                     Range 0..15.
 438   @param  EndBit    The ordinal of the most significant bit in the bit field.
 439                     Range 0..15.
 440   @param  AndData   The value to AND with the read value from the value.
 441
 442   @return The new 16-bit value.
 443
 444 **/
 445 UINT16
 446 EFIAPI
 447 BitFieldAnd16 (
 448   IN      UINT16  Operand,
 449   IN      UINTN   StartBit,
 450   IN      UINTN   EndBit,
 451   IN      UINT16  AndData
 452   )
 453 {
 454   ASSERT (EndBit < 16);
 455   ASSERT (StartBit <= EndBit);
 456   return (UINT16)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
 457 }
 458
 459 /**
 460   Reads a bit field from a 16-bit value, performs a bitwise AND followed by a
 461   bitwise OR, and returns the result.
 462
 463   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 464   in Operand and the value specified by AndData, followed by a bitwise
 465   OR with value specified by OrData. All other bits in Operand are
 466   preserved. The new 16-bit value is returned.
 467
 468   If 16-bit operations are not supported, then ASSERT().
 469   If StartBit is greater than 15, then ASSERT().
 470   If EndBit is greater than 15, then ASSERT().
 471   If EndBit is less than StartBit, then ASSERT().
 472   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 473   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 474
 475   @param  Operand   Operand on which to perform the bitfield operation.
 476   @param  StartBit  The ordinal of the least significant bit in the bit field.
 477                     Range 0..15.
 478   @param  EndBit    The ordinal of the most significant bit in the bit field.
 479                     Range 0..15.
 480   @param  AndData   The value to AND with the read value from the value.
 481   @param  OrData    The value to OR with the result of the AND operation.
 482
 483   @return The new 16-bit value.
 484
 485 **/
 486 UINT16
 487 EFIAPI
 488 BitFieldAndThenOr16 (
 489   IN      UINT16  Operand,
 490   IN      UINTN   StartBit,
 491   IN      UINTN   EndBit,
 492   IN      UINT16  AndData,
 493   IN      UINT16  OrData
 494   )
 495 {
 496   ASSERT (EndBit < 16);
 497   ASSERT (StartBit <= EndBit);
 498   return BitFieldOr16 (
 499            BitFieldAnd16 (Operand, StartBit, EndBit, AndData),
 500            StartBit,
 501            EndBit,
 502            OrData
 503            );
 504 }
 505
 506 /**
 507   Returns a bit field from a 32-bit value.
 508
 509   Returns the bitfield specified by the StartBit and the EndBit from Operand.
 510
 511   If 32-bit operations are not supported, then ASSERT().
 512   If StartBit is greater than 31, then ASSERT().
 513   If EndBit is greater than 31, then ASSERT().
 514   If EndBit is less than StartBit, then ASSERT().
 515
 516   @param  Operand   Operand on which to perform the bitfield operation.
 517   @param  StartBit  The ordinal of the least significant bit in the bit field.
 518                     Range 0..31.
 519   @param  EndBit    The ordinal of the most significant bit in the bit field.
 520                     Range 0..31.
 521
 522   @return The bit field read.
 523
 524 **/
 525 UINT32
 526 EFIAPI
 527 BitFieldRead32 (
 528   IN      UINT32  Operand,
 529   IN      UINTN   StartBit,
 530   IN      UINTN   EndBit
 531   )
 532 {
 533   ASSERT (EndBit < 32);
 534   ASSERT (StartBit <= EndBit);
 535   return (UINT32)InternalBaseLibBitFieldReadUint (Operand, StartBit, EndBit);
 536 }
 537
 538 /**
 539   Writes a bit field to a 32-bit value, and returns the result.
 540
 541   Writes Value to the bit field specified by the StartBit and the EndBit in
 542   Operand. All other bits in Operand are preserved. The new 32-bit value is
 543   returned.
 544
 545   If 32-bit operations are not supported, then ASSERT().
 546   If StartBit is greater than 31, then ASSERT().
 547   If EndBit is greater than 31, then ASSERT().
 548   If EndBit is less than StartBit, then ASSERT().
 549   If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 550
 551   @param  Operand   Operand on which to perform the bitfield operation.
 552   @param  StartBit  The ordinal of the least significant bit in the bit field.
 553                     Range 0..31.
 554   @param  EndBit    The ordinal of the most significant bit in the bit field.
 555                     Range 0..31.
 556   @param  Value     The new value of the bit field.
 557
 558   @return The new 32-bit value.
 559
 560 **/
 561 UINT32
 562 EFIAPI
 563 BitFieldWrite32 (
 564   IN      UINT32  Operand,
 565   IN      UINTN   StartBit,
 566   IN      UINTN   EndBit,
 567   IN      UINT32  Value
 568   )
 569 {
 570   ASSERT (EndBit < 32);
 571   ASSERT (StartBit <= EndBit);
 572   return BitFieldAndThenOr32 (Operand, StartBit, EndBit, 0, Value);
 573 }
 574
 575 /**
 576   Reads a bit field from a 32-bit value, performs a bitwise OR, and returns the
 577   result.
 578
 579   Performs a bitwise OR between the bit field specified by StartBit
 580   and EndBit in Operand and the value specified by OrData. All other bits in
 581   Operand are preserved. The new 32-bit value is returned.
 582
 583   If 32-bit operations are not supported, then ASSERT().
 584   If StartBit is greater than 31, then ASSERT().
 585   If EndBit is greater than 31, then ASSERT().
 586   If EndBit is less than StartBit, then ASSERT().
 587   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 588
 589   @param  Operand   Operand on which to perform the bitfield operation.
 590   @param  StartBit  The ordinal of the least significant bit in the bit field.
 591                     Range 0..31.
 592   @param  EndBit    The ordinal of the most significant bit in the bit field.
 593                     Range 0..31.
 594   @param  OrData    The value to OR with the read value from the value.
 595
 596   @return The new 32-bit value.
 597
 598 **/
 599 UINT32
 600 EFIAPI
 601 BitFieldOr32 (
 602   IN      UINT32  Operand,
 603   IN      UINTN   StartBit,
 604   IN      UINTN   EndBit,
 605   IN      UINT32  OrData
 606   )
 607 {
 608   ASSERT (EndBit < 32);
 609   ASSERT (StartBit <= EndBit);
 610   return (UINT32)InternalBaseLibBitFieldOrUint (Operand, StartBit, EndBit, OrData);
 611 }
 612
 613 /**
 614   Reads a bit field from a 32-bit value, performs a bitwise AND, and returns
 615   the result.
 616
 617   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 618   in Operand and the value specified by AndData. All other bits in Operand are
 619   preserved. The new 32-bit value is returned.
 620
 621   If 32-bit operations are not supported, then ASSERT().
 622   If StartBit is greater than 31, then ASSERT().
 623   If EndBit is greater than 31, then ASSERT().
 624   If EndBit is less than StartBit, then ASSERT().
 625   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 626
 627   @param  Operand   Operand on which to perform the bitfield operation.
 628   @param  StartBit  The ordinal of the least significant bit in the bit field.
 629                     Range 0..31.
 630   @param  EndBit    The ordinal of the most significant bit in the bit field.
 631                     Range 0..31.
 632   @param  AndData   The value to AND with the read value from the value.
 633
 634   @return The new 32-bit value.
 635
 636 **/
 637 UINT32
 638 EFIAPI
 639 BitFieldAnd32 (
 640   IN      UINT32  Operand,
 641   IN      UINTN   StartBit,
 642   IN      UINTN   EndBit,
 643   IN      UINT32  AndData
 644   )
 645 {
 646   ASSERT (EndBit < 32);
 647   ASSERT (StartBit <= EndBit);
 648   return (UINT32)InternalBaseLibBitFieldAndUint (Operand, StartBit, EndBit, AndData);
 649 }
 650
 651 /**
 652   Reads a bit field from a 32-bit value, performs a bitwise AND followed by a
 653   bitwise OR, and returns the result.
 654
 655   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 656   in Operand and the value specified by AndData, followed by a bitwise
 657   OR with value specified by OrData. All other bits in Operand are
 658   preserved. The new 32-bit value is returned.
 659
 660   If 32-bit operations are not supported, then ASSERT().
 661   If StartBit is greater than 31, then ASSERT().
 662   If EndBit is greater than 31, then ASSERT().
 663   If EndBit is less than StartBit, then ASSERT().
 664   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 665   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 666
 667   @param  Operand   Operand on which to perform the bitfield operation.
 668   @param  StartBit  The ordinal of the least significant bit in the bit field.
 669                     Range 0..31.
 670   @param  EndBit    The ordinal of the most significant bit in the bit field.
 671                     Range 0..31.
 672   @param  AndData   The value to AND with the read value from the value.
 673   @param  OrData    The value to OR with the result of the AND operation.
 674
 675   @return The new 32-bit value.
 676
 677 **/
 678 UINT32
 679 EFIAPI
 680 BitFieldAndThenOr32 (
 681   IN      UINT32  Operand,
 682   IN      UINTN   StartBit,
 683   IN      UINTN   EndBit,
 684   IN      UINT32  AndData,
 685   IN      UINT32  OrData
 686   )
 687 {
 688   ASSERT (EndBit < 32);
 689   ASSERT (StartBit <= EndBit);
 690   return BitFieldOr32 (
 691            BitFieldAnd32 (Operand, StartBit, EndBit, AndData),
 692            StartBit,
 693            EndBit,
 694            OrData
 695            );
 696 }
 697
 698 /**
 699   Returns a bit field from a 64-bit value.
 700
 701   Returns the bitfield specified by the StartBit and the EndBit from Operand.
 702
 703   If 64-bit operations are not supported, then ASSERT().
 704   If StartBit is greater than 63, then ASSERT().
 705   If EndBit is greater than 63, then ASSERT().
 706   If EndBit is less than StartBit, then ASSERT().
 707
 708   @param  Operand   Operand on which to perform the bitfield operation.
 709   @param  StartBit  The ordinal of the least significant bit in the bit field.
 710                     Range 0..63.
 711   @param  EndBit    The ordinal of the most significant bit in the bit field.
 712                     Range 0..63.
 713
 714   @return The bit field read.
 715
 716 **/
 717 UINT64
 718 EFIAPI
 719 BitFieldRead64 (
 720   IN      UINT64  Operand,
 721   IN      UINTN   StartBit,
 722   IN      UINTN   EndBit
 723   )
 724 {
 725   ASSERT (EndBit < 64);
 726   ASSERT (StartBit <= EndBit);
 727   return RShiftU64 (Operand & ~LShiftU64 ((UINT64)-2, EndBit), StartBit);
 728 }
 729
 730 /**
 731   Writes a bit field to a 64-bit value, and returns the result.
 732
 733   Writes Value to the bit field specified by the StartBit and the EndBit in
 734   Operand. All other bits in Operand are preserved. The new 64-bit value is
 735   returned.
 736
 737   If 64-bit operations are not supported, then ASSERT().
 738   If StartBit is greater than 63, then ASSERT().
 739   If EndBit is greater than 63, then ASSERT().
 740   If EndBit is less than StartBit, then ASSERT().
 741   If Value is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 742
 743   @param  Operand   Operand on which to perform the bitfield operation.
 744   @param  StartBit  The ordinal of the least significant bit in the bit field.
 745                     Range 0..63.
 746   @param  EndBit    The ordinal of the most significant bit in the bit field.
 747                     Range 0..63.
 748   @param  Value     The new value of the bit field.
 749
 750   @return The new 64-bit value.
 751
 752 **/
 753 UINT64
 754 EFIAPI
 755 BitFieldWrite64 (
 756   IN      UINT64  Operand,
 757   IN      UINTN   StartBit,
 758   IN      UINTN   EndBit,
 759   IN      UINT64  Value
 760   )
 761 {
 762   ASSERT (EndBit < 64);
 763   ASSERT (StartBit <= EndBit);
 764   return BitFieldAndThenOr64 (Operand, StartBit, EndBit, 0, Value);
 765 }
 766
 767 /**
 768   Reads a bit field from a 64-bit value, performs a bitwise OR, and returns the
 769   result.
 770
 771   Performs a bitwise OR between the bit field specified by StartBit
 772   and EndBit in Operand and the value specified by OrData. All other bits in
 773   Operand are preserved. The new 64-bit value is returned.
 774
 775   If 64-bit operations are not supported, then ASSERT().
 776   If StartBit is greater than 63, then ASSERT().
 777   If EndBit is greater than 63, then ASSERT().
 778   If EndBit is less than StartBit, then ASSERT().
 779   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 780
 781   @param  Operand   Operand on which to perform the bitfield operation.
 782   @param  StartBit  The ordinal of the least significant bit in the bit field.
 783                     Range 0..63.
 784   @param  EndBit    The ordinal of the most significant bit in the bit field.
 785                     Range 0..63.
 786   @param  OrData    The value to OR with the read value from the value
 787
 788   @return The new 64-bit value.
 789
 790 **/
 791 UINT64
 792 EFIAPI
 793 BitFieldOr64 (
 794   IN      UINT64  Operand,
 795   IN      UINTN   StartBit,
 796   IN      UINTN   EndBit,
 797   IN      UINT64  OrData
 798   )
 799 {
 800   UINT64  Value1;
 801   UINT64  Value2;
 802
 803   ASSERT (EndBit < 64);
 804   ASSERT (StartBit <= EndBit);
 805   //
 806   // Higher bits in OrData those are not used must be zero.
 807   //
 808   // EndBit - StartBit + 1 might be 64 while the result right shifting 64 on RShiftU64() API is invalid,
 809   // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
 810   //
 811   ASSERT (RShiftU64 (OrData, EndBit - StartBit) == (RShiftU64 (OrData, EndBit - StartBit) & 1));
 812
 813   Value1 = LShiftU64 (OrData, StartBit);
 814   Value2 = LShiftU64 ((UINT64)-2, EndBit);
 815
 816   return Operand | (Value1 & ~Value2);
 817 }
 818
 819 /**
 820   Reads a bit field from a 64-bit value, performs a bitwise AND, and returns
 821   the result.
 822
 823   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 824   in Operand and the value specified by AndData. All other bits in Operand are
 825   preserved. The new 64-bit value is returned.
 826
 827   If 64-bit operations are not supported, then ASSERT().
 828   If StartBit is greater than 63, then ASSERT().
 829   If EndBit is greater than 63, then ASSERT().
 830   If EndBit is less than StartBit, then ASSERT().
 831   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 832
 833   @param  Operand   Operand on which to perform the bitfield operation.
 834   @param  StartBit  The ordinal of the least significant bit in the bit field.
 835                     Range 0..63.
 836   @param  EndBit    The ordinal of the most significant bit in the bit field.
 837                     Range 0..63.
 838   @param  AndData   The value to AND with the read value from the value.
 839
 840   @return The new 64-bit value.
 841
 842 **/
 843 UINT64
 844 EFIAPI
 845 BitFieldAnd64 (
 846   IN      UINT64  Operand,
 847   IN      UINTN   StartBit,
 848   IN      UINTN   EndBit,
 849   IN      UINT64  AndData
 850   )
 851 {
 852   UINT64  Value1;
 853   UINT64  Value2;
 854
 855   ASSERT (EndBit < 64);
 856   ASSERT (StartBit <= EndBit);
 857   //
 858   // Higher bits in AndData those are not used must be zero.
 859   //
 860   // EndBit - StartBit + 1 might be 64 while the right shifting 64 on RShiftU64() API is invalid,
 861   // So the logic is updated to right shift (EndBit - StartBit) bits and compare the last bit directly.
 862   //
 863   ASSERT (RShiftU64 (AndData, EndBit - StartBit) == (RShiftU64 (AndData, EndBit - StartBit) & 1));
 864
 865   Value1 = LShiftU64 (~AndData, StartBit);
 866   Value2 = LShiftU64 ((UINT64)-2, EndBit);
 867
 868   return Operand & ~(Value1 & ~Value2);
 869 }
 870
 871 /**
 872   Reads a bit field from a 64-bit value, performs a bitwise AND followed by a
 873   bitwise OR, and returns the result.
 874
 875   Performs a bitwise AND between the bit field specified by StartBit and EndBit
 876   in Operand and the value specified by AndData, followed by a bitwise
 877   OR with value specified by OrData. All other bits in Operand are
 878   preserved. The new 64-bit value is returned.
 879
 880   If 64-bit operations are not supported, then ASSERT().
 881   If StartBit is greater than 63, then ASSERT().
 882   If EndBit is greater than 63, then ASSERT().
 883   If EndBit is less than StartBit, then ASSERT().
 884   If AndData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 885   If OrData is larger than the bitmask value range specified by StartBit and EndBit, then ASSERT().
 886
 887   @param  Operand   Operand on which to perform the bitfield operation.
 888   @param  StartBit  The ordinal of the least significant bit in the bit field.
 889                     Range 0..63.
 890   @param  EndBit    The ordinal of the most significant bit in the bit field.
 891                     Range 0..63.
 892   @param  AndData   The value to AND with the read value from the value.
 893   @param  OrData    The value to OR with the result of the AND operation.
 894
 895   @return The new 64-bit value.
 896
 897 **/
 898 UINT64
 899 EFIAPI
 900 BitFieldAndThenOr64 (
 901   IN      UINT64  Operand,
 902   IN      UINTN   StartBit,
 903   IN      UINTN   EndBit,
 904   IN      UINT64  AndData,
 905   IN      UINT64  OrData
 906   )
 907 {
 908   ASSERT (EndBit < 64);
 909   ASSERT (StartBit <= EndBit);
 910   return BitFieldOr64 (
 911            BitFieldAnd64 (Operand, StartBit, EndBit, AndData),
 912            StartBit,
 913            EndBit,
 914            OrData
 915            );
 916 }
 917
 918 /**
 919   Reads a bit field from a 32-bit value, counts and returns
 920   the number of set bits.
 921
 922   Counts the number of set bits in the  bit field specified by
 923   StartBit and EndBit in Operand. The count is returned.
 924
 925   If StartBit is greater than 31, then ASSERT().
 926   If EndBit is greater than 31, then ASSERT().
 927   If EndBit is less than StartBit, then ASSERT().
 928
 929   @param  Operand   Operand on which to perform the bitfield operation.
 930   @param  StartBit  The ordinal of the least significant bit in the bit field.
 931                     Range 0..31.
 932   @param  EndBit    The ordinal of the most significant bit in the bit field.
 933                     Range 0..31.
 934
 935   @return The number of bits set between StartBit and EndBit.
 936
 937 **/
 938 UINT8
 939 EFIAPI
 940 BitFieldCountOnes32 (
 941   IN       UINT32  Operand,
 942   IN       UINTN   StartBit,
 943   IN       UINTN   EndBit
 944   )
 945 {
 946   UINT32  Count;
 947
 948   ASSERT (EndBit < 32);
 949   ASSERT (StartBit <= EndBit);
 950
 951   Count  = BitFieldRead32 (Operand, StartBit, EndBit);
 952   Count -= ((Count >> 1) & 0x55555555);
 953   Count  = (Count & 0x33333333) + ((Count >> 2) & 0x33333333);
 954   Count += Count >> 4;
 955   Count &= 0x0F0F0F0F;
 956   Count += Count >> 8;
 957   Count += Count >> 16;
 958
 959   return (UINT8)Count & 0x3F;
 960 }
 961
 962 /**
 963    Reads a bit field from a 64-bit value, counts and returns
 964    the number of set bits.
 965
 966    Counts the number of set bits in the  bit field specified by
 967    StartBit and EndBit in Operand. The count is returned.
 968
 969    If StartBit is greater than 63, then ASSERT().
 970    If EndBit is greater than 63, then ASSERT().
 971    If EndBit is less than StartBit, then ASSERT().
 972
 973    @param  Operand   Operand on which to perform the bitfield operation.
 974    @param  StartBit  The ordinal of the least significant bit in the bit field.
 975    Range 0..63.
 976    @param  EndBit    The ordinal of the most significant bit in the bit field.
 977    Range 0..63.
 978
 979    @return The number of bits set between StartBit and EndBit.
 980
 981 **/
 982 UINT8
 983 EFIAPI
 984 BitFieldCountOnes64 (
 985   IN       UINT64  Operand,
 986   IN       UINTN   StartBit,
 987   IN       UINTN   EndBit
 988   )
 989 {
 990   UINT64  BitField;
 991   UINT8   Count;
 992
 993   ASSERT (EndBit < 64);
 994   ASSERT (StartBit <= EndBit);
 995
 996   BitField = BitFieldRead64 (Operand, StartBit, EndBit);
 997   Count    = BitFieldCountOnes32 ((UINT32)BitField, 0, 31);
 998   Count   += BitFieldCountOnes32 ((UINT32)RShiftU64 (BitField, 32), 0, 31);
 999
1000   return Count;
1001 }