dlls/krnl386.exe16/selector.c

   1 /*
   2  * Selector manipulation functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <string.h>
  25
  26 #include "wine/winbase16.h"
  27 #include "wine/server.h"
  28 #include "wine/debug.h"
  29 #include "kernel16_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(selector);
  32
  33 #define LDT_SIZE 8192
  34
  35 /* get the number of selectors needed to cover up to the selector limit */
  36 static inline WORD get_sel_count( WORD sel )
  37 {
  38     return (wine_ldt_copy.limit[sel >> __AHSHIFT] >> 16) + 1;
  39 }
  40
  41
  42 /***********************************************************************
  43  *           AllocSelectorArray   (KERNEL.206)
  44  */
  45 WORD WINAPI AllocSelectorArray16( WORD count )
  46 {
  47     WORD i, sel = wine_ldt_alloc_entries( count );
  48
  49     if (sel)
  50     {
  51         LDT_ENTRY entry;
  52         wine_ldt_set_base( &entry, 0 );
  53         wine_ldt_set_limit( &entry, 1 ); /* avoid 0 base and limit */
  54         wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_DATA );
  55         for (i = 0; i < count; i++)
  56         {
  57             if (wine_ldt_set_entry( sel + (i << __AHSHIFT), &entry ) < 0)
  58             {
  59                 wine_ldt_free_entries( sel, count );
  60                 return 0;
  61             }
  62         }
  63     }
  64     return sel;
  65 }
  66
  67
  68 /***********************************************************************
  69  *           AllocSelector   (KERNEL.175)
  70  */
  71 WORD WINAPI AllocSelector16( WORD sel )
  72 {
  73     WORD newsel, count, i;
  74
  75     count = sel ? get_sel_count(sel) : 1;
  76     newsel = wine_ldt_alloc_entries( count );
  77     TRACE("(%04x): returning %04x\n", sel, newsel );
  78     if (!newsel) return 0;
  79     if (!sel) return newsel;  /* nothing to copy */
  80     for (i = 0; i < count; i++)
  81     {
  82         LDT_ENTRY entry;
  83         wine_ldt_get_entry( sel + (i << __AHSHIFT), &entry );
  84         wine_ldt_set_entry( newsel + (i << __AHSHIFT), &entry );
  85     }
  86     return newsel;
  87 }
  88
  89
  90 /***********************************************************************
  91  *           FreeSelector   (KERNEL.176)
  92  */
  93 WORD WINAPI FreeSelector16( WORD sel )
  94 {
  95     LDT_ENTRY entry;
  96
  97     wine_ldt_get_entry( sel, &entry );
  98     if (wine_ldt_is_empty( &entry )) return sel;  /* error */
  99     /* Check if we are freeing current %fs selector */
 100     if (!((wine_get_fs() ^ sel) & ~3))
 101         WARN("Freeing %%fs selector (%04x), not good.\n", wine_get_fs() );
 102     wine_ldt_free_entries( sel, 1 );
 103     return 0;
 104 }
 105
 106
 107 /***********************************************************************
 108  *           SELECTOR_SetEntries
 109  *
 110  * Set the LDT entries for an array of selectors.
 111  */
 112 static BOOL SELECTOR_SetEntries( WORD sel, const void *base, DWORD size, unsigned char flags )
 113 {
 114     LDT_ENTRY entry;
 115     WORD i, count;
 116
 117     wine_ldt_set_base( &entry, base );
 118     wine_ldt_set_limit( &entry, size - 1 );
 119     wine_ldt_set_flags( &entry, flags );
 120     count = (size + 0xffff) / 0x10000;
 121     for (i = 0; i < count; i++)
 122     {
 123         if (wine_ldt_set_entry( sel + (i << __AHSHIFT), &entry ) < 0) return FALSE;
 124         wine_ldt_set_base( &entry, (char*)wine_ldt_get_base(&entry) + 0x10000);
 125         /* yep, Windows sets limit like that, not 64K sel units */
 126         wine_ldt_set_limit( &entry, wine_ldt_get_limit(&entry) - 0x10000 );
 127     }
 128     return TRUE;
 129 }
 130
 131
 132 /***********************************************************************
 133  *           SELECTOR_AllocBlock
 134  *
 135  * Allocate selectors for a block of linear memory.
 136  */
 137 WORD SELECTOR_AllocBlock( const void *base, DWORD size, unsigned char flags )
 138 {
 139     WORD sel, count;
 140
 141     if (!size) return 0;
 142     count = (size + 0xffff) / 0x10000;
 143     if ((sel = wine_ldt_alloc_entries( count )))
 144     {
 145         if (SELECTOR_SetEntries( sel, base, size, flags )) return sel;
 146         wine_ldt_free_entries( sel, count );
 147         sel = 0;
 148     }
 149     return sel;
 150 }
 151
 152
 153 /***********************************************************************
 154  *           SELECTOR_FreeBlock
 155  *
 156  * Free a block of selectors.
 157  */
 158 void SELECTOR_FreeBlock( WORD sel )
 159 {
 160     WORD i, count = get_sel_count( sel );
 161
 162     TRACE("(%04x,%d)\n", sel, count );
 163     for (i = 0; i < count; i++) FreeSelector16( sel + (i << __AHSHIFT) );
 164 }
 165
 166
 167 /***********************************************************************
 168  *           SELECTOR_ReallocBlock
 169  *
 170  * Change the size of a block of selectors.
 171  */
 172 WORD SELECTOR_ReallocBlock( WORD sel, const void *base, DWORD size )
 173 {
 174     LDT_ENTRY entry;
 175     int oldcount, newcount;
 176
 177     if (!size) size = 1;
 178     wine_ldt_get_entry( sel, &entry );
 179     oldcount = (wine_ldt_get_limit(&entry) >> 16) + 1;
 180     newcount = (size + 0xffff) >> 16;
 181
 182     sel = wine_ldt_realloc_entries( sel, oldcount, newcount );
 183     if (sel) SELECTOR_SetEntries( sel, base, size, wine_ldt_get_flags(&entry) );
 184     return sel;
 185 }
 186
 187
 188 /***********************************************************************
 189  *           PrestoChangoSelector   (KERNEL.177)
 190  */
 191 WORD WINAPI PrestoChangoSelector16( WORD selSrc, WORD selDst )
 192 {
 193     LDT_ENTRY entry;
 194     wine_ldt_get_entry( selSrc, &entry );
 195     /* toggle the executable bit */
 196     entry.HighWord.Bits.Type ^= (WINE_LDT_FLAGS_CODE ^ WINE_LDT_FLAGS_DATA);
 197     wine_ldt_set_entry( selDst, &entry );
 198     return selDst;
 199 }
 200
 201
 202 /***********************************************************************
 203  *           AllocCStoDSAlias   (KERNEL.170)
 204  *           AllocAlias         (KERNEL.172)
 205  */
 206 WORD WINAPI AllocCStoDSAlias16( WORD sel )
 207 {
 208     WORD newsel;
 209     LDT_ENTRY entry;
 210
 211     newsel = wine_ldt_alloc_entries( 1 );
 212     TRACE("(%04x): returning %04x\n",
 213                       sel, newsel );
 214     if (!newsel) return 0;
 215     wine_ldt_get_entry( sel, &entry );
 216     entry.HighWord.Bits.Type = WINE_LDT_FLAGS_DATA;
 217     if (wine_ldt_set_entry( newsel, &entry ) >= 0) return newsel;
 218     wine_ldt_free_entries( newsel, 1 );
 219     return 0;
 220 }
 221
 222
 223 /***********************************************************************
 224  *           AllocDStoCSAlias   (KERNEL.171)
 225  */
 226 WORD WINAPI AllocDStoCSAlias16( WORD sel )
 227 {
 228     WORD newsel;
 229     LDT_ENTRY entry;
 230
 231     newsel = wine_ldt_alloc_entries( 1 );
 232     TRACE("(%04x): returning %04x\n",
 233                       sel, newsel );
 234     if (!newsel) return 0;
 235     wine_ldt_get_entry( sel, &entry );
 236     entry.HighWord.Bits.Type = WINE_LDT_FLAGS_CODE;
 237     if (wine_ldt_set_entry( newsel, &entry ) >= 0) return newsel;
 238     wine_ldt_free_entries( newsel, 1 );
 239     return 0;
 240 }
 241
 242
 243 /***********************************************************************
 244  *           LongPtrAdd   (KERNEL.180)
 245  */
 246 void WINAPI LongPtrAdd16( DWORD ptr, DWORD add )
 247 {
 248     LDT_ENTRY entry;
 249     wine_ldt_get_entry( SELECTOROF(ptr), &entry );
 250     wine_ldt_set_base( &entry, (char *)wine_ldt_get_base(&entry) + add );
 251     wine_ldt_set_entry( SELECTOROF(ptr), &entry );
 252 }
 253
 254
 255 /***********************************************************************
 256  *             GetSelectorBase   (KERNEL.186)
 257  */
 258 DWORD WINAPI GetSelectorBase( WORD sel )
 259 {
 260     void *base = wine_ldt_copy.base[sel >> __AHSHIFT];
 261
 262     /* if base points into DOSMEM, assume we have to
 263      * return pointer into physical lower 1MB */
 264
 265     return DOSMEM_MapLinearToDos( base );
 266 }
 267
 268
 269 /***********************************************************************
 270  *             SetSelectorBase   (KERNEL.187)
 271  */
 272 WORD WINAPI SetSelectorBase( WORD sel, DWORD base )
 273 {
 274     LDT_ENTRY entry;
 275     wine_ldt_get_entry( sel, &entry );
 276     wine_ldt_set_base( &entry, DOSMEM_MapDosToLinear(base) );
 277     if (wine_ldt_set_entry( sel, &entry ) < 0) sel = 0;
 278     return sel;
 279 }
 280
 281
 282 /***********************************************************************
 283  *           GetSelectorLimit   (KERNEL.188)
 284  */
 285 DWORD WINAPI GetSelectorLimit16( WORD sel )
 286 {
 287     return wine_ldt_copy.limit[sel >> __AHSHIFT];
 288 }
 289
 290
 291 /***********************************************************************
 292  *           SetSelectorLimit   (KERNEL.189)
 293  */
 294 WORD WINAPI SetSelectorLimit16( WORD sel, DWORD limit )
 295 {
 296     LDT_ENTRY entry;
 297     wine_ldt_get_entry( sel, &entry );
 298     wine_ldt_set_limit( &entry, limit );
 299     if (wine_ldt_set_entry( sel, &entry ) < 0) sel = 0;
 300     return sel;
 301 }
 302
 303
 304 /***********************************************************************
 305  *           SelectorAccessRights   (KERNEL.196)
 306  */
 307 WORD WINAPI SelectorAccessRights16( WORD sel, WORD op, WORD val )
 308 {
 309     LDT_ENTRY entry;
 310     wine_ldt_get_entry( sel, &entry );
 311
 312     if (op == 0)  /* get */
 313     {
 314         return entry.HighWord.Bytes.Flags1 | ((entry.HighWord.Bytes.Flags2 & 0xf0) << 8);
 315     }
 316     else  /* set */
 317     {
 318         entry.HighWord.Bytes.Flags1 = LOBYTE(val) | 0xf0;
 319         entry.HighWord.Bytes.Flags2 = (entry.HighWord.Bytes.Flags2 & 0x0f) | (HIBYTE(val) & 0xf0);
 320         wine_ldt_set_entry( sel, &entry );
 321         return 0;
 322     }
 323 }
 324
 325
 326 /***********************************************************************
 327  *           IsBadCodePtr   (KERNEL.336)
 328  */
 329 BOOL16 WINAPI IsBadCodePtr16( SEGPTR lpfn )
 330 {
 331     WORD sel;
 332     LDT_ENTRY entry;
 333
 334     sel = SELECTOROF(lpfn);
 335     if (!sel) return TRUE;
 336     wine_ldt_get_entry( sel, &entry );
 337     if (wine_ldt_is_empty( &entry )) return TRUE;
 338     /* check for code segment, ignoring conforming, read-only and accessed bits */
 339     if ((entry.HighWord.Bits.Type ^ WINE_LDT_FLAGS_CODE) & 0x18) return TRUE;
 340     if (OFFSETOF(lpfn) > wine_ldt_get_limit(&entry)) return TRUE;
 341     return FALSE;
 342 }
 343
 344
 345 /***********************************************************************
 346  *           IsBadStringPtr   (KERNEL.337)
 347  */
 348 BOOL16 WINAPI IsBadStringPtr16( SEGPTR ptr, UINT16 size )
 349 {
 350     WORD sel;
 351     LDT_ENTRY entry;
 352
 353     sel = SELECTOROF(ptr);
 354     if (!sel) return TRUE;
 355     wine_ldt_get_entry( sel, &entry );
 356     if (wine_ldt_is_empty( &entry )) return TRUE;
 357     /* check for data or readable code segment */
 358     if (!(entry.HighWord.Bits.Type & 0x10)) return TRUE;  /* system descriptor */
 359     if ((entry.HighWord.Bits.Type & 0x0a) == 0x08) return TRUE;  /* non-readable code segment */
 360     if (strlen(MapSL(ptr)) < size) size = strlen(MapSL(ptr)) + 1;
 361     if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit(&entry))) return TRUE;
 362     return FALSE;
 363 }
 364
 365
 366 /***********************************************************************
 367  *           IsBadHugeReadPtr   (KERNEL.346)
 368  */
 369 BOOL16 WINAPI IsBadHugeReadPtr16( SEGPTR ptr, DWORD size )
 370 {
 371     WORD sel;
 372     LDT_ENTRY entry;
 373
 374     sel = SELECTOROF(ptr);
 375     if (!sel) return TRUE;
 376     wine_ldt_get_entry( sel, &entry );
 377     if (wine_ldt_is_empty( &entry )) return TRUE;
 378     /* check for data or readable code segment */
 379     if (!(entry.HighWord.Bits.Type & 0x10)) return TRUE;  /* system descriptor */
 380     if ((entry.HighWord.Bits.Type & 0x0a) == 0x08) return TRUE;  /* non-readable code segment */
 381     if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit( &entry ))) return TRUE;
 382     return FALSE;
 383 }
 384
 385
 386 /***********************************************************************
 387  *           IsBadHugeWritePtr   (KERNEL.347)
 388  */
 389 BOOL16 WINAPI IsBadHugeWritePtr16( SEGPTR ptr, DWORD size )
 390 {
 391     WORD sel;
 392     LDT_ENTRY entry;
 393
 394     sel = SELECTOROF(ptr);
 395     if (!sel) return TRUE;
 396     wine_ldt_get_entry( sel, &entry );
 397     if (wine_ldt_is_empty( &entry )) return TRUE;
 398     /* check for writable data segment, ignoring expand-down and accessed flags */
 399     if ((entry.HighWord.Bits.Type ^ WINE_LDT_FLAGS_DATA) & ~5) return TRUE;
 400     if (size && (OFFSETOF(ptr) + size - 1 > wine_ldt_get_limit( &entry ))) return TRUE;
 401     return FALSE;
 402 }
 403
 404 /***********************************************************************
 405  *           IsBadReadPtr   (KERNEL.334)
 406  */
 407 BOOL16 WINAPI IsBadReadPtr16( SEGPTR ptr, UINT16 size )
 408 {
 409     return IsBadHugeReadPtr16( ptr, size );
 410 }
 411
 412
 413 /***********************************************************************
 414  *           IsBadWritePtr   (KERNEL.335)
 415  */
 416 BOOL16 WINAPI IsBadWritePtr16( SEGPTR ptr, UINT16 size )
 417 {
 418     return IsBadHugeWritePtr16( ptr, size );
 419 }
 420
 421
 422 /***********************************************************************
 423  *           IsBadFlatReadWritePtr   (KERNEL.627)
 424  */
 425 BOOL16 WINAPI IsBadFlatReadWritePtr16( SEGPTR ptr, DWORD size, BOOL16 bWrite )
 426 {
 427     return bWrite? IsBadHugeWritePtr16( ptr, size )
 428                  : IsBadHugeReadPtr16( ptr, size );
 429 }
 430
 431
 432 /************************************* Win95 pointer mapping functions *
 433  *
 434  */
 435
 436 struct mapls_entry
 437 {
 438     struct mapls_entry *next;
 439     void               *addr;   /* linear address */
 440     int                 count;  /* ref count */
 441     WORD                sel;    /* selector */
 442 };
 443
 444 static struct mapls_entry *first_entry;
 445
 446
 447 /***********************************************************************
 448  *           MapLS   (KERNEL32.@)
 449  *           MapLS   (KERNEL.358)
 450  *
 451  * Maps linear pointer to segmented.
 452  */
 453 SEGPTR WINAPI MapLS( LPCVOID ptr )
 454 {
 455     struct mapls_entry *entry, *free = NULL;
 456     const void *base;
 457     SEGPTR ret = 0;
 458
 459     if (!HIWORD(ptr)) return (SEGPTR)LOWORD(ptr);
 460
 461     base = (const char *)ptr - ((ULONG_PTR)ptr & 0x7fff);
 462     HeapLock( GetProcessHeap() );
 463     for (entry = first_entry; entry; entry = entry->next)
 464     {
 465         if (entry->addr == base) break;
 466         if (!entry->count) free = entry;
 467     }
 468
 469     if (!entry)
 470     {
 471         if (!free)  /* no free entry found, create a new one */
 472         {
 473             if (!(free = HeapAlloc( GetProcessHeap(), 0, sizeof(*free) ))) goto done;
 474             if (!(free->sel = SELECTOR_AllocBlock( base, 0x10000, WINE_LDT_FLAGS_DATA )))
 475             {
 476                 HeapFree( GetProcessHeap(), 0, free );
 477                 goto done;
 478             }
 479             free->count = 0;
 480             free->next = first_entry;
 481             first_entry = free;
 482         }
 483         SetSelectorBase( free->sel, (DWORD)base );
 484         free->addr = (void*)base;
 485         entry = free;
 486     }
 487     entry->count++;
 488     ret = MAKESEGPTR( entry->sel, (const char *)ptr - (char *)entry->addr );
 489  done:
 490     HeapUnlock( GetProcessHeap() );
 491     return ret;
 492 }
 493
 494 /***********************************************************************
 495  *           UnMapLS   (KERNEL32.@)
 496  *           UnMapLS   (KERNEL.359)
 497  *
 498  * Free mapped selector.
 499  */
 500 void WINAPI UnMapLS( SEGPTR sptr )
 501 {
 502     struct mapls_entry *entry;
 503     WORD sel = SELECTOROF(sptr);
 504
 505     if (sel)
 506     {
 507         HeapLock( GetProcessHeap() );
 508         for (entry = first_entry; entry; entry = entry->next) if (entry->sel == sel) break;
 509         if (entry && entry->count > 0) entry->count--;
 510         HeapUnlock( GetProcessHeap() );
 511     }
 512 }
 513
 514 /***********************************************************************
 515  *           MapSL   (KERNEL32.@)
 516  *           MapSL   (KERNEL.357)
 517  *
 518  * Maps fixed segmented pointer to linear.
 519  */
 520 LPVOID WINAPI MapSL( SEGPTR sptr )
 521 {
 522     return (char *)wine_ldt_copy.base[SELECTOROF(sptr) >> __AHSHIFT] + OFFSETOF(sptr);
 523 }
 524
 525 /***********************************************************************
 526  *           MapSLFix   (KERNEL32.@)
 527  *
 528  * FIXME: MapSLFix and UnMapSLFixArray should probably prevent
 529  * unexpected linear address change when GlobalCompact() shuffles
 530  * moveable blocks.
 531  */
 532
 533 LPVOID WINAPI MapSLFix( SEGPTR sptr )
 534 {
 535     return MapSL(sptr);
 536 }
 537
 538
 539 /***********************************************************************
 540  *           UnMapSLFixArray   (KERNEL32.@)
 541  *
 542  * Must not change EAX, hence defined as asm function.
 543  */
 544 __ASM_STDCALL_FUNC( UnMapSLFixArray, 8, "ret $8" )
 545
 546 /***********************************************************************
 547  *              SMapLS (KERNEL32.@)
 548  */
 549 __ASM_STDCALL_FUNC( SMapLS, 0,
 550                    "xor %edx,%edx\n\t"
 551                    "testl $0xffff0000,%eax\n\t"
 552                    "jz 1f\n\t"
 553                    "pushl %eax\n\t"
 554                    "call " __ASM_NAME("MapLS") __ASM_STDCALL(4) "\n\t"
 555                    "movl %eax,%edx\n"
 556                    "1:\tret" )
 557
 558 /***********************************************************************
 559  *              SUnMapLS (KERNEL32.@)
 560  */
 561 __ASM_STDCALL_FUNC( SUnMapLS, 0,
 562                    "pushl %eax\n\t"  /* preserve eax */
 563                    "pushl %eax\n\t"
 564                    "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 565                    "popl %eax\n\t"
 566                    "ret" )
 567
 568 /***********************************************************************
 569  *              SMapLS_IP_EBP_8 (KERNEL32.@)
 570  *
 571  * These functions map linear pointers at [EBP+xxx] to segmented pointers
 572  * and return them.
 573  * Win95 uses some kind of alias structs, which it stores in [EBP+x] to
 574  * unravel them at SUnMapLS. We just store the segmented pointer there.
 575  */
 576 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_8, 0,
 577                     "movl 8(%ebp),%eax\n\t"
 578                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 579                     "movl %edx,8(%ebp)\n\t"
 580                     "ret" )
 581
 582 /***********************************************************************
 583  *              SMapLS_IP_EBP_12 (KERNEL32.@)
 584  */
 585 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_12, 0,
 586                     "movl 12(%ebp),%eax\n\t"
 587                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 588                     "movl %edx,12(%ebp)\n\t"
 589                     "ret" )
 590
 591 /***********************************************************************
 592  *              SMapLS_IP_EBP_16 (KERNEL32.@)
 593  */
 594 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_16, 0,
 595                     "movl 16(%ebp),%eax\n\t"
 596                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 597                     "movl %edx,16(%ebp)\n\t"
 598                     "ret" )
 599
 600 /***********************************************************************
 601  *              SMapLS_IP_EBP_20 (KERNEL32.@)
 602  */
 603 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_20, 0,
 604                     "movl 20(%ebp),%eax\n\t"
 605                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 606                     "movl %edx,20(%ebp)\n\t"
 607                     "ret" )
 608
 609 /***********************************************************************
 610  *              SMapLS_IP_EBP_24 (KERNEL32.@)
 611  */
 612 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_24, 0,
 613                     "movl 24(%ebp),%eax\n\t"
 614                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 615                     "movl %edx,24(%ebp)\n\t"
 616                     "ret" )
 617
 618 /***********************************************************************
 619  *              SMapLS_IP_EBP_28 (KERNEL32.@)
 620  */
 621 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_28, 0,
 622                     "movl 28(%ebp),%eax\n\t"
 623                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 624                     "movl %edx,28(%ebp)\n\t"
 625                     "ret" )
 626
 627 /***********************************************************************
 628  *              SMapLS_IP_EBP_32 (KERNEL32.@)
 629  */
 630 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_32, 0,
 631                     "movl 32(%ebp),%eax\n\t"
 632                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 633                     "movl %edx,32(%ebp)\n\t"
 634                     "ret" )
 635
 636 /***********************************************************************
 637  *              SMapLS_IP_EBP_36 (KERNEL32.@)
 638  */
 639 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_36, 0,
 640                     "movl 36(%ebp),%eax\n\t"
 641                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 642                     "movl %edx,36(%ebp)\n\t"
 643                     "ret" )
 644
 645 /***********************************************************************
 646  *              SMapLS_IP_EBP_40 (KERNEL32.@)
 647  */
 648 __ASM_STDCALL_FUNC( SMapLS_IP_EBP_40, 0,
 649                     "movl 40(%ebp),%eax\n\t"
 650                     "call " __ASM_NAME("SMapLS") __ASM_STDCALL(4) "\n\t"
 651                     "movl %edx,40(%ebp)\n\t"
 652                     "ret" )
 653
 654 /***********************************************************************
 655  *              SUnMapLS_IP_EBP_8 (KERNEL32.@)
 656  */
 657 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_8, 0,
 658                     "pushl %eax\n\t"  /* preserve eax */
 659                     "pushl 8(%ebp)\n\t"
 660                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 661                     "movl $0,8(%ebp)\n\t"
 662                     "popl %eax\n\t"
 663                     "ret" )
 664
 665 /***********************************************************************
 666  *              SUnMapLS_IP_EBP_12 (KERNEL32.@)
 667  */
 668 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_12, 0,
 669                     "pushl %eax\n\t"  /* preserve eax */
 670                     "pushl 12(%ebp)\n\t"
 671                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 672                     "movl $0,12(%ebp)\n\t"
 673                     "popl %eax\n\t"
 674                     "ret" )
 675
 676 /***********************************************************************
 677  *              SUnMapLS_IP_EBP_16 (KERNEL32.@)
 678  */
 679 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_16, 0,
 680                     "pushl %eax\n\t"  /* preserve eax */
 681                     "pushl 16(%ebp)\n\t"
 682                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 683                     "movl $0,16(%ebp)\n\t"
 684                     "popl %eax\n\t"
 685                     "ret" )
 686
 687 /***********************************************************************
 688  *              SUnMapLS_IP_EBP_20 (KERNEL32.@)
 689  */
 690 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_20, 0,
 691                     "pushl %eax\n\t"  /* preserve eax */
 692                     "pushl 20(%ebp)\n\t"
 693                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 694                     "movl $0,20(%ebp)\n\t"
 695                     "popl %eax\n\t"
 696                     "ret" )
 697
 698 /***********************************************************************
 699  *              SUnMapLS_IP_EBP_24 (KERNEL32.@)
 700  */
 701 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_24, 0,
 702                     "pushl %eax\n\t"  /* preserve eax */
 703                     "pushl 24(%ebp)\n\t"
 704                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 705                     "movl $0,24(%ebp)\n\t"
 706                     "popl %eax\n\t"
 707                     "ret" )
 708
 709 /***********************************************************************
 710  *              SUnMapLS_IP_EBP_28 (KERNEL32.@)
 711  */
 712 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_28, 0,
 713                     "pushl %eax\n\t"  /* preserve eax */
 714                     "pushl 28(%ebp)\n\t"
 715                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 716                     "movl $0,28(%ebp)\n\t"
 717                     "popl %eax\n\t"
 718                     "ret" )
 719
 720 /***********************************************************************
 721  *              SUnMapLS_IP_EBP_32 (KERNEL32.@)
 722  */
 723 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_32, 0,
 724                     "pushl %eax\n\t"  /* preserve eax */
 725                     "pushl 32(%ebp)\n\t"
 726                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 727                     "movl $0,32(%ebp)\n\t"
 728                     "popl %eax\n\t"
 729                     "ret" )
 730
 731 /***********************************************************************
 732  *              SUnMapLS_IP_EBP_36 (KERNEL32.@)
 733  */
 734 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_36, 0,
 735                     "pushl %eax\n\t"  /* preserve eax */
 736                     "pushl 36(%ebp)\n\t"
 737                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 738                     "movl $0,36(%ebp)\n\t"
 739                     "popl %eax\n\t"
 740                     "ret" )
 741
 742 /***********************************************************************
 743  *              SUnMapLS_IP_EBP_40 (KERNEL32.@)
 744  */
 745 __ASM_STDCALL_FUNC( SUnMapLS_IP_EBP_40, 0,
 746                     "pushl %eax\n\t"  /* preserve eax */
 747                     "pushl 40(%ebp)\n\t"
 748                     "call " __ASM_NAME("UnMapLS") __ASM_STDCALL(4) "\n\t"
 749                     "movl $0,40(%ebp)\n\t"
 750                     "popl %eax\n\t"
 751                     "ret" )