memory/selector.c

   1 /*
   2  * Selector manipulation functions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #include <string.h>
   8 #include "windows.h"
   9 #include "ldt.h"
  10 #include "miscemu.h"
  11 #include "selectors.h"
  12 #include "stackframe.h"
  13 #include "debug.h"
  14
  15
  16 /***********************************************************************
  17  *           AllocSelectorArray   (KERNEL.206)
  18  */
  19 WORD WINAPI AllocSelectorArray( WORD count )
  20 {
  21     WORD i, sel, size = 0;
  22     ldt_entry entry;
  23
  24     if (!count) return 0;
  25     for (i = FIRST_LDT_ENTRY_TO_ALLOC; i < LDT_SIZE; i++)
  26     {
  27         if (!IS_LDT_ENTRY_FREE(i)) size = 0;
  28         else if (++size >= count) break;
  29     }
  30     if (i == LDT_SIZE) return 0;
  31     sel = i - size + 1;
  32
  33     entry.base           = 0;
  34     entry.type           = SEGMENT_DATA;
  35     entry.seg_32bit      = FALSE;
  36     entry.read_only      = FALSE;
  37     entry.limit_in_pages = FALSE;
  38     entry.limit          = 1;  /* avoid 0 base and limit */
  39
  40     for (i = 0; i < count; i++)
  41     {
  42         /* Mark selector as allocated */
  43         ldt_flags_copy[sel + i] |= LDT_FLAGS_ALLOCATED;
  44         LDT_SetEntry( sel + i, &entry );
  45     }
  46     return ENTRY_TO_SELECTOR( sel );
  47 }
  48
  49
  50 /***********************************************************************
  51  *           AllocSelector   (KERNEL.175)
  52  */
  53 WORD WINAPI AllocSelector( WORD sel )
  54 {
  55     WORD newsel, count, i;
  56
  57     count = sel ? ((GET_SEL_LIMIT(sel) >> 16) + 1) : 1;
  58     newsel = AllocSelectorArray( count );
  59     TRACE(selector, "(%04x): returning %04x\n",
  60                       sel, newsel );
  61     if (!newsel) return 0;
  62     if (!sel) return newsel;  /* nothing to copy */
  63     for (i = 0; i < count; i++)
  64     {
  65         ldt_entry entry;
  66         LDT_GetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
  67         LDT_SetEntry( SELECTOR_TO_ENTRY(newsel) + i, &entry );
  68     }
  69     return newsel;
  70 }
  71
  72
  73 /***********************************************************************
  74  *           FreeSelector   (KERNEL.176)
  75  */
  76 WORD WINAPI FreeSelector( WORD sel )
  77 {
  78     if (IS_SELECTOR_FREE(sel)) return sel;  /* error */
  79     SELECTOR_FreeBlock( sel, 1 );
  80     return 0;
  81 }
  82
  83
  84 /***********************************************************************
  85  *           SELECTOR_SetEntries
  86  *
  87  * Set the LDT entries for an array of selectors.
  88  */
  89 static void SELECTOR_SetEntries( WORD sel, const void *base, DWORD size,
  90                                  enum seg_type type, BOOL32 is32bit,
  91                                  BOOL32 readonly )
  92 {
  93     ldt_entry entry;
  94     WORD i, count;
  95
  96     /* The limit for the first selector is the whole */
  97     /* block. The next selectors get a 64k limit.    */
  98     entry.base           = (unsigned long)base;
  99     entry.type           = type;
 100     entry.seg_32bit      = is32bit;
 101     entry.read_only      = readonly;
 102     entry.limit_in_pages = (size > 0x100000);
 103     if (entry.limit_in_pages) entry.limit = ((size + 0xfff) >> 12) - 1;
 104     else entry.limit = size - 1;
 105     /* Make sure base and limit are not 0 together if the size is not 0 */
 106     if (!base && !entry.limit && size) entry.limit = 1;
 107     count = (size + 0xffff) / 0x10000;
 108     for (i = 0; i < count; i++)
 109     {
 110         LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
 111         entry.base += 0x10000;
 112         /* Apparently the next selectors should *not* get a 64k limit. */
 113         /* Can't remember where I read they should... --AJ */
 114         entry.limit -= entry.limit_in_pages ? 0x10 : 0x10000;
 115     }
 116 }
 117
 118
 119 /***********************************************************************
 120  *           SELECTOR_AllocBlock
 121  *
 122  * Allocate selectors for a block of linear memory.
 123  */
 124 WORD SELECTOR_AllocBlock( const void *base, DWORD size, enum seg_type type,
 125                           BOOL32 is32bit, BOOL32 readonly )
 126 {
 127     WORD sel, count;
 128
 129     if (!size) return 0;
 130     count = (size + 0xffff) / 0x10000;
 131     sel = AllocSelectorArray( count );
 132     if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
 133     return sel;
 134 }
 135
 136
 137 /***********************************************************************
 138  *           SELECTOR_MoveBlock
 139  *
 140  * Move a block of selectors in linear memory.
 141  */
 142 void SELECTOR_MoveBlock( WORD sel, const void *new_base )
 143 {
 144     WORD i, count = (GET_SEL_LIMIT(sel) >> 16) + 1;
 145
 146     for (i = 0; i < count; i++)
 147     {
 148         ldt_entry entry;
 149         LDT_GetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
 150         entry.base = (unsigned long)new_base;
 151         LDT_SetEntry( SELECTOR_TO_ENTRY(sel) + i, &entry );
 152     }
 153 }
 154
 155
 156 /***********************************************************************
 157  *           SELECTOR_FreeBlock
 158  *
 159  * Free a block of selectors.
 160  */
 161 void SELECTOR_FreeBlock( WORD sel, WORD count )
 162 {
 163     WORD i, nextsel;
 164     ldt_entry entry;
 165     STACK16FRAME *frame;
 166
 167     TRACE(selector, "(%04x,%d)\n", sel, count );
 168     sel &= ~(__AHINCR - 1);  /* clear bottom bits of selector */
 169     nextsel = sel + (count << __AHSHIFT);
 170
 171 #ifdef __i386__
 172     {
 173         /* Check if we are freeing current %fs or %gs selector */
 174
 175         WORD fs, gs;
 176         GET_FS(fs);
 177         if ((fs >= sel) && (fs < nextsel))
 178         {
 179             WARN(selector, "Freeing %%fs selector (%04x), not good.\n", fs );
 180             SET_FS( 0 );
 181         }
 182         fs = THREAD_Current()->saved_fs;
 183         if ((fs >= sel) && (fs < nextsel)) THREAD_Current()->saved_fs = 0;
 184         GET_GS(gs);
 185         if ((gs >= sel) && (gs < nextsel)) SET_GS( 0 );
 186     }
 187 #endif  /* __i386__ */
 188
 189     memset( &entry, 0, sizeof(entry) );  /* clear the LDT entries */
 190     for (i = SELECTOR_TO_ENTRY(sel); count; i++, count--)
 191     {
 192         LDT_SetEntry( i, &entry );
 193         ldt_flags_copy[i] &= ~LDT_FLAGS_ALLOCATED;
 194     }
 195
 196     /* Clear the saved 16-bit selector */
 197     frame = CURRENT_STACK16;
 198     while (frame && frame->frame32)
 199     {
 200         if ((frame->ds >= sel) && (frame->ds < nextsel)) frame->ds = 0;
 201         if ((frame->es >= sel) && (frame->es < nextsel)) frame->es = 0;
 202         frame = PTR_SEG_TO_LIN( frame->frame32->frame16 );
 203     }
 204 }
 205
 206
 207 /***********************************************************************
 208  *           SELECTOR_ReallocBlock
 209  *
 210  * Change the size of a block of selectors.
 211  */
 212 WORD SELECTOR_ReallocBlock( WORD sel, const void *base, DWORD size,
 213                            enum seg_type type, BOOL32 is32bit, BOOL32 readonly)
 214 {
 215     WORD i, oldcount, newcount;
 216
 217     if (!size) size = 1;
 218     oldcount = (GET_SEL_LIMIT(sel) >> 16) + 1;
 219     newcount = (size + 0xffff) >> 16;
 220
 221     if (oldcount < newcount)  /* We need to add selectors */
 222     {
 223           /* Check if the next selectors are free */
 224         if (SELECTOR_TO_ENTRY(sel) + newcount > LDT_SIZE) i = oldcount;
 225         else
 226             for (i = oldcount; i < newcount; i++)
 227                 if (!IS_LDT_ENTRY_FREE(SELECTOR_TO_ENTRY(sel)+i)) break;
 228
 229         if (i < newcount)  /* they are not free */
 230         {
 231             SELECTOR_FreeBlock( sel, oldcount );
 232             sel = AllocSelectorArray( newcount );
 233         }
 234         else  /* mark the selectors as allocated */
 235         {
 236             for (i = oldcount; i < newcount; i++)
 237                 ldt_flags_copy[SELECTOR_TO_ENTRY(sel)+i] |=LDT_FLAGS_ALLOCATED;
 238         }
 239     }
 240     else if (oldcount > newcount) /* We need to remove selectors */
 241     {
 242         SELECTOR_FreeBlock( ENTRY_TO_SELECTOR(SELECTOR_TO_ENTRY(sel)+newcount),
 243                             oldcount - newcount );
 244     }
 245     if (sel) SELECTOR_SetEntries( sel, base, size, type, is32bit, readonly );
 246     return sel;
 247 }
 248
 249
 250 /***********************************************************************
 251  *           PrestoChangoSelector   (KERNEL.177)
 252  */
 253 WORD WINAPI PrestoChangoSelector( WORD selSrc, WORD selDst )
 254 {
 255     ldt_entry entry;
 256     LDT_GetEntry( SELECTOR_TO_ENTRY( selSrc ), &entry );
 257     entry.type ^= SEGMENT_CODE;  /* toggle the executable bit */
 258     LDT_SetEntry( SELECTOR_TO_ENTRY( selDst ), &entry );
 259     return selDst;
 260 }
 261
 262
 263 /***********************************************************************
 264  *           AllocCStoDSAlias   (KERNEL.170)
 265  */
 266 WORD WINAPI AllocCStoDSAlias( WORD sel )
 267 {
 268     WORD newsel;
 269     ldt_entry entry;
 270
 271     newsel = AllocSelectorArray( 1 );
 272     TRACE(selector, "(%04x): returning %04x\n",
 273                       sel, newsel );
 274     if (!newsel) return 0;
 275     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 276     entry.type = SEGMENT_DATA;
 277     LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
 278     return newsel;
 279 }
 280
 281
 282 /***********************************************************************
 283  *           AllocDStoCSAlias   (KERNEL.171)
 284  */
 285 WORD WINAPI AllocDStoCSAlias( WORD sel )
 286 {
 287     WORD newsel;
 288     ldt_entry entry;
 289
 290     newsel = AllocSelectorArray( 1 );
 291     TRACE(selector, "(%04x): returning %04x\n",
 292                       sel, newsel );
 293     if (!newsel) return 0;
 294     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 295     entry.type = SEGMENT_CODE;
 296     LDT_SetEntry( SELECTOR_TO_ENTRY(newsel), &entry );
 297     return newsel;
 298 }
 299
 300
 301 /***********************************************************************
 302  *           LongPtrAdd   (KERNEL.180)
 303  */
 304 void WINAPI LongPtrAdd( DWORD ptr, DWORD add )
 305 {
 306     ldt_entry entry;
 307     LDT_GetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
 308     entry.base += add;
 309     LDT_SetEntry( SELECTOR_TO_ENTRY(SELECTOROF(ptr)), &entry );
 310 }
 311
 312
 313 /***********************************************************************
 314  *           GetSelectorBase   (KERNEL.186)
 315  */
 316 DWORD WINAPI GetSelectorBase( WORD sel )
 317 {
 318     DWORD base = GET_SEL_BASE(sel);
 319
 320     /* if base points into DOSMEM, assume we have to
 321      * return pointer into physical lower 1MB */
 322
 323     return DOSMEM_MapLinearToDos( (LPVOID)base );
 324 }
 325
 326
 327 /***********************************************************************
 328  *           SetSelectorBase   (KERNEL.187)
 329  */
 330 WORD WINAPI SetSelectorBase( WORD sel, DWORD base )
 331 {
 332     ldt_entry entry;
 333
 334     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 335
 336     entry.base = (DWORD)DOSMEM_MapDosToLinear(base);
 337
 338     LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 339     return sel;
 340 }
 341
 342
 343 /***********************************************************************
 344  *           GetSelectorLimit   (KERNEL.188)
 345  */
 346 DWORD WINAPI GetSelectorLimit( WORD sel )
 347 {
 348     return GET_SEL_LIMIT(sel);
 349 }
 350
 351
 352 /***********************************************************************
 353  *           SetSelectorLimit   (KERNEL.189)
 354  */
 355 WORD WINAPI SetSelectorLimit( WORD sel, DWORD limit )
 356 {
 357     ldt_entry entry;
 358     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 359     entry.limit_in_pages = (limit >= 0x100000);
 360     if (entry.limit_in_pages) entry.limit = limit >> 12;
 361     else entry.limit = limit;
 362     LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 363     return sel;
 364 }
 365
 366
 367 /***********************************************************************
 368  *           SelectorAccessRights   (KERNEL.196)
 369  */
 370 WORD WINAPI SelectorAccessRights( WORD sel, WORD op, WORD val )
 371 {
 372     ldt_entry entry;
 373     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 374     if (op == 0)  /* get */
 375     {
 376         return 0x01 | /* accessed */
 377                0x10 | /* not system */
 378                0x60 | /* DPL 3 */
 379                0x80 | /* present */
 380                ((entry.read_only == 0) << 1) |
 381                (entry.type << 2) |
 382                (entry.seg_32bit << 14) |
 383                (entry.limit_in_pages << 15);
 384     }
 385     else  /* set */
 386     {
 387         entry.read_only = ((val & 2) == 0);
 388         entry.type = (val >> 2) & 3;
 389         entry.seg_32bit = val & 0x4000;
 390         entry.limit_in_pages = val & 0x8000;
 391         LDT_SetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 392         return 0;
 393     }
 394 }
 395
 396
 397 /***********************************************************************
 398  *           IsBadCodePtr16   (KERNEL.336)
 399  */
 400 BOOL16 WINAPI IsBadCodePtr16( SEGPTR lpfn )
 401 {
 402     WORD sel;
 403     ldt_entry entry;
 404
 405     sel = SELECTOROF(lpfn);
 406     if (!sel) return TRUE;
 407     if (IS_SELECTOR_FREE(sel)) return TRUE;
 408     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 409     if (entry.type != SEGMENT_CODE) return TRUE;
 410     if (OFFSETOF(lpfn) > entry.limit) return TRUE;
 411     return FALSE;
 412 }
 413
 414
 415 /***********************************************************************
 416  *           IsBadStringPtr16   (KERNEL.337)
 417  */
 418 BOOL16 WINAPI IsBadStringPtr16( SEGPTR ptr, UINT16 size )
 419 {
 420     WORD sel;
 421     ldt_entry entry;
 422
 423     sel = SELECTOROF(ptr);
 424     if (!sel) return TRUE;
 425     if (IS_SELECTOR_FREE(sel)) return TRUE;
 426     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 427     if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
 428     if (strlen(PTR_SEG_TO_LIN(ptr)) < size) size = strlen(PTR_SEG_TO_LIN(ptr));
 429     if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
 430     return FALSE;
 431 }
 432
 433
 434 /***********************************************************************
 435  *           IsBadHugeReadPtr16   (KERNEL.346)
 436  */
 437 BOOL16 WINAPI IsBadHugeReadPtr16( SEGPTR ptr, DWORD size )
 438 {
 439     WORD sel;
 440     ldt_entry entry;
 441
 442     sel = SELECTOROF(ptr);
 443     if (!sel) return TRUE;
 444     if (IS_SELECTOR_FREE(sel)) return TRUE;
 445     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 446     if ((entry.type == SEGMENT_CODE) && entry.read_only) return TRUE;
 447     if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
 448     return FALSE;
 449 }
 450
 451
 452 /***********************************************************************
 453  *           IsBadHugeWritePtr16   (KERNEL.347)
 454  */
 455 BOOL16 WINAPI IsBadHugeWritePtr16( SEGPTR ptr, DWORD size )
 456 {
 457     WORD sel;
 458     ldt_entry entry;
 459
 460     sel = SELECTOROF(ptr);
 461     if (!sel) return TRUE;
 462     if (IS_SELECTOR_FREE(sel)) return TRUE;
 463     LDT_GetEntry( SELECTOR_TO_ENTRY(sel), &entry );
 464     if ((entry.type == SEGMENT_CODE) || entry.read_only) return TRUE;
 465     if (OFFSETOF(ptr) + size - 1 > entry.limit) return TRUE;
 466     return FALSE;
 467 }
 468
 469 /***********************************************************************
 470  *           IsBadReadPtr16   (KERNEL.334)
 471  */
 472 BOOL16 WINAPI IsBadReadPtr16( SEGPTR ptr, UINT16 size )
 473 {
 474     return IsBadHugeReadPtr16( ptr, size );
 475 }
 476
 477
 478 /***********************************************************************
 479  *           IsBadWritePtr16   (KERNEL.335)
 480  */
 481 BOOL16 WINAPI IsBadWritePtr16( SEGPTR ptr, UINT16 size )
 482 {
 483     return IsBadHugeWritePtr16( ptr, size );
 484 }
 485
 486
 487 /***********************************************************************
 488  *           MemoryRead   (TOOLHELP.78)
 489  */
 490 DWORD WINAPI MemoryRead( WORD sel, DWORD offset, void *buffer, DWORD count )
 491 {
 492     if (IS_SELECTOR_FREE(sel)) return 0;
 493     if (offset > GET_SEL_LIMIT(sel)) return 0;
 494     if (offset + count > GET_SEL_LIMIT(sel) + 1)
 495         count = GET_SEL_LIMIT(sel) + 1 - offset;
 496     memcpy( buffer, ((char *)GET_SEL_BASE(sel)) + offset, count );
 497     return count;
 498 }
 499
 500
 501 /***********************************************************************
 502  *           MemoryWrite   (TOOLHELP.79)
 503  */
 504 DWORD WINAPI MemoryWrite( WORD sel, DWORD offset, void *buffer, DWORD count )
 505 {
 506     if (IS_SELECTOR_FREE(sel)) return 0;
 507     if (offset > GET_SEL_LIMIT(sel)) return 0;
 508     if (offset + count > GET_SEL_LIMIT(sel) + 1)
 509         count = GET_SEL_LIMIT(sel) + 1 - offset;
 510     memcpy( ((char *)GET_SEL_BASE(sel)) + offset, buffer, count );
 511     return count;
 512 }
 513
 514 /************************************* Win95 pointer mapping functions *
 515  *
 516  */
 517
 518 /***********************************************************************
 519  *           MapSL   (KERNEL32.523)
 520  *
 521  * Maps fixed segmented pointer to linear.
 522  */
 523 LPVOID WINAPI MapSL( SEGPTR sptr )
 524 {
 525     return (LPVOID)PTR_SEG_TO_LIN(sptr);
 526 }
 527
 528 /***********************************************************************
 529  *           MapSLFix   (KERNEL32.524)
 530  *
 531  * FIXME: MapSLFix and UnMapSLFixArray should probably prevent
 532  * unexpected linear address change when GlobalCompact() shuffles
 533  * moveable blocks.
 534  */
 535
 536 LPVOID WINAPI MapSLFix( SEGPTR sptr )
 537 {
 538     return (LPVOID)PTR_SEG_TO_LIN(sptr);
 539 }
 540
 541 /***********************************************************************
 542  *           UnMapSLFixArray   (KERNEL32.701)
 543  */
 544
 545 void WINAPI UnMapSLFixArray( SEGPTR sptr[], INT32 length )
 546 {
 547 }
 548
 549 /***********************************************************************
 550  *           MapLS   (KERNEL32.522)
 551  *
 552  * Maps linear pointer to segmented.
 553  */
 554 SEGPTR WINAPI MapLS( LPVOID ptr )
 555 {
 556     if (!HIWORD(ptr))
 557         return (SEGPTR)ptr;
 558     else
 559     {
 560         WORD sel = SELECTOR_AllocBlock( ptr, 0x10000, SEGMENT_DATA, FALSE, FALSE );
 561         return PTR_SEG_OFF_TO_SEGPTR( sel, 0 );
 562     }
 563 }
 564
 565
 566 /***********************************************************************
 567  *           UnMapLS   (KERNEL32.700)
 568  *
 569  * Free mapped selector.
 570  */
 571 void WINAPI UnMapLS( SEGPTR sptr )
 572 {
 573     if (SELECTOROF(sptr))
 574         SELECTOR_FreeBlock( SELECTOROF(sptr), 1 );
 575 }
 576
 577 /***********************************************************************
 578  *           GetThreadSelectorEntry   (KERNEL32)
 579  * FIXME: add #ifdef i386 for non x86
 580  */
 581 BOOL32 WINAPI GetThreadSelectorEntry( HANDLE32 hthread, DWORD sel,
 582                                       LPLDT_ENTRY ldtent)
 583 {
 584     ldt_entry   ldtentry;
 585
 586     LDT_GetEntry(SELECTOR_TO_ENTRY(sel),&ldtentry);
 587     ldtent->BaseLow = ldtentry.base & 0x0000ffff;
 588     ldtent->HighWord.Bits.BaseMid = (ldtentry.base & 0x00ff0000) >> 16;
 589     ldtent->HighWord.Bits.BaseHi = (ldtentry.base & 0xff000000) >> 24;
 590     ldtent->LimitLow = ldtentry.limit & 0x0000ffff;
 591     ldtent->HighWord.Bits.LimitHi = (ldtentry.limit & 0x00ff0000) >> 16;
 592     ldtent->HighWord.Bits.Dpl = 3;
 593     ldtent->HighWord.Bits.Sys = 0;
 594     ldtent->HighWord.Bits.Pres = 1;
 595     ldtent->HighWord.Bits.Type = 0x10|(ldtentry.type << 2);
 596     if (ldtentry.read_only)
 597         ldtent->HighWord.Bits.Type|=0x2;
 598     ldtent->HighWord.Bits.Granularity = ldtentry.limit_in_pages;
 599     ldtent->HighWord.Bits.Default_Big = ldtentry.seg_32bit;
 600     return TRUE;
 601 }
 602
 603
 604 /**********************************************************************
 605  *              SMapLS*         (KERNEL32)
 606  * These functions map linear pointers at [EBP+xxx] to segmented pointers
 607  * and return them.
 608  * Win95 uses some kind of alias structs, which it stores in [EBP+x] to
 609  * unravel them at SUnMapLS. We just store the segmented pointer there.
 610  */
 611 static void
 612 x_SMapLS_IP_EBP_x(CONTEXT *context,int argoff) {
 613     DWORD       val,ptr;
 614
 615     val =*(DWORD*)(EBP_reg(context)+argoff);
 616     if (val<0x10000) {
 617         ptr=val;
 618         *(DWORD*)(EBP_reg(context)+argoff) = 0;
 619     } else {
 620         ptr = MapLS((LPVOID)val);
 621         *(DWORD*)(EBP_reg(context)+argoff) = ptr;
 622     }
 623     EAX_reg(context) = ptr;
 624 }
 625
 626 REGS_ENTRYPOINT(SMapLS_IP_EBP_8)  {x_SMapLS_IP_EBP_x(context,8);}
 627 REGS_ENTRYPOINT(SMapLS_IP_EBP_12) {x_SMapLS_IP_EBP_x(context,12);}
 628 REGS_ENTRYPOINT(SMapLS_IP_EBP_16) {x_SMapLS_IP_EBP_x(context,16);}
 629 REGS_ENTRYPOINT(SMapLS_IP_EBP_20) {x_SMapLS_IP_EBP_x(context,20);}
 630 REGS_ENTRYPOINT(SMapLS_IP_EBP_24) {x_SMapLS_IP_EBP_x(context,24);}
 631 REGS_ENTRYPOINT(SMapLS_IP_EBP_28) {x_SMapLS_IP_EBP_x(context,28);}
 632 REGS_ENTRYPOINT(SMapLS_IP_EBP_32) {x_SMapLS_IP_EBP_x(context,32);}
 633 REGS_ENTRYPOINT(SMapLS_IP_EBP_36) {x_SMapLS_IP_EBP_x(context,36);}
 634 REGS_ENTRYPOINT(SMapLS_IP_EBP_40) {x_SMapLS_IP_EBP_x(context,40);}
 635
 636 REGS_ENTRYPOINT(SMapLS)
 637 {
 638     if (EAX_reg(context)>=0x10000) {
 639         EAX_reg(context) = MapLS((LPVOID)EAX_reg(context));
 640         EDX_reg(context) = EAX_reg(context);
 641     } else {
 642         EDX_reg(context) = 0;
 643     }
 644 }
 645
 646 REGS_ENTRYPOINT(SUnMapLS)
 647 {
 648     if (EAX_reg(context)>=0x10000)
 649         UnMapLS((SEGPTR)EAX_reg(context));
 650 }
 651
 652 static void
 653 x_SUnMapLS_IP_EBP_x(CONTEXT *context,int argoff) {
 654         if (*(DWORD*)(EBP_reg(context)+argoff))
 655                 UnMapLS(*(DWORD*)(EBP_reg(context)+argoff));
 656         *(DWORD*)(EBP_reg(context)+argoff)=0;
 657 }
 658 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_8)  { x_SUnMapLS_IP_EBP_x(context,12); }
 659 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_12) { x_SUnMapLS_IP_EBP_x(context,12); }
 660 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_16) { x_SUnMapLS_IP_EBP_x(context,16); }
 661 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_20) { x_SUnMapLS_IP_EBP_x(context,20); }
 662 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_24) { x_SUnMapLS_IP_EBP_x(context,24); }
 663 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_28) { x_SUnMapLS_IP_EBP_x(context,28); }
 664 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_32) { x_SUnMapLS_IP_EBP_x(context,32); }
 665 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_36) { x_SUnMapLS_IP_EBP_x(context,36); }
 666 REGS_ENTRYPOINT(SUnMapLS_IP_EBP_40) { x_SUnMapLS_IP_EBP_x(context,40); }
 667
 668 /**********************************************************************
 669  *              AllocMappedBuffer       (KERNEL32.38)
 670  *
 671  * This is a undocumented KERNEL32 function that
 672  * SMapLS's a GlobalAlloc'ed buffer.
 673  *
 674  * Input:   EDI register: size of buffer to allocate
 675  * Output:  EDI register: pointer to buffer
 676  *
 677  * Note: The buffer is preceeded by 8 bytes:
 678  *        ...
 679  *       edi+0   buffer
 680  *       edi-4   SEGPTR to buffer
 681  *       edi-8   some magic Win95 needs for SUnMapLS
 682  *               (we use it for the memory handle)
 683  *
 684  *       The SEGPTR is used by the caller!
 685  */
 686
 687 REGS_ENTRYPOINT(AllocMappedBuffer)
 688 {
 689     HGLOBAL32 handle = GlobalAlloc32(0, EDI_reg(context) + 8);
 690     DWORD *buffer = (DWORD *)GlobalLock32(handle);
 691     SEGPTR ptr = 0;
 692
 693     if (buffer)
 694         if (!(ptr = MapLS(buffer + 2)))
 695         {
 696             GlobalUnlock32(handle);
 697             GlobalFree32(handle);
 698         }
 699
 700     if (!ptr)
 701         EAX_reg(context) = EDI_reg(context) = 0;
 702     else
 703     {
 704         buffer[0] = handle;
 705         buffer[1] = ptr;
 706
 707         EAX_reg(context) = (DWORD) ptr;
 708         EDI_reg(context) = (DWORD)(buffer + 2);
 709     }
 710 }
 711
 712 /**********************************************************************
 713  *              FreeMappedBuffer        (KERNEL32.39)
 714  *
 715  * Free a buffer allocated by AllocMappedBuffer
 716  *
 717  * Input: EDI register: pointer to buffer
 718  */
 719
 720 REGS_ENTRYPOINT(FreeMappedBuffer)
 721 {
 722     if (EDI_reg(context))
 723     {
 724         DWORD *buffer = (DWORD *)EDI_reg(context) - 2;
 725
 726         UnMapLS(buffer[1]);
 727
 728         GlobalUnlock32(buffer[0]);
 729         GlobalFree32(buffer[0]);
 730     }
 731 }
 732
 733 /**********************************************************************
 734  *           WOWGetVDMPointer   (KERNEL32.55)
 735  * Get linear from segmented pointer. (MSDN lib)
 736  */
 737 LPVOID WINAPI WOWGetVDMPointer(DWORD vp,DWORD nrofbytes,BOOL32 protected)
 738 {
 739     /* FIXME: add size check too */
 740     if (protected)
 741         return PTR_SEG_TO_LIN(vp);
 742     else
 743         return DOSMEM_MapRealToLinear(vp);
 744 }
 745
 746 /**********************************************************************
 747  *           GetVDMPointer32W   (KERNEL.516)
 748  */
 749 LPVOID WINAPI GetVDMPointer32W(DWORD vp,DWORD mode)
 750 {
 751     return WOWGetVDMPointer(vp,0,mode);
 752 }
 753
 754 /**********************************************************************
 755  *           WOWGetVDMPointerFix (KERNEL32.55)
 756  * Dito, but fix heapsegment (MSDN lib)
 757  */
 758 LPVOID WINAPI WOWGetVDMPointerFix(DWORD vp,DWORD nrofbytes,BOOL32 protected)
 759 {
 760     /* FIXME: fix heapsegment */
 761     return WOWGetVDMPointer(vp,nrofbytes,protected);
 762 }
 763
 764 /**********************************************************************
 765  *           WOWGetVDMPointerUnFix (KERNEL32.56)
 766  */
 767 void WINAPI WOWGetVDMPointerUnfix(DWORD vp)
 768 {
 769     /* FIXME: unfix heapsegment */
 770 }
 771
 772 /***********************************************************************
 773  *           UTSelectorOffsetToLinear       (WIN32S16.48)
 774  *
 775  * rough guesswork, but seems to work (I had no "reasonable" docu)
 776  */
 777 LPVOID WINAPI UTSelectorOffsetToLinear(SEGPTR sptr)
 778 {
 779         return PTR_SEG_TO_LIN(sptr);
 780 }
 781
 782 /***********************************************************************
 783  *           UTLinearToSelectorOffset       (WIN32S16.49)
 784  *
 785  * FIXME: I don't know if that's the right way to do linear -> segmented
 786  */
 787 SEGPTR WINAPI UTLinearToSelectorOffset(LPVOID lptr)
 788 {
 789     return (SEGPTR)lptr;
 790 }