include/xdk/rtlfuncs.h

   1 /******************************************************************************
   2  *                         Runtime Library Functions                          *
   3  ******************************************************************************/
   4
   5 $if (_WDMDDK_)
   6
   7 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
   8
   9 #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
  10
  11 FORCEINLINE
  12 VOID
  13 InitializeListHead(
  14   OUT PLIST_ENTRY ListHead)
  15 {
  16   ListHead->Flink = ListHead->Blink = ListHead;
  17 }
  18
  19 BOOLEAN
  20 FORCEINLINE
  21 IsListEmpty(
  22   IN CONST LIST_ENTRY * ListHead)
  23 {
  24   return (BOOLEAN)(ListHead->Flink == ListHead);
  25 }
  26
  27 FORCEINLINE
  28 BOOLEAN
  29 RemoveEntryList(
  30   IN PLIST_ENTRY Entry)
  31 {
  32   PLIST_ENTRY OldFlink;
  33   PLIST_ENTRY OldBlink;
  34
  35   OldFlink = Entry->Flink;
  36   OldBlink = Entry->Blink;
  37   OldFlink->Blink = OldBlink;
  38   OldBlink->Flink = OldFlink;
  39   return (BOOLEAN)(OldFlink == OldBlink);
  40 }
  41
  42 FORCEINLINE
  43 PLIST_ENTRY
  44 RemoveHeadList(
  45   IN OUT PLIST_ENTRY ListHead)
  46 {
  47   PLIST_ENTRY Flink;
  48   PLIST_ENTRY Entry;
  49
  50   Entry = ListHead->Flink;
  51   Flink = Entry->Flink;
  52   ListHead->Flink = Flink;
  53   Flink->Blink = ListHead;
  54   return Entry;
  55 }
  56
  57 FORCEINLINE
  58 PLIST_ENTRY
  59 RemoveTailList(
  60   IN OUT PLIST_ENTRY ListHead)
  61 {
  62   PLIST_ENTRY Blink;
  63   PLIST_ENTRY Entry;
  64
  65   Entry = ListHead->Blink;
  66   Blink = Entry->Blink;
  67   ListHead->Blink = Blink;
  68   Blink->Flink = ListHead;
  69   return Entry;
  70 }
  71
  72 FORCEINLINE
  73 VOID
  74 InsertTailList(
  75   IN OUT PLIST_ENTRY ListHead,
  76   IN OUT PLIST_ENTRY Entry)
  77 {
  78   PLIST_ENTRY OldBlink;
  79   OldBlink = ListHead->Blink;
  80   Entry->Flink = ListHead;
  81   Entry->Blink = OldBlink;
  82   OldBlink->Flink = Entry;
  83   ListHead->Blink = Entry;
  84 }
  85
  86 FORCEINLINE
  87 VOID
  88 InsertHeadList(
  89   IN OUT PLIST_ENTRY ListHead,
  90   IN OUT PLIST_ENTRY Entry)
  91 {
  92   PLIST_ENTRY OldFlink;
  93   OldFlink = ListHead->Flink;
  94   Entry->Flink = OldFlink;
  95   Entry->Blink = ListHead;
  96   OldFlink->Blink = Entry;
  97   ListHead->Flink = Entry;
  98 }
  99
 100 FORCEINLINE
 101 VOID
 102 AppendTailList(
 103   IN OUT PLIST_ENTRY ListHead,
 104   IN OUT PLIST_ENTRY ListToAppend)
 105 {
 106   PLIST_ENTRY ListEnd = ListHead->Blink;
 107
 108   ListHead->Blink->Flink = ListToAppend;
 109   ListHead->Blink = ListToAppend->Blink;
 110   ListToAppend->Blink->Flink = ListHead;
 111   ListToAppend->Blink = ListEnd;
 112 }
 113
 114 FORCEINLINE
 115 PSINGLE_LIST_ENTRY
 116 PopEntryList(
 117   IN OUT PSINGLE_LIST_ENTRY ListHead)
 118 {
 119   PSINGLE_LIST_ENTRY FirstEntry;
 120   FirstEntry = ListHead->Next;
 121   if (FirstEntry != NULL) {
 122     ListHead->Next = FirstEntry->Next;
 123   }
 124   return FirstEntry;
 125 }
 126
 127 FORCEINLINE
 128 VOID
 129 PushEntryList(
 130   IN OUT PSINGLE_LIST_ENTRY ListHead,
 131   IN OUT PSINGLE_LIST_ENTRY Entry)
 132 {
 133   Entry->Next = ListHead->Next;
 134   ListHead->Next = Entry;
 135 }
 136
 137 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
 138
 139 NTSYSAPI
 140 VOID
 141 NTAPI
 142 RtlAssert(
 143   IN PVOID FailedAssertion,
 144   IN PVOID FileName,
 145   IN ULONG LineNumber,
 146   IN PSTR Message);
 147
 148 /* VOID
 149  * RtlCopyMemory(
 150  *     IN VOID UNALIGNED *Destination,
 151  *     IN CONST VOID UNALIGNED *Source,
 152  *     IN SIZE_T Length)
 153  */
 154 #define RtlCopyMemory(Destination, Source, Length) \
 155     memcpy(Destination, Source, Length)
 156
 157 #define RtlCopyBytes RtlCopyMemory
 158
 159 #if defined(_M_AMD64)
 160 NTSYSAPI
 161 VOID
 162 NTAPI
 163 RtlCopyMemoryNonTemporal(
 164   VOID UNALIGNED *Destination,
 165   CONST VOID UNALIGNED *Source,
 166   SIZE_T Length);
 167 #else
 168 #define RtlCopyMemoryNonTemporal RtlCopyMemory
 169 #endif
 170
 171 /* BOOLEAN
 172  * RtlEqualLuid(
 173  *     IN PLUID Luid1,
 174  *     IN PLUID Luid2)
 175  */
 176 #define RtlEqualLuid(Luid1, Luid2) \
 177     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
 178
 179 /* ULONG
 180  * RtlEqualMemory(
 181  *     IN VOID UNALIGNED *Destination,
 182  *     IN CONST VOID UNALIGNED *Source,
 183  *     IN SIZE_T Length)
 184  */
 185 #define RtlEqualMemory(Destination, Source, Length) \
 186     (!memcmp(Destination, Source, Length))
 187
 188 /* VOID
 189  * RtlFillMemory(
 190  *     IN VOID UNALIGNED *Destination,
 191  *     IN SIZE_T Length,
 192  *     IN UCHAR Fill)
 193  */
 194 #define RtlFillMemory(Destination, Length, Fill) \
 195     memset(Destination, Fill, Length)
 196
 197 #define RtlFillBytes RtlFillMemory
 198
 199 NTSYSAPI
 200 VOID
 201 NTAPI
 202 RtlFreeUnicodeString(
 203   IN OUT PUNICODE_STRING UnicodeString);
 204
 205 NTSYSAPI
 206 NTSTATUS
 207 NTAPI
 208 RtlGUIDFromString(
 209   IN PUNICODE_STRING GuidString,
 210   OUT GUID *Guid);
 211
 212 NTSYSAPI
 213 VOID
 214 NTAPI
 215 RtlInitUnicodeString(
 216   IN OUT PUNICODE_STRING DestinationString,
 217   IN PCWSTR SourceString OPTIONAL);
 218
 219 /* VOID
 220  * RtlMoveMemory(
 221  *    IN VOID UNALIGNED *Destination,
 222  *    IN CONST VOID UNALIGNED *Source,
 223  *    IN SIZE_T Length)
 224  */
 225 #define RtlMoveMemory(Destination, Source, Length) \
 226     memmove(Destination, Source, Length)
 227
 228 NTSYSAPI
 229 NTSTATUS
 230 NTAPI
 231 RtlStringFromGUID(
 232   IN REFGUID Guid,
 233   OUT PUNICODE_STRING GuidString);
 234
 235 /* VOID
 236  * RtlZeroMemory(
 237  *     IN VOID UNALIGNED *Destination,
 238  *     IN SIZE_T Length)
 239  */
 240 #define RtlZeroMemory(Destination, Length) \
 241     memset(Destination, 0, Length)
 242
 243 #define RtlZeroBytes RtlZeroMemory
 244
 245 $endif
 246 #if (NTDDI_VERSION >= NTDDI_WIN2K)
 247
 248 $if (_NTIFS_)
 249 NTSYSAPI
 250 PVOID
 251 NTAPI
 252 RtlAllocateHeap(
 253   IN HANDLE HeapHandle,
 254   IN ULONG Flags OPTIONAL,
 255   IN SIZE_T Size);
 256
 257 NTSYSAPI
 258 BOOLEAN
 259 NTAPI
 260 RtlFreeHeap(
 261   IN PVOID HeapHandle,
 262   IN ULONG Flags OPTIONAL,
 263   IN PVOID BaseAddress);
 264
 265 $endif
 266 $if (_WDMDDK_)
 267 NTSYSAPI
 268 BOOLEAN
 269 NTAPI
 270 RtlAreBitsClear(
 271   IN PRTL_BITMAP BitMapHeader,
 272   IN ULONG StartingIndex,
 273   IN ULONG Length);
 274
 275 NTSYSAPI
 276 BOOLEAN
 277 NTAPI
 278 RtlAreBitsSet(
 279   IN PRTL_BITMAP BitMapHeader,
 280   IN ULONG StartingIndex,
 281   IN ULONG Length);
 282
 283 NTSYSAPI
 284 NTSTATUS
 285 NTAPI
 286 RtlAnsiStringToUnicodeString(
 287   IN OUT PUNICODE_STRING DestinationString,
 288   IN PANSI_STRING SourceString,
 289   IN BOOLEAN AllocateDestinationString);
 290
 291 NTSYSAPI
 292 ULONG
 293 NTAPI
 294 RtlxAnsiStringToUnicodeSize(
 295   IN PCANSI_STRING AnsiString);
 296
 297 #define RtlAnsiStringToUnicodeSize(String) (               \
 298   NLS_MB_CODE_PAGE_TAG ?                                   \
 299   RtlxAnsiStringToUnicodeSize(String) :                    \
 300   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
 301 )
 302
 303 NTSYSAPI
 304 NTSTATUS
 305 NTAPI
 306 RtlAppendUnicodeStringToString(
 307   IN OUT PUNICODE_STRING Destination,
 308   IN PCUNICODE_STRING Source);
 309
 310 NTSYSAPI
 311 NTSTATUS
 312 NTAPI
 313 RtlAppendUnicodeToString(
 314   IN OUT PUNICODE_STRING Destination,
 315   IN PCWSTR Source);
 316
 317 NTSYSAPI
 318 NTSTATUS
 319 NTAPI
 320 RtlCheckRegistryKey(
 321   IN ULONG RelativeTo,
 322   IN PWSTR Path);
 323
 324 NTSYSAPI
 325 VOID
 326 NTAPI
 327 RtlClearAllBits(
 328   IN PRTL_BITMAP BitMapHeader);
 329
 330 NTSYSAPI
 331 VOID
 332 NTAPI
 333 RtlClearBits(
 334   IN PRTL_BITMAP BitMapHeader,
 335   IN ULONG StartingIndex,
 336   IN ULONG NumberToClear);
 337
 338 NTSYSAPI
 339 SIZE_T
 340 NTAPI
 341 RtlCompareMemory(
 342   IN CONST VOID *Source1,
 343   IN CONST VOID *Source2,
 344   IN SIZE_T Length);
 345
 346 NTSYSAPI
 347 LONG
 348 NTAPI
 349 RtlCompareUnicodeString(
 350   IN PCUNICODE_STRING String1,
 351   IN PCUNICODE_STRING String2,
 352   IN BOOLEAN CaseInSensitive);
 353
 354 NTSYSAPI
 355 LONG
 356 NTAPI
 357 RtlCompareUnicodeStrings(
 358   IN PCWCH String1,
 359   IN SIZE_T String1Length,
 360   IN PCWCH String2,
 361   IN SIZE_T String2Length,
 362   IN BOOLEAN CaseInSensitive);
 363
 364 NTSYSAPI
 365 VOID
 366 NTAPI
 367 RtlCopyUnicodeString(
 368   IN OUT PUNICODE_STRING DestinationString,
 369   IN PCUNICODE_STRING SourceString OPTIONAL);
 370
 371 NTSYSAPI
 372 NTSTATUS
 373 NTAPI
 374 RtlCreateRegistryKey(
 375   IN ULONG RelativeTo,
 376   IN PWSTR Path);
 377
 378 NTSYSAPI
 379 NTSTATUS
 380 NTAPI
 381 RtlCreateSecurityDescriptor(
 382   IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 383   IN ULONG Revision);
 384
 385 NTSYSAPI
 386 NTSTATUS
 387 NTAPI
 388 RtlDeleteRegistryValue(
 389   IN ULONG RelativeTo,
 390   IN PCWSTR Path,
 391   IN PCWSTR ValueName);
 392
 393 NTSYSAPI
 394 BOOLEAN
 395 NTAPI
 396 RtlEqualUnicodeString(
 397   IN CONST UNICODE_STRING *String1,
 398   IN CONST UNICODE_STRING *String2,
 399   IN BOOLEAN CaseInSensitive);
 400
 401 #if !defined(_AMD64_) && !defined(_IA64_)
 402 NTSYSAPI
 403 LARGE_INTEGER
 404 NTAPI
 405 RtlExtendedIntegerMultiply(
 406   IN LARGE_INTEGER Multiplicand,
 407   IN LONG Multiplier);
 408
 409 NTSYSAPI
 410 LARGE_INTEGER
 411 NTAPI
 412 RtlExtendedLargeIntegerDivide(
 413   IN LARGE_INTEGER Dividend,
 414   IN ULONG Divisor,
 415   OUT PULONG Remainder OPTIONAL);
 416 #endif
 417
 418 #if defined(_X86_) || defined(_IA64_)
 419 NTSYSAPI
 420 LARGE_INTEGER
 421 NTAPI
 422 RtlExtendedMagicDivide(
 423     IN LARGE_INTEGER Dividend,
 424     IN LARGE_INTEGER MagicDivisor,
 425     IN CCHAR  ShiftCount);
 426 #endif
 427
 428 NTSYSAPI
 429 VOID
 430 NTAPI
 431 RtlFreeAnsiString(
 432   IN PANSI_STRING AnsiString);
 433
 434 NTSYSAPI
 435 ULONG
 436 NTAPI
 437 RtlFindClearBits(
 438   IN PRTL_BITMAP BitMapHeader,
 439   IN ULONG NumberToFind,
 440   IN ULONG HintIndex);
 441
 442 NTSYSAPI
 443 ULONG
 444 NTAPI
 445 RtlFindClearBitsAndSet(
 446   IN PRTL_BITMAP BitMapHeader,
 447   IN ULONG NumberToFind,
 448   IN ULONG HintIndex);
 449
 450 NTSYSAPI
 451 ULONG
 452 NTAPI
 453 RtlFindFirstRunClear(
 454   IN PRTL_BITMAP BitMapHeader,
 455   OUT PULONG StartingIndex);
 456
 457 NTSYSAPI
 458 ULONG
 459 NTAPI
 460 RtlFindClearRuns(
 461   IN PRTL_BITMAP BitMapHeader,
 462   OUT PRTL_BITMAP_RUN RunArray,
 463   IN ULONG SizeOfRunArray,
 464   IN BOOLEAN LocateLongestRuns);
 465
 466 NTSYSAPI
 467 ULONG
 468 NTAPI
 469 RtlFindLastBackwardRunClear(
 470   IN PRTL_BITMAP BitMapHeader,
 471   IN ULONG FromIndex,
 472   OUT PULONG StartingRunIndex);
 473
 474 NTSYSAPI
 475 CCHAR
 476 NTAPI
 477 RtlFindLeastSignificantBit(
 478   IN ULONGLONG Set);
 479
 480 NTSYSAPI
 481 ULONG
 482 NTAPI
 483 RtlFindLongestRunClear(
 484   IN PRTL_BITMAP BitMapHeader,
 485   OUT PULONG StartingIndex);
 486
 487 NTSYSAPI
 488 CCHAR
 489 NTAPI
 490 RtlFindMostSignificantBit(
 491   IN ULONGLONG Set);
 492
 493 NTSYSAPI
 494 ULONG
 495 NTAPI
 496 RtlFindNextForwardRunClear(
 497   IN PRTL_BITMAP BitMapHeader,
 498   IN ULONG FromIndex,
 499   OUT PULONG StartingRunIndex);
 500
 501 NTSYSAPI
 502 ULONG
 503 NTAPI
 504 RtlFindSetBits(
 505   IN PRTL_BITMAP BitMapHeader,
 506   IN ULONG NumberToFind,
 507   IN ULONG HintIndex);
 508
 509 NTSYSAPI
 510 ULONG
 511 NTAPI
 512 RtlFindSetBitsAndClear(
 513   IN PRTL_BITMAP BitMapHeader,
 514   IN ULONG NumberToFind,
 515   IN ULONG HintIndex);
 516
 517 NTSYSAPI
 518 VOID
 519 NTAPI
 520 RtlInitAnsiString(
 521   IN OUT PANSI_STRING DestinationString,
 522   IN PCSZ SourceString);
 523
 524 NTSYSAPI
 525 VOID
 526 NTAPI
 527 RtlInitializeBitMap(
 528   IN PRTL_BITMAP BitMapHeader,
 529   IN PULONG BitMapBuffer,
 530   IN ULONG SizeOfBitMap);
 531
 532 NTSYSAPI
 533 VOID
 534 NTAPI
 535 RtlInitString(
 536   IN OUT PSTRING DestinationString,
 537   IN PCSZ SourceString);
 538
 539 NTSYSAPI
 540 NTSTATUS
 541 NTAPI
 542 RtlIntegerToUnicodeString(
 543   IN ULONG Value,
 544   IN ULONG Base OPTIONAL,
 545   IN OUT PUNICODE_STRING String);
 546
 547 NTSYSAPI
 548 NTSTATUS
 549 NTAPI
 550 RtlInt64ToUnicodeString(
 551   IN ULONGLONG Value,
 552   IN ULONG Base OPTIONAL,
 553   IN OUT PUNICODE_STRING String);
 554
 555 #ifdef _WIN64
 556 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 557     RtlInt64ToUnicodeString(Value, Base, String)
 558 #else
 559 #define RtlIntPtrToUnicodeString(Value, Base, String) \
 560     RtlIntegerToUnicodeString(Value, Base, String)
 561 #endif
 562
 563 /* BOOLEAN
 564  * RtlIsZeroLuid(
 565  *     IN PLUID L1);
 566  */
 567 #define RtlIsZeroLuid(_L1) \
 568     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
 569
 570 NTSYSAPI
 571 ULONG
 572 NTAPI
 573 RtlLengthSecurityDescriptor(
 574   IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 575
 576 NTSYSAPI
 577 ULONG
 578 NTAPI
 579 RtlNumberOfClearBits(
 580   IN PRTL_BITMAP BitMapHeader);
 581
 582 NTSYSAPI
 583 ULONG
 584 NTAPI
 585 RtlNumberOfSetBits(
 586   IN PRTL_BITMAP BitMapHeader);
 587
 588 NTSYSAPI
 589 NTSTATUS
 590 NTAPI
 591 RtlQueryRegistryValues(
 592   IN ULONG RelativeTo,
 593   IN PCWSTR Path,
 594   IN OUT PRTL_QUERY_REGISTRY_TABLE QueryTable,
 595   IN PVOID Context OPTIONAL,
 596   IN PVOID Environment OPTIONAL);
 597
 598 #define SHORT_SIZE  (sizeof(USHORT))
 599 #define SHORT_MASK  (SHORT_SIZE - 1)
 600 #define LONG_SIZE (sizeof(LONG))
 601 #define LONGLONG_SIZE   (sizeof(LONGLONG))
 602 #define LONG_MASK (LONG_SIZE - 1)
 603 #define LONGLONG_MASK   (LONGLONG_SIZE - 1)
 604 #define LOWBYTE_MASK 0x00FF
 605
 606 #define FIRSTBYTE(VALUE)  ((VALUE) & LOWBYTE_MASK)
 607 #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)
 608 #define THIRDBYTE(VALUE)  (((VALUE) >> 16) & LOWBYTE_MASK)
 609 #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)
 610
 611 NTSYSAPI
 612 VOID
 613 NTAPI
 614 RtlSetAllBits(
 615   IN PRTL_BITMAP BitMapHeader);
 616
 617 NTSYSAPI
 618 VOID
 619 NTAPI
 620 RtlSetBits(
 621   IN PRTL_BITMAP BitMapHeader,
 622   IN ULONG StartingIndex,
 623   IN ULONG NumberToSet);
 624
 625 NTSYSAPI
 626 NTSTATUS
 627 NTAPI
 628 RtlSetDaclSecurityDescriptor(
 629   IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor,
 630   IN BOOLEAN DaclPresent,
 631   IN PACL Dacl OPTIONAL,
 632   IN BOOLEAN DaclDefaulted OPTIONAL);
 633
 634 #if defined(_AMD64_)
 635
 636 /* VOID
 637  * RtlStoreUlong(
 638  *     IN PULONG Address,
 639  *     IN ULONG Value);
 640  */
 641 #define RtlStoreUlong(Address,Value) \
 642     *(ULONG UNALIGNED *)(Address) = (Value)
 643
 644 /* VOID
 645  * RtlStoreUlonglong(
 646  *     IN OUT PULONGLONG Address,
 647  *     ULONGLONG Value);
 648  */
 649 #define RtlStoreUlonglong(Address,Value) \
 650     *(ULONGLONG UNALIGNED *)(Address) = (Value)
 651
 652 /* VOID
 653  * RtlStoreUshort(
 654  *     IN PUSHORT Address,
 655  *     IN USHORT Value);
 656  */
 657 #define RtlStoreUshort(Address,Value) \
 658     *(USHORT UNALIGNED *)(Address) = (Value)
 659
 660 /* VOID
 661  * RtlRetrieveUshort(
 662  *     PUSHORT DestinationAddress,
 663  *    PUSHORT SourceAddress);
 664  */
 665 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 666     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
 667
 668 /* VOID
 669  * RtlRetrieveUlong(
 670  *    PULONG DestinationAddress,
 671  *    PULONG SourceAddress);
 672  */
 673 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 674     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
 675
 676 #else
 677
 678 #define RtlStoreUlong(Address,Value)                      \
 679     if ((ULONG_PTR)(Address) & LONG_MASK) { \
 680         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
 681         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
 682         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
 683         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
 684     } \
 685     else { \
 686         *((PULONG)(Address)) = (ULONG) (Value); \
 687     }
 688
 689 #define RtlStoreUlonglong(Address,Value) \
 690     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
 691         RtlStoreUlong((ULONG_PTR)(Address), \
 692                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
 693         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
 694                       (ULONGLONG)(Value) >> 32); \
 695     } else { \
 696         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
 697     }
 698
 699 #define RtlStoreUshort(Address,Value) \
 700     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
 701         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
 702         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
 703     } \
 704     else { \
 705         *((PUSHORT) (Address)) = (USHORT)Value; \
 706     }
 707
 708 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
 709     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 710     { \
 711         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 712         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 713     } \
 714     else \
 715     { \
 716         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
 717     }
 718
 719 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
 720     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
 721     { \
 722         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
 723         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
 724         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
 725         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
 726     } \
 727     else \
 728     { \
 729         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
 730     }
 731
 732 #endif /* defined(_AMD64_) */
 733
 734 #ifdef _WIN64
 735 /* VOID
 736  * RtlStoreUlongPtr(
 737  *     IN OUT PULONG_PTR Address,
 738  *     IN ULONG_PTR Value);
 739  */
 740 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
 741 #else
 742 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
 743 #endif /* _WIN64 */
 744
 745
 746 NTSYSAPI
 747 BOOLEAN
 748 NTAPI
 749 RtlTimeFieldsToTime(
 750   IN PTIME_FIELDS TimeFields,
 751   IN PLARGE_INTEGER Time);
 752
 753 NTSYSAPI
 754 VOID
 755 NTAPI
 756 RtlTimeToTimeFields(
 757   IN PLARGE_INTEGER Time,
 758   IN PTIME_FIELDS TimeFields);
 759
 760 NTSYSAPI
 761 ULONG
 762 FASTCALL
 763 RtlUlongByteSwap(
 764   IN ULONG Source);
 765
 766 NTSYSAPI
 767 ULONGLONG
 768 FASTCALL
 769 RtlUlonglongByteSwap(
 770   IN ULONGLONG Source);
 771
 772 NTSYSAPI
 773 NTSTATUS
 774 NTAPI
 775 RtlUnicodeStringToAnsiString(
 776   IN OUT PANSI_STRING DestinationString,
 777   IN PCUNICODE_STRING SourceString,
 778   IN BOOLEAN AllocateDestinationString);
 779
 780 NTSYSAPI
 781 ULONG
 782 NTAPI
 783 RtlxUnicodeStringToAnsiSize(
 784   IN PCUNICODE_STRING UnicodeString);
 785
 786 #define RtlUnicodeStringToAnsiSize(String) (                  \
 787     NLS_MB_CODE_PAGE_TAG ?                                    \
 788     RtlxUnicodeStringToAnsiSize(String) :                     \
 789     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
 790 )
 791
 792 NTSYSAPI
 793 NTSTATUS
 794 NTAPI
 795 RtlUnicodeStringToInteger(
 796   IN PCUNICODE_STRING String,
 797   IN ULONG Base OPTIONAL,
 798   OUT PULONG Value);
 799
 800 NTSYSAPI
 801 WCHAR
 802 NTAPI
 803 RtlUpcaseUnicodeChar(
 804   IN WCHAR SourceCharacter);
 805
 806 NTSYSAPI
 807 USHORT
 808 FASTCALL
 809 RtlUshortByteSwap(
 810   IN USHORT Source);
 811
 812 NTSYSAPI
 813 BOOLEAN
 814 NTAPI
 815 RtlValidRelativeSecurityDescriptor(
 816   IN PSECURITY_DESCRIPTOR SecurityDescriptorInput,
 817   IN ULONG SecurityDescriptorLength,
 818   IN SECURITY_INFORMATION RequiredInformation);
 819
 820 NTSYSAPI
 821 BOOLEAN
 822 NTAPI
 823 RtlValidSecurityDescriptor(
 824   IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 825
 826 NTSYSAPI
 827 NTSTATUS
 828 NTAPI
 829 RtlWriteRegistryValue(
 830   IN ULONG RelativeTo,
 831   IN PCWSTR Path,
 832   IN PCWSTR ValueName,
 833   IN ULONG ValueType,
 834   IN PVOID ValueData,
 835   IN ULONG ValueLength);
 836
 837 #endif // (NTDDI_VERSION >= NTDDI_WIN2K)
 838
 839 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
 840 NTSYSAPI
 841 VOID
 842 FASTCALL
 843 RtlPrefetchMemoryNonTemporal(
 844   IN PVOID Source,
 845   IN SIZE_T Length);
 846 #endif
 847
 848 #if (NTDDI_VERSION >= NTDDI_WINXP)
 849
 850 NTSYSAPI
 851 VOID
 852 NTAPI
 853 RtlClearBit(
 854   PRTL_BITMAP BitMapHeader,
 855   ULONG BitNumber);
 856
 857 NTSYSAPI
 858 WCHAR
 859 NTAPI
 860 RtlDowncaseUnicodeChar(
 861   IN WCHAR SourceCharacter);
 862
 863 NTSYSAPI
 864 VOID
 865 NTAPI
 866 RtlSetBit(
 867   PRTL_BITMAP BitMapHeader,
 868   ULONG BitNumber);
 869
 870 NTSYSAPI
 871 BOOLEAN
 872 NTAPI
 873 RtlTestBit(
 874   IN PRTL_BITMAP BitMapHeader,
 875   IN ULONG BitNumber);
 876
 877 NTSYSAPI
 878 NTSTATUS
 879 NTAPI
 880 RtlHashUnicodeString(
 881   IN CONST UNICODE_STRING *String,
 882   IN BOOLEAN CaseInSensitive,
 883   IN ULONG HashAlgorithm,
 884   OUT PULONG HashValue);
 885
 886 #endif // (NTDDI_VERSION >= NTDDI_WINXP)
 887
 888 #if (NTDDI_VERSION >= NTDDI_VISTA)
 889
 890 NTSYSAPI
 891 ULONG
 892 NTAPI
 893 RtlNumberOfSetBitsUlongPtr(
 894   IN ULONG_PTR Target);
 895
 896 NTSYSAPI
 897 ULONGLONG
 898 NTAPI
 899 RtlIoDecodeMemIoResource(
 900   IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
 901   OUT PULONGLONG Alignment OPTIONAL,
 902   OUT PULONGLONG MinimumAddress OPTIONAL,
 903   OUT PULONGLONG MaximumAddress OPTIONAL);
 904
 905 NTSYSAPI
 906 NTSTATUS
 907 NTAPI
 908 RtlIoEncodeMemIoResource(
 909   IN struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
 910   IN UCHAR Type,
 911   IN ULONGLONG Length,
 912   IN ULONGLONG Alignment,
 913   IN ULONGLONG MinimumAddress,
 914   IN ULONGLONG MaximumAddress);
 915
 916 NTSYSAPI
 917 ULONGLONG
 918 NTAPI
 919 RtlCmDecodeMemIoResource(
 920   IN struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
 921   OUT PULONGLONG Start OPTIONAL);
 922
 923 NTSYSAPI
 924 NTSTATUS
 925 NTAPI
 926 RtlFindClosestEncodableLength(
 927   IN ULONGLONG SourceLength,
 928   OUT PULONGLONG TargetLength);
 929
 930 NTSYSAPI
 931 NTSTATUS
 932 NTAPI
 933 RtlCmEncodeMemIoResource(
 934   IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
 935   IN UCHAR Type,
 936   IN ULONGLONG Length,
 937   IN ULONGLONG Start);
 938
 939 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
 940
 941 #if (NTDDI_VERSION >= NTDDI_WIN7)
 942
 943 NTSYSAPI
 944 NTSTATUS
 945 NTAPI
 946 RtlUnicodeToUTF8N(
 947   OUT PCHAR UTF8StringDestination,
 948   IN ULONG UTF8StringMaxByteCount,
 949   OUT PULONG UTF8StringActualByteCount,
 950   IN PCWCH UnicodeStringSource,
 951   IN ULONG UnicodeStringByteCount);
 952
 953 NTSYSAPI
 954 NTSTATUS
 955 NTAPI
 956 RtlUTF8ToUnicodeN(
 957   OUT PWSTR UnicodeStringDestination,
 958   IN ULONG UnicodeStringMaxByteCount,
 959   OUT PULONG UnicodeStringActualByteCount,
 960   IN PCCH UTF8StringSource,
 961   IN ULONG UTF8StringByteCount);
 962
 963 NTSYSAPI
 964 ULONG64
 965 NTAPI
 966 RtlGetEnabledExtendedFeatures(
 967   IN ULONG64 FeatureMask);
 968
 969 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
 970
 971 #if !defined(MIDL_PASS)
 972 /* inline funftions */
 973 //DECLSPEC_DEPRECATED_DDK_WINXP
 974 static __inline
 975 LARGE_INTEGER
 976 NTAPI_INLINE
 977 RtlConvertLongToLargeInteger(
 978   IN LONG SignedInteger)
 979 {
 980   LARGE_INTEGER ret;
 981   ret.QuadPart = SignedInteger;
 982   return ret;
 983 }
 984
 985 //DECLSPEC_DEPRECATED_DDK_WINXP
 986 static __inline
 987 LARGE_INTEGER
 988 NTAPI_INLINE
 989 RtlConvertUlongToLargeInteger(
 990   IN ULONG UnsignedInteger)
 991 {
 992   LARGE_INTEGER ret;
 993   ret.QuadPart = UnsignedInteger;
 994   return ret;
 995 }
 996
 997 //DECLSPEC_DEPRECATED_DDK_WINXP
 998 static __inline
 999 LARGE_INTEGER
1000 NTAPI_INLINE
1001 RtlLargeIntegerShiftLeft(
1002   IN LARGE_INTEGER LargeInteger,
1003   IN CCHAR ShiftCount)
1004 {
1005   LARGE_INTEGER Result;
1006
1007   Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
1008   return Result;
1009 }
1010
1011 //DECLSPEC_DEPRECATED_DDK_WINXP
1012 static __inline
1013 LARGE_INTEGER
1014 NTAPI_INLINE
1015 RtlLargeIntegerShiftRight(
1016   IN LARGE_INTEGER LargeInteger,
1017   IN CCHAR ShiftCount)
1018 {
1019   LARGE_INTEGER Result;
1020
1021   Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
1022   return Result;
1023 }
1024
1025 //DECLSPEC_DEPRECATED_DDK
1026 static __inline
1027 ULONG
1028 NTAPI_INLINE
1029 RtlEnlargedUnsignedDivide(
1030   IN ULARGE_INTEGER Dividend,
1031   IN ULONG Divisor,
1032   IN OUT PULONG Remainder)
1033 {
1034   if (Remainder)
1035     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
1036   return (ULONG)(Dividend.QuadPart / Divisor);
1037 }
1038
1039 //DECLSPEC_DEPRECATED_DDK
1040 static __inline
1041 LARGE_INTEGER
1042 NTAPI_INLINE
1043 RtlLargeIntegerNegate(
1044   IN LARGE_INTEGER Subtrahend)
1045 {
1046   LARGE_INTEGER Difference;
1047
1048   Difference.QuadPart = -Subtrahend.QuadPart;
1049   return Difference;
1050 }
1051
1052 //DECLSPEC_DEPRECATED_DDK
1053 static __inline
1054 LARGE_INTEGER
1055 NTAPI_INLINE
1056 RtlLargeIntegerSubtract(
1057   IN LARGE_INTEGER Minuend,
1058   IN LARGE_INTEGER Subtrahend)
1059 {
1060   LARGE_INTEGER Difference;
1061
1062   Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
1063   return Difference;
1064 }
1065
1066 //DECLSPEC_DEPRECATED_DDK
1067 static __inline
1068 LARGE_INTEGER
1069 NTAPI_INLINE
1070 RtlEnlargedUnsignedMultiply(
1071   IN ULONG Multiplicand,
1072   IN ULONG Multiplier)
1073 {
1074   LARGE_INTEGER ret;
1075   ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
1076   return ret;
1077 }
1078
1079 //DECLSPEC_DEPRECATED_DDK
1080 static __inline
1081 LARGE_INTEGER
1082 NTAPI_INLINE
1083 RtlEnlargedIntegerMultiply(
1084   IN LONG Multiplicand,
1085   IN LONG Multiplier)
1086 {
1087   LARGE_INTEGER ret;
1088   ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
1089   return ret;
1090 }
1091
1092 FORCEINLINE
1093 VOID
1094 RtlInitEmptyAnsiString(
1095   OUT PANSI_STRING AnsiString,
1096   IN PCHAR Buffer,
1097   IN USHORT BufferSize)
1098 {
1099   AnsiString->Length = 0;
1100   AnsiString->MaximumLength = BufferSize;
1101   AnsiString->Buffer = Buffer;
1102 }
1103
1104 FORCEINLINE
1105 VOID
1106 RtlInitEmptyUnicodeString(
1107   OUT PUNICODE_STRING UnicodeString,
1108   IN PWSTR Buffer,
1109   IN USHORT BufferSize)
1110 {
1111   UnicodeString->Length = 0;
1112   UnicodeString->MaximumLength = BufferSize;
1113   UnicodeString->Buffer = Buffer;
1114 }
1115
1116 #if defined(_AMD64_) || defined(_IA64_)
1117 static __inline
1118 LARGE_INTEGER
1119 NTAPI_INLINE
1120 RtlExtendedIntegerMultiply(
1121   IN LARGE_INTEGER Multiplicand,
1122   IN LONG Multiplier)
1123 {
1124   LARGE_INTEGER ret;
1125   ret.QuadPart = Multiplicand.QuadPart * Multiplier;
1126   return ret;
1127 }
1128
1129 static __inline
1130 LARGE_INTEGER
1131 NTAPI_INLINE
1132 RtlExtendedLargeIntegerDivide(
1133   IN LARGE_INTEGER Dividend,
1134   IN ULONG Divisor,
1135   OUT PULONG Remainder OPTIONAL)
1136 {
1137   LARGE_INTEGER ret;
1138   ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
1139   if (Remainder)
1140     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
1141   return ret;
1142 }
1143 #endif
1144
1145 #if defined(_AMD64_)
1146
1147 #define MultiplyHigh __mulh
1148 #define UnsignedMultiplyHigh __umulh
1149
1150 //DECLSPEC_DEPRECATED_DDK
1151 static __inline
1152 LARGE_INTEGER
1153 NTAPI_INLINE
1154 RtlExtendedMagicDivide(
1155   IN LARGE_INTEGER Dividend,
1156   IN LARGE_INTEGER MagicDivisor,
1157   IN CCHAR ShiftCount)
1158 {
1159   LARGE_INTEGER ret;
1160   ULONG64 ret64;
1161   BOOLEAN Pos;
1162   Pos = (Dividend.QuadPart >= 0);
1163   ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
1164                                MagicDivisor.QuadPart);
1165   ret64 >>= ShiftCount;
1166   ret.QuadPart = Pos ? ret64 : -ret64;
1167   return ret;
1168 }
1169 #endif
1170
1171 //DECLSPEC_DEPRECATED_DDK
1172 static __inline
1173 LARGE_INTEGER
1174 NTAPI_INLINE
1175 RtlLargeIntegerAdd(
1176   IN LARGE_INTEGER Addend1,
1177   IN LARGE_INTEGER Addend2)
1178 {
1179   LARGE_INTEGER ret;
1180   ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
1181   return ret;
1182 }
1183
1184 /* VOID
1185  * RtlLargeIntegerAnd(
1186  *     IN OUT LARGE_INTEGER Result,
1187  *     IN LARGE_INTEGER Source,
1188  *     IN LARGE_INTEGER Mask);
1189  */
1190 #define RtlLargeIntegerAnd(Result, Source, Mask) \
1191     Result.QuadPart = Source.QuadPart & Mask.QuadPart
1192
1193 //DECLSPEC_DEPRECATED_DDK
1194 static __inline
1195 LARGE_INTEGER
1196 NTAPI_INLINE
1197 RtlLargeIntegerArithmeticShift(
1198   IN LARGE_INTEGER LargeInteger,
1199   IN CCHAR ShiftCount)
1200 {
1201   LARGE_INTEGER ret;
1202   ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
1203   return ret;
1204 }
1205
1206 /* BOOLEAN
1207  * RtlLargeIntegerEqualTo(
1208  *     IN LARGE_INTEGER  Operand1,
1209  *     IN LARGE_INTEGER  Operand2);
1210  */
1211 #define RtlLargeIntegerEqualTo(X,Y) \
1212     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
1213
1214 FORCEINLINE
1215 PVOID
1216 RtlSecureZeroMemory(
1217   OUT PVOID Pointer,
1218   IN SIZE_T Size)
1219 {
1220   volatile char* vptr = (volatile char*)Pointer;
1221 #if defined(_M_AMD64)
1222   __stosb((PUCHAR)vptr, 0, Size);
1223 #else
1224   char * endptr = (char *)vptr + Size;
1225   while (vptr < endptr) {
1226     *vptr = 0; vptr++;
1227   }
1228 #endif
1229    return Pointer;
1230 }
1231
1232 #if defined(_M_AMD64)
1233 FORCEINLINE
1234 BOOLEAN
1235 RtlCheckBit(
1236   IN PRTL_BITMAP BitMapHeader,
1237   IN ULONG BitPosition)
1238 {
1239   return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
1240 }
1241 #else
1242 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
1243 #endif /* defined(_M_AMD64) */
1244
1245 #define RtlLargeIntegerGreaterThan(X,Y) (                              \
1246     (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
1247     ((X).HighPart > (Y).HighPart)                                      \
1248 )
1249
1250 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) (                      \
1251     (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
1252     ((X).HighPart > (Y).HighPart)                                       \
1253 )
1254
1255 #define RtlLargeIntegerNotEqualTo(X,Y) (                          \
1256     (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
1257 )
1258
1259 #define RtlLargeIntegerLessThan(X,Y) (                                 \
1260     (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
1261     ((X).HighPart < (Y).HighPart)                                      \
1262 )
1263
1264 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) (                         \
1265     (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
1266     ((X).HighPart < (Y).HighPart)                                       \
1267 )
1268
1269 #define RtlLargeIntegerGreaterThanZero(X) (       \
1270     (((X).HighPart == 0) && ((X).LowPart > 0)) || \
1271     ((X).HighPart > 0 )                           \
1272 )
1273
1274 #define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
1275
1276 #define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
1277
1278 #define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
1279
1280 #define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
1281
1282 #define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
1283
1284 #endif /* !defined(MIDL_PASS) */
1285
1286 /* Byte Swap Functions */
1287 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
1288     ((defined(_M_AMD64) || defined(_M_IA64)) \
1289         && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
1290
1291 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
1292 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
1293 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
1294
1295 #endif
1296
1297 #if DBG
1298
1299 #define ASSERT(exp) \
1300   (VOID)((!(exp)) ? \
1301     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
1302
1303 #define ASSERTMSG(msg, exp) \
1304   (VOID)((!(exp)) ? \
1305     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, msg ), FALSE : TRUE)
1306
1307 #define RTL_SOFT_ASSERT(exp) \
1308   (VOID)((!(exp)) ? \
1309     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
1310
1311 #define RTL_SOFT_ASSERTMSG(msg, exp) \
1312   (VOID)((!(exp)) ? \
1313     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n   Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
1314
1315 #define RTL_VERIFY(exp) ASSERT(exp)
1316 #define RTL_VERIFYMSG(msg, exp) ASSERTMSG(msg, exp)
1317
1318 #define RTL_SOFT_VERIFY(exp) RTL_SOFT_ASSERT(exp)
1319 #define RTL_SOFT_VERIFYMSG(msg, exp) RTL_SOFT_ASSERTMSG(msg, exp)
1320
1321 #if defined(_MSC_VER)
1322
1323 #define NT_ASSERT(exp) \
1324    ((!(exp)) ? \
1325       (__annotation(L"Debug", L"AssertFail", L#exp), \
1326        DbgRaiseAssertionFailure(), FALSE) : TRUE)
1327
1328 #define NT_ASSERTMSG(msg, exp) \
1329    ((!(exp)) ? \
1330       (__annotation(L"Debug", L"AssertFail", L##msg), \
1331       DbgRaiseAssertionFailure(), FALSE) : TRUE)
1332
1333 #define NT_ASSERTMSGW(msg, exp) \
1334     ((!(exp)) ? \
1335         (__annotation(L"Debug", L"AssertFail", msg), \
1336          DbgRaiseAssertionFailure(), FALSE) : TRUE)
1337
1338 #define NT_VERIFY     NT_ASSERT
1339 #define NT_VERIFYMSG  NT_ASSERTMSG
1340 #define NT_VERIFYMSGW NT_ASSERTMSGW
1341
1342 #else
1343
1344 /* GCC doesn't support __annotation (nor PDB) */
1345 #define NT_ASSERT(exp) \
1346    (VOID)((!(exp)) ? (DbgRaiseAssertionFailure(), FALSE) : TRUE)
1347
1348 #define NT_ASSERTMSG NT_ASSERT
1349 #define NT_ASSERTMSGW NT_ASSERT
1350
1351 #endif
1352
1353 #else /* !DBG */
1354
1355 #define ASSERT(exp) ((VOID) 0)
1356 #define ASSERTMSG(msg, exp) ((VOID) 0)
1357
1358 #define RTL_SOFT_ASSERT(exp) ((VOID) 0)
1359 #define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
1360
1361 #define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
1362 #define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1363
1364 #define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
1365 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
1366
1367 #define NT_ASSERT(exp)          ((VOID)0)
1368 #define NT_ASSERTMSG(msg, exp)  ((VOID)0)
1369 #define NT_ASSERTMSGW(msg, exp) ((VOID)0)
1370
1371 #define NT_VERIFY(_exp)           ((_exp) ? TRUE : FALSE)
1372 #define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
1373 #define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
1374
1375 #endif /* DBG */
1376
1377 #define InitializeListHead32(ListHead) (\
1378     (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
1379
1380 #if !defined(_WINBASE_)
1381
1382 #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
1383
1384 NTKERNELAPI
1385 VOID
1386 InitializeSListHead(
1387   OUT PSLIST_HEADER SListHead);
1388
1389 #else
1390
1391 VOID
1392 FORCEINLINE
1393 InitializeSListHead(
1394   OUT PSLIST_HEADER SListHead)
1395 {
1396 #if defined(_IA64_)
1397   ULONG64 FeatureBits;
1398 #endif
1399
1400 #if defined(_WIN64)
1401   if (((ULONG_PTR)SListHead & 0xf) != 0) {
1402     RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
1403   }
1404 #endif
1405   RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
1406 #if defined(_IA64_)
1407   FeatureBits = __getReg(CV_IA64_CPUID4);
1408   if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
1409     SListHead->Header16.HeaderType = 1;
1410     SListHead->Header16.Init = 1;
1411   }
1412 #endif
1413 }
1414
1415 #endif
1416
1417 #if defined(_WIN64)
1418
1419 #define InterlockedPopEntrySList(Head) \
1420     ExpInterlockedPopEntrySList(Head)
1421
1422 #define InterlockedPushEntrySList(Head, Entry) \
1423     ExpInterlockedPushEntrySList(Head, Entry)
1424
1425 #define InterlockedFlushSList(Head) \
1426     ExpInterlockedFlushSList(Head)
1427
1428 #define QueryDepthSList(Head) \
1429     ExQueryDepthSList(Head)
1430
1431 #else /* !defined(_WIN64) */
1432
1433 NTKERNELAPI
1434 PSLIST_ENTRY
1435 FASTCALL
1436 InterlockedPopEntrySList(
1437   IN PSLIST_HEADER ListHead);
1438
1439 NTKERNELAPI
1440 PSLIST_ENTRY
1441 FASTCALL
1442 InterlockedPushEntrySList(
1443   IN PSLIST_HEADER ListHead,
1444   IN PSLIST_ENTRY ListEntry);
1445
1446 #define InterlockedFlushSList(ListHead) \
1447     ExInterlockedFlushSList(ListHead)
1448
1449 #define QueryDepthSList(Head) \
1450     ExQueryDepthSList(Head)
1451
1452 #endif /* !defined(_WIN64) */
1453
1454 #endif /* !defined(_WINBASE_) */
1455
1456 #define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)
1457 #define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)
1458 #define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk)       \
1459     ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))
1460 #define RTL_CONTEXT_OFFSET(Context, Chunk)              \
1461     RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)
1462 #define RTL_CONTEXT_LENGTH(Context, Chunk)              \
1463     RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)
1464 #define RTL_CONTEXT_CHUNK(Context, Chunk)               \
1465     RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1),    \
1466                          (PCONTEXT_EX)(Context + 1),    \
1467                          Chunk)
1468
1469 BOOLEAN
1470 RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
1471   IN ULONG Version);
1472
1473 BOOLEAN
1474 RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
1475   IN ULONG Version);
1476
1477 #ifndef RtlIsNtDdiVersionAvailable
1478 #define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
1479 #endif
1480
1481 #ifndef RtlIsServicePackVersionInstalled
1482 #define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
1483 #endif
1484
1485 #define RtlInterlockedSetBits(Flags, Flag) \
1486     InterlockedOr((PLONG)(Flags), Flag)
1487
1488 #define RtlInterlockedAndBits(Flags, Flag) \
1489     InterlockedAnd((PLONG)(Flags), Flag)
1490
1491 #define RtlInterlockedClearBits(Flags, Flag) \
1492     RtlInterlockedAndBits(Flags, ~(Flag))
1493
1494 #define RtlInterlockedXorBits(Flags, Flag) \
1495     InterlockedXor(Flags, Flag)
1496
1497 #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
1498     (VOID) RtlInterlockedSetBits(Flags, Flag)
1499
1500 #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
1501     (VOID) RtlInterlockedAndBits(Flags, Flag)
1502
1503 #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
1504     RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
1505
1506