2 * Selector manipulation functions
4 * Copyright 1995 Alexandre Julliard
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
27 #include "wine/winbase16.h"
29 #include "selectors.h"
30 #include "stackframe.h"
31 #include "wine/server.h"
32 #include "wine/debug.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(selector
);
39 /* get the number of selectors needed to cover up to the selector limit */
40 inline static WORD
get_sel_count( WORD sel
)
42 return (wine_ldt_copy
.limit
[sel
>> __AHSHIFT
] >> 16) + 1;
45 static const LDT_ENTRY null_entry
; /* all-zeros, used to clear LDT entries */
47 /***********************************************************************
50 * Allocate a selector array without setting the LDT entries
52 static WORD
SELECTOR_AllocArray( WORD count
)
54 WORD i
, sel
, size
= 0;
57 for (i
= FIRST_LDT_ENTRY_TO_ALLOC
; i
< LDT_SIZE
; i
++)
59 if (wine_ldt_copy
.flags
[i
] & WINE_LDT_FLAGS_ALLOCATED
) size
= 0;
60 else if (++size
>= count
) break;
62 if (i
== LDT_SIZE
) return 0;
65 /* mark selectors as allocated */
66 for (i
= 0; i
< count
; i
++) wine_ldt_copy
.flags
[sel
+ i
] |= WINE_LDT_FLAGS_ALLOCATED
;
68 return (sel
<< __AHSHIFT
) | 7;
72 /***********************************************************************
73 * AllocSelectorArray (KERNEL.206)
75 WORD WINAPI
AllocSelectorArray16( WORD count
)
77 WORD i
, sel
= SELECTOR_AllocArray( count
);
82 wine_ldt_set_base( &entry
, 0 );
83 wine_ldt_set_limit( &entry
, 1 ); /* avoid 0 base and limit */
84 wine_ldt_set_flags( &entry
, WINE_LDT_FLAGS_DATA
);
85 for (i
= 0; i
< count
; i
++) wine_ldt_set_entry( sel
+ (i
<< __AHSHIFT
), &entry
);
91 /***********************************************************************
92 * AllocSelector (KERNEL.175)
94 WORD WINAPI
AllocSelector16( WORD sel
)
96 WORD newsel
, count
, i
;
98 count
= sel
? get_sel_count(sel
) : 1;
99 newsel
= SELECTOR_AllocArray( count
);
100 TRACE("(%04x): returning %04x\n", sel
, newsel
);
101 if (!newsel
) return 0;
102 if (!sel
) return newsel
; /* nothing to copy */
103 for (i
= 0; i
< count
; i
++)
106 wine_ldt_get_entry( sel
+ (i
<< __AHSHIFT
), &entry
);
107 wine_ldt_set_entry( newsel
+ (i
<< __AHSHIFT
), &entry
);
113 /***********************************************************************
114 * FreeSelector (KERNEL.176)
116 WORD WINAPI
FreeSelector16( WORD sel
)
118 if (IS_SELECTOR_FREE(sel
)) return sel
; /* error */
121 /* Check if we are freeing current %fs or %gs selector */
122 if (!((wine_get_fs() ^ sel
) & ~3))
124 WARN("Freeing %%fs selector (%04x), not good.\n", wine_get_fs() );
127 if (!((wine_get_gs() ^ sel
) & ~3)) wine_set_gs( 0 );
128 #endif /* __i386__ */
130 wine_ldt_set_entry( sel
, &null_entry
);
131 wine_ldt_copy
.flags
[sel
>> __AHSHIFT
] &= ~WINE_LDT_FLAGS_ALLOCATED
;
136 /***********************************************************************
139 * Free the current %fs selector.
141 void SELECTOR_FreeFs(void)
143 WORD fs
= wine_get_fs();
146 wine_ldt_copy
.flags
[fs
>> __AHSHIFT
] &= ~WINE_LDT_FLAGS_ALLOCATED
;
148 wine_ldt_set_entry( fs
, &null_entry
);
153 /***********************************************************************
154 * SELECTOR_SetEntries
156 * Set the LDT entries for an array of selectors.
158 static void SELECTOR_SetEntries( WORD sel
, const void *base
, DWORD size
, unsigned char flags
)
163 wine_ldt_set_base( &entry
, base
);
164 wine_ldt_set_limit( &entry
, size
- 1 );
165 wine_ldt_set_flags( &entry
, flags
);
166 count
= (size
+ 0xffff) / 0x10000;
167 for (i
= 0; i
< count
; i
++)
169 wine_ldt_set_entry( sel
+ (i
<< __AHSHIFT
), &entry
);
170 wine_ldt_set_base( &entry
, (char*)wine_ldt_get_base(&entry
) + 0x10000);
171 /* yep, Windows sets limit like that, not 64K sel units */
172 wine_ldt_set_limit( &entry
, wine_ldt_get_limit(&entry
) - 0x10000 );
177 /***********************************************************************
178 * SELECTOR_AllocBlock
180 * Allocate selectors for a block of linear memory.
182 WORD
SELECTOR_AllocBlock( const void *base
, DWORD size
, unsigned char flags
)
187 count
= (size
+ 0xffff) / 0x10000;
188 sel
= SELECTOR_AllocArray( count
);
189 if (sel
) SELECTOR_SetEntries( sel
, base
, size
, flags
);
194 /***********************************************************************
197 * Free a block of selectors.
199 void SELECTOR_FreeBlock( WORD sel
)
201 WORD i
, count
= get_sel_count( sel
);
203 TRACE("(%04x,%d)\n", sel
, count
);
204 for (i
= 0; i
< count
; i
++) FreeSelector16( sel
+ (i
<< __AHSHIFT
) );
208 /***********************************************************************
209 * SELECTOR_ReallocBlock
211 * Change the size of a block of selectors.
213 WORD
SELECTOR_ReallocBlock( WORD sel
, const void *base
, DWORD size
)
216 WORD i
, oldcount
, newcount
;
219 oldcount
= get_sel_count( sel
);
220 newcount
= (size
+ 0xffff) >> 16;
221 wine_ldt_get_entry( sel
, &entry
);
223 if (oldcount
< newcount
) /* We need to add selectors */
225 WORD index
= sel
>> __AHSHIFT
;
226 /* Check if the next selectors are free */
227 if (index
+ newcount
> LDT_SIZE
) i
= oldcount
;
229 for (i
= oldcount
; i
< newcount
; i
++)
230 if (wine_ldt_copy
.flags
[index
+i
] & WINE_LDT_FLAGS_ALLOCATED
) break;
232 if (i
< newcount
) /* they are not free */
234 SELECTOR_FreeBlock( sel
);
235 sel
= SELECTOR_AllocArray( newcount
);
237 else /* mark the selectors as allocated */
239 for (i
= oldcount
; i
< newcount
; i
++)
240 wine_ldt_copy
.flags
[index
+i
] |= WINE_LDT_FLAGS_ALLOCATED
;
243 else if (oldcount
> newcount
) /* We need to remove selectors */
245 SELECTOR_FreeBlock( sel
+ (newcount
<< __AHSHIFT
) );
247 if (sel
) SELECTOR_SetEntries( sel
, base
, size
, wine_ldt_get_flags(&entry
) );
252 /***********************************************************************
253 * PrestoChangoSelector (KERNEL.177)
255 WORD WINAPI
PrestoChangoSelector16( WORD selSrc
, WORD selDst
)
258 wine_ldt_get_entry( selSrc
, &entry
);
259 /* toggle the executable bit */
260 entry
.HighWord
.Bits
.Type
^= (WINE_LDT_FLAGS_CODE
^ WINE_LDT_FLAGS_DATA
);
261 wine_ldt_set_entry( selDst
, &entry
);
266 /***********************************************************************
267 * AllocCStoDSAlias (KERNEL.170)
268 * AllocAlias (KERNEL.172)
270 WORD WINAPI
AllocCStoDSAlias16( WORD sel
)
275 newsel
= SELECTOR_AllocArray( 1 );
276 TRACE("(%04x): returning %04x\n",
278 if (!newsel
) return 0;
279 wine_ldt_get_entry( sel
, &entry
);
280 entry
.HighWord
.Bits
.Type
= WINE_LDT_FLAGS_DATA
;
281 wine_ldt_set_entry( newsel
, &entry
);
286 /***********************************************************************
287 * AllocDStoCSAlias (KERNEL.171)
289 WORD WINAPI
AllocDStoCSAlias16( WORD sel
)
294 newsel
= SELECTOR_AllocArray( 1 );
295 TRACE("(%04x): returning %04x\n",
297 if (!newsel
) return 0;
298 wine_ldt_get_entry( sel
, &entry
);
299 entry
.HighWord
.Bits
.Type
= WINE_LDT_FLAGS_CODE
;
300 wine_ldt_set_entry( newsel
, &entry
);
305 /***********************************************************************
306 * LongPtrAdd (KERNEL.180)
308 void WINAPI
LongPtrAdd16( DWORD ptr
, DWORD add
)
311 wine_ldt_get_entry( SELECTOROF(ptr
), &entry
);
312 wine_ldt_set_base( &entry
, (char *)wine_ldt_get_base(&entry
) + add
);
313 wine_ldt_set_entry( SELECTOROF(ptr
), &entry
);
317 /***********************************************************************
318 * GetSelectorBase (KERNEL.186)
320 DWORD WINAPI
WIN16_GetSelectorBase( WORD sel
)
323 * Note: For Win32s processes, the whole linear address space is
324 * shifted by 0x10000 relative to the OS linear address space.
325 * See the comment in msdos/vxd.c.
328 DWORD base
= GetSelectorBase( sel
);
329 return W32S_WINE2APP( base
);
332 /***********************************************************************
335 DWORD WINAPI
GetSelectorBase( WORD sel
)
337 void *base
= wine_ldt_copy
.base
[sel
>> __AHSHIFT
];
339 /* if base points into DOSMEM, assume we have to
340 * return pointer into physical lower 1MB */
342 return DOSMEM_MapLinearToDos( base
);
346 /***********************************************************************
347 * SetSelectorBase (KERNEL.187)
349 DWORD WINAPI
WIN16_SetSelectorBase( WORD sel
, DWORD base
)
352 * Note: For Win32s processes, the whole linear address space is
353 * shifted by 0x10000 relative to the OS linear address space.
354 * See the comment in msdos/vxd.c.
357 SetSelectorBase( sel
, W32S_APP2WINE( base
) );
361 /***********************************************************************
364 WORD WINAPI
SetSelectorBase( WORD sel
, DWORD base
)
367 wine_ldt_get_entry( sel
, &entry
);
368 wine_ldt_set_base( &entry
, DOSMEM_MapDosToLinear(base
) );
369 wine_ldt_set_entry( sel
, &entry
);
374 /***********************************************************************
375 * GetSelectorLimit (KERNEL.188)
377 DWORD WINAPI
GetSelectorLimit16( WORD sel
)
379 return wine_ldt_copy
.limit
[sel
>> __AHSHIFT
];
383 /***********************************************************************
384 * SetSelectorLimit (KERNEL.189)
386 WORD WINAPI
SetSelectorLimit16( WORD sel
, DWORD limit
)
389 wine_ldt_get_entry( sel
, &entry
);
390 wine_ldt_set_limit( &entry
, limit
);
391 wine_ldt_set_entry( sel
, &entry
);
396 /***********************************************************************
397 * SelectorAccessRights (KERNEL.196)
399 WORD WINAPI
SelectorAccessRights16( WORD sel
, WORD op
, WORD val
)
402 wine_ldt_get_entry( sel
, &entry
);
404 if (op
== 0) /* get */
406 return entry
.HighWord
.Bytes
.Flags1
| ((entry
.HighWord
.Bytes
.Flags2
<< 8) & 0xf0);
410 entry
.HighWord
.Bytes
.Flags1
= LOBYTE(val
) | 0xf0;
411 entry
.HighWord
.Bytes
.Flags2
= (entry
.HighWord
.Bytes
.Flags2
& 0x0f) | (HIBYTE(val
) & 0xf0);
412 wine_ldt_set_entry( sel
, &entry
);
418 /***********************************************************************
419 * IsBadCodePtr (KERNEL.336)
421 BOOL16 WINAPI
IsBadCodePtr16( SEGPTR lpfn
)
426 sel
= SELECTOROF(lpfn
);
427 if (!sel
) return TRUE
;
428 if (IS_SELECTOR_FREE(sel
)) return TRUE
;
429 wine_ldt_get_entry( sel
, &entry
);
430 /* check for code segment, ignoring conforming, read-only and accessed bits */
431 if ((entry
.HighWord
.Bits
.Type
^ WINE_LDT_FLAGS_CODE
) & 0x18) return TRUE
;
432 if (OFFSETOF(lpfn
) > wine_ldt_get_limit(&entry
)) return TRUE
;
437 /***********************************************************************
438 * IsBadStringPtr (KERNEL.337)
440 BOOL16 WINAPI
IsBadStringPtr16( SEGPTR ptr
, UINT16 size
)
445 sel
= SELECTOROF(ptr
);
446 if (!sel
) return TRUE
;
447 if (IS_SELECTOR_FREE(sel
)) return TRUE
;
448 wine_ldt_get_entry( sel
, &entry
);
449 /* check for data or readable code segment */
450 if (!(entry
.HighWord
.Bits
.Type
& 0x10)) return TRUE
; /* system descriptor */
451 if ((entry
.HighWord
.Bits
.Type
& 0x0a) == 0x08) return TRUE
; /* non-readable code segment */
452 if (strlen(MapSL(ptr
)) < size
) size
= strlen(MapSL(ptr
)) + 1;
453 if (size
&& (OFFSETOF(ptr
) + size
- 1 > wine_ldt_get_limit(&entry
))) return TRUE
;
458 /***********************************************************************
459 * IsBadHugeReadPtr (KERNEL.346)
461 BOOL16 WINAPI
IsBadHugeReadPtr16( SEGPTR ptr
, DWORD size
)
466 sel
= SELECTOROF(ptr
);
467 if (!sel
) return TRUE
;
468 if (IS_SELECTOR_FREE(sel
)) return TRUE
;
469 wine_ldt_get_entry( sel
, &entry
);
470 /* check for data or readable code segment */
471 if (!(entry
.HighWord
.Bits
.Type
& 0x10)) return TRUE
; /* system descriptor */
472 if ((entry
.HighWord
.Bits
.Type
& 0x0a) == 0x08) return TRUE
; /* non-readable code segment */
473 if (size
&& (OFFSETOF(ptr
) + size
- 1 > wine_ldt_get_limit( &entry
))) return TRUE
;
478 /***********************************************************************
479 * IsBadHugeWritePtr (KERNEL.347)
481 BOOL16 WINAPI
IsBadHugeWritePtr16( SEGPTR ptr
, DWORD size
)
486 sel
= SELECTOROF(ptr
);
487 if (!sel
) return TRUE
;
488 if (IS_SELECTOR_FREE(sel
)) return TRUE
;
489 wine_ldt_get_entry( sel
, &entry
);
490 /* check for writeable data segment, ignoring expand-down and accessed flags */
491 if ((entry
.HighWord
.Bits
.Type
^ WINE_LDT_FLAGS_DATA
) & ~5) return TRUE
;
492 if (size
&& (OFFSETOF(ptr
) + size
- 1 > wine_ldt_get_limit( &entry
))) return TRUE
;
496 /***********************************************************************
497 * IsBadReadPtr (KERNEL.334)
499 BOOL16 WINAPI
IsBadReadPtr16( SEGPTR ptr
, UINT16 size
)
501 return IsBadHugeReadPtr16( ptr
, size
);
505 /***********************************************************************
506 * IsBadWritePtr (KERNEL.335)
508 BOOL16 WINAPI
IsBadWritePtr16( SEGPTR ptr
, UINT16 size
)
510 return IsBadHugeWritePtr16( ptr
, size
);
514 /***********************************************************************
515 * IsBadFlatReadWritePtr (KERNEL.627)
517 BOOL16 WINAPI
IsBadFlatReadWritePtr16( SEGPTR ptr
, DWORD size
, BOOL16 bWrite
)
519 return bWrite
? IsBadHugeWritePtr16( ptr
, size
)
520 : IsBadHugeReadPtr16( ptr
, size
);
524 /***********************************************************************
525 * MemoryRead (TOOLHELP.78)
527 DWORD WINAPI
MemoryRead16( WORD sel
, DWORD offset
, void *buffer
, DWORD count
)
529 WORD index
= sel
>> __AHSHIFT
;
531 if (!(wine_ldt_copy
.flags
[index
] & WINE_LDT_FLAGS_ALLOCATED
)) return 0;
532 if (offset
> wine_ldt_copy
.limit
[index
]) return 0;
533 if (offset
+ count
> wine_ldt_copy
.limit
[index
] + 1)
534 count
= wine_ldt_copy
.limit
[index
] + 1 - offset
;
535 memcpy( buffer
, (char *)wine_ldt_copy
.base
[index
] + offset
, count
);
540 /***********************************************************************
541 * MemoryWrite (TOOLHELP.79)
543 DWORD WINAPI
MemoryWrite16( WORD sel
, DWORD offset
, void *buffer
, DWORD count
)
545 WORD index
= sel
>> __AHSHIFT
;
547 if (!(wine_ldt_copy
.flags
[index
] & WINE_LDT_FLAGS_ALLOCATED
)) return 0;
548 if (offset
> wine_ldt_copy
.limit
[index
]) return 0;
549 if (offset
+ count
> wine_ldt_copy
.limit
[index
] + 1)
550 count
= wine_ldt_copy
.limit
[index
] + 1 - offset
;
551 memcpy( (char *)wine_ldt_copy
.base
[index
] + offset
, buffer
, count
);
555 /************************************* Win95 pointer mapping functions *
561 struct mapls_entry
*next
;
562 void *addr
; /* linear address */
563 int count
; /* ref count */
564 WORD sel
; /* selector */
567 static struct mapls_entry
*first_entry
;
570 /***********************************************************************
574 * Maps linear pointer to segmented.
576 SEGPTR WINAPI
MapLS( LPCVOID ptr
)
578 struct mapls_entry
*entry
, *free
= NULL
;
582 if (!HIWORD(ptr
)) return (SEGPTR
)ptr
;
584 base
= (char *)ptr
- ((unsigned int)ptr
& 0x7fff);
585 HeapLock( GetProcessHeap() );
586 for (entry
= first_entry
; entry
; entry
= entry
->next
)
588 if (entry
->addr
== base
) break;
589 if (!entry
->count
) free
= entry
;
594 if (!free
) /* no free entry found, create a new one */
596 if (!(free
= HeapAlloc( GetProcessHeap(), 0, sizeof(*free
) ))) goto done
;
597 if (!(free
->sel
= SELECTOR_AllocBlock( base
, 0x10000, WINE_LDT_FLAGS_DATA
)))
599 HeapFree( GetProcessHeap(), 0, free
);
603 free
->next
= first_entry
;
606 SetSelectorBase( free
->sel
, (DWORD
)base
);
611 ret
= MAKESEGPTR( entry
->sel
, (char *)ptr
- (char *)entry
->addr
);
613 HeapUnlock( GetProcessHeap() );
617 /***********************************************************************
618 * UnMapLS (KERNEL32.@)
619 * UnMapLS (KERNEL.359)
621 * Free mapped selector.
623 void WINAPI
UnMapLS( SEGPTR sptr
)
625 struct mapls_entry
*entry
;
626 WORD sel
= SELECTOROF(sptr
);
630 HeapLock( GetProcessHeap() );
631 for (entry
= first_entry
; entry
; entry
= entry
->next
) if (entry
->sel
== sel
) break;
632 if (entry
&& entry
->count
> 0) entry
->count
--;
633 HeapUnlock( GetProcessHeap() );
637 /***********************************************************************
641 * Maps fixed segmented pointer to linear.
643 LPVOID WINAPI
MapSL( SEGPTR sptr
)
645 return (char *)wine_ldt_copy
.base
[SELECTOROF(sptr
) >> __AHSHIFT
] + OFFSETOF(sptr
);
648 /***********************************************************************
649 * MapSLFix (KERNEL32.@)
651 * FIXME: MapSLFix and UnMapSLFixArray should probably prevent
652 * unexpected linear address change when GlobalCompact() shuffles
656 LPVOID WINAPI
MapSLFix( SEGPTR sptr
)
661 /***********************************************************************
662 * UnMapSLFixArray (KERNEL32.@)
665 void WINAPI
UnMapSLFixArray( SEGPTR sptr
[], INT length
, CONTEXT86
*context
)
667 /* Must not change EAX, hence defined as 'register' function */
670 /***********************************************************************
671 * GetThreadSelectorEntry (KERNEL32.@)
673 BOOL WINAPI
GetThreadSelectorEntry( HANDLE hthread
, DWORD sel
, LPLDT_ENTRY ldtent
)
678 if (!(sel
& 4)) /* GDT selector */
680 sel
&= ~3; /* ignore RPL */
681 if (!sel
) /* null selector */
683 memset( ldtent
, 0, sizeof(*ldtent
) );
687 ldtent
->HighWord
.Bits
.BaseMid
= 0;
688 ldtent
->HighWord
.Bits
.BaseHi
= 0;
689 ldtent
->LimitLow
= 0xffff;
690 ldtent
->HighWord
.Bits
.LimitHi
= 0xf;
691 ldtent
->HighWord
.Bits
.Dpl
= 3;
692 ldtent
->HighWord
.Bits
.Sys
= 0;
693 ldtent
->HighWord
.Bits
.Pres
= 1;
694 ldtent
->HighWord
.Bits
.Granularity
= 1;
695 ldtent
->HighWord
.Bits
.Default_Big
= 1;
696 ldtent
->HighWord
.Bits
.Type
= 0x12;
697 /* it has to be one of the system GDT selectors */
698 if (sel
== (wine_get_ds() & ~3)) return TRUE
;
699 if (sel
== (wine_get_ss() & ~3)) return TRUE
;
700 if (sel
== (wine_get_cs() & ~3))
702 ldtent
->HighWord
.Bits
.Type
|= 8; /* code segment */
705 SetLastError( ERROR_NOACCESS
);
709 SERVER_START_REQ( get_selector_entry
)
711 req
->handle
= hthread
;
712 req
->entry
= sel
>> __AHSHIFT
;
713 if ((ret
= !wine_server_call_err( req
)))
715 if (!(reply
->flags
& WINE_LDT_FLAGS_ALLOCATED
))
717 SetLastError( ERROR_MR_MID_NOT_FOUND
); /* sic */
722 wine_ldt_set_base( ldtent
, (void *)reply
->base
);
723 wine_ldt_set_limit( ldtent
, reply
->limit
);
724 wine_ldt_set_flags( ldtent
, reply
->flags
);
731 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
737 /**********************************************************************
739 * These functions map linear pointers at [EBP+xxx] to segmented pointers
741 * Win95 uses some kind of alias structs, which it stores in [EBP+x] to
742 * unravel them at SUnMapLS. We just store the segmented pointer there.
745 x_SMapLS_IP_EBP_x(CONTEXT86
*context
,int argoff
) {
748 val
=*(DWORD
*)(context
->Ebp
+ argoff
);
751 *(DWORD
*)(context
->Ebp
+ argoff
) = 0;
753 ptr
= MapLS((LPVOID
)val
);
754 *(DWORD
*)(context
->Ebp
+ argoff
) = ptr
;
759 /***********************************************************************
760 * SMapLS_IP_EBP_8 (KERNEL32.@)
762 void WINAPI
SMapLS_IP_EBP_8 (CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
, 8);}
764 /***********************************************************************
765 * SMapLS_IP_EBP_12 (KERNEL32.@)
767 void WINAPI
SMapLS_IP_EBP_12(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,12);}
769 /***********************************************************************
770 * SMapLS_IP_EBP_16 (KERNEL32.@)
772 void WINAPI
SMapLS_IP_EBP_16(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,16);}
774 /***********************************************************************
775 * SMapLS_IP_EBP_20 (KERNEL32.@)
777 void WINAPI
SMapLS_IP_EBP_20(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,20);}
779 /***********************************************************************
780 * SMapLS_IP_EBP_24 (KERNEL32.@)
782 void WINAPI
SMapLS_IP_EBP_24(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,24);}
784 /***********************************************************************
785 * SMapLS_IP_EBP_28 (KERNEL32.@)
787 void WINAPI
SMapLS_IP_EBP_28(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,28);}
789 /***********************************************************************
790 * SMapLS_IP_EBP_32 (KERNEL32.@)
792 void WINAPI
SMapLS_IP_EBP_32(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,32);}
794 /***********************************************************************
795 * SMapLS_IP_EBP_36 (KERNEL32.@)
797 void WINAPI
SMapLS_IP_EBP_36(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,36);}
799 /***********************************************************************
800 * SMapLS_IP_EBP_40 (KERNEL32.@)
802 void WINAPI
SMapLS_IP_EBP_40(CONTEXT86
*context
) {x_SMapLS_IP_EBP_x(context
,40);}
804 /***********************************************************************
805 * SMapLS (KERNEL32.@)
807 void WINAPI
SMapLS( CONTEXT86
*context
)
809 if (HIWORD(context
->Eax
))
811 context
->Eax
= MapLS( (LPVOID
)context
->Eax
);
812 context
->Edx
= context
->Eax
;
818 /***********************************************************************
819 * SUnMapLS (KERNEL32.@)
822 void WINAPI
SUnMapLS( CONTEXT86
*context
)
824 if (HIWORD(context
->Eax
)) UnMapLS( (SEGPTR
)context
->Eax
);
827 inline static void x_SUnMapLS_IP_EBP_x(CONTEXT86
*context
,int argoff
)
829 SEGPTR
*ptr
= (SEGPTR
*)(context
->Ebp
+ argoff
);
837 /***********************************************************************
838 * SUnMapLS_IP_EBP_8 (KERNEL32.@)
840 void WINAPI
SUnMapLS_IP_EBP_8 (CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
, 8); }
842 /***********************************************************************
843 * SUnMapLS_IP_EBP_12 (KERNEL32.@)
845 void WINAPI
SUnMapLS_IP_EBP_12(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,12); }
847 /***********************************************************************
848 * SUnMapLS_IP_EBP_16 (KERNEL32.@)
850 void WINAPI
SUnMapLS_IP_EBP_16(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,16); }
852 /***********************************************************************
853 * SUnMapLS_IP_EBP_20 (KERNEL32.@)
855 void WINAPI
SUnMapLS_IP_EBP_20(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,20); }
857 /***********************************************************************
858 * SUnMapLS_IP_EBP_24 (KERNEL32.@)
860 void WINAPI
SUnMapLS_IP_EBP_24(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,24); }
862 /***********************************************************************
863 * SUnMapLS_IP_EBP_28 (KERNEL32.@)
865 void WINAPI
SUnMapLS_IP_EBP_28(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,28); }
867 /***********************************************************************
868 * SUnMapLS_IP_EBP_32 (KERNEL32.@)
870 void WINAPI
SUnMapLS_IP_EBP_32(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,32); }
872 /***********************************************************************
873 * SUnMapLS_IP_EBP_36 (KERNEL32.@)
875 void WINAPI
SUnMapLS_IP_EBP_36(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,36); }
877 /***********************************************************************
878 * SUnMapLS_IP_EBP_40 (KERNEL32.@)
880 void WINAPI
SUnMapLS_IP_EBP_40(CONTEXT86
*context
) { x_SUnMapLS_IP_EBP_x(context
,40); }
882 /**********************************************************************
883 * AllocMappedBuffer (KERNEL32.38)
885 * This is a undocumented KERNEL32 function that
886 * SMapLS's a GlobalAlloc'ed buffer.
888 * Input: EDI register: size of buffer to allocate
889 * Output: EDI register: pointer to buffer
891 * Note: The buffer is preceded by 8 bytes:
894 * edi-4 SEGPTR to buffer
895 * edi-8 some magic Win95 needs for SUnMapLS
896 * (we use it for the memory handle)
898 * The SEGPTR is used by the caller!
901 void WINAPI
AllocMappedBuffer( CONTEXT86
*context
)
903 HGLOBAL handle
= GlobalAlloc(0, context
->Edi
+ 8);
904 DWORD
*buffer
= (DWORD
*)GlobalLock(handle
);
908 if (!(ptr
= MapLS(buffer
+ 2)))
910 GlobalUnlock(handle
);
915 context
->Eax
= context
->Edi
= 0;
918 buffer
[0] = (DWORD
)handle
;
921 context
->Eax
= (DWORD
) ptr
;
922 context
->Edi
= (DWORD
)(buffer
+ 2);
926 /**********************************************************************
927 * FreeMappedBuffer (KERNEL32.39)
929 * Free a buffer allocated by AllocMappedBuffer
931 * Input: EDI register: pointer to buffer
934 void WINAPI
FreeMappedBuffer( CONTEXT86
*context
)
938 DWORD
*buffer
= (DWORD
*)context
->Edi
- 2;
942 GlobalUnlock((HGLOBAL
)buffer
[0]);
943 GlobalFree((HGLOBAL
)buffer
[0]);