src/w32term.h (SCROLL_BAR_PACK, SCROLL_BAR_UNPACK): Define for x64.
(SET_SCROLL_BAR_W32_WINDOW): Cast ID to intptr_t, for
compatibility with x64.
src/w32term.c (w32_draw_underwave): Don't use GCC extensions for
defining an XRectangle structure.
src/w32proc.c (RVA_TO_PTR, w32_executable_type): Fix pointer
arithmetics for compatibility with x64.
src/w32menu.c (add_menu_item): Use UINT_PTR instead of UINT, for
compatibility with x64.
src/w32heap.h: Adjust prototypes and declarations.
src/w32heap.c (RVA_TO_PTR, allocate_heap, sbrk, init_heap)
(round_heap): Use DWORD_PTR, ptrdiff_t and size_t instead of
DWORD, long, and unsigned long, for compatibility with x64.
(allocate_heap) [_WIN64]: Reserve 32GB of memory.
(sbrk): Argument is now of type ptrdiff_t.
src/w32fns.c (HMONITOR): Condition declaration on _WIN32_WINNT being
less than 0x0500.
(w32_msg_pump): Use WPARAM type for 'result'.
src/w32.c (init_environment, get_emacs_configuration): Support AMD64
architecture.
(init_ntproc): Cast arguments of _open_osfhandle to intptr_t, for
compatibility with x64.
src/vm-limit.c (lim_data): Now size_t.
(check_memory_limits): Adjust prototypes of real_morecore and
__morecore to receive argument of type ptrdiff_t. Use size_t for
five_percent and data_size.
src/unexw32.c: Use DWORD_PTR instead of DWORD for file-scope
variables, for compatibility with x64.
(rva_to_section, offset_to_section, relocate_offset)
(OFFSET_TO_RVA, RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET)
(PTR_TO_RVA, RVA_TO_PTR, OFFSET_TO_PTR, get_section_info)
(copy_executable_and_dump_data): Use DWORD_PTR instead of DWORD
for compatibility with x64.
src/sysdep.c (STDERR_FILENO): Define if not already defined.
src/ralloc.c (real_morecore): Argument type is now ptrdiff_t.
(__morecore): Argument type is now ptrdiff_t.
(ROUNDUP, MEM_ROUNDUP): Use size_t instead of 'unsigned long'.
(relinquish): Use ptrdiff_t type for 'excess'.
(r_alloc_sbrk): Argument type is now ptrdiff_t.
src/makefile.w32-in (HEAPSIZE): Get value from EMACS_HEAPSIZE.
(bootstrap-temacs-CMD, bootstrap-temacs-SH): Use $(EMACS_PURESIZE)
instead of a literal number.
src/gmalloc.c [WINDOWSNT]: Include w32heap.h.
(min): Define only if not already defined.
src/frame.c (x_report_frame_params): Use EMACS_UINT for the return
value of FRAME_X_WINDOW, to fit a 64-bit pointer on 64-bit Windows
hosts.
src/image.c (x_bitmap_pixmap): Return ptrdiff_t, not int, since
'bitmaps' is a pointer.
src/dispextern.h (x_bitmap_pixmap): Adjust prototype.
src/alloc.c (gdb_make_enums_visible): Now conditional on __GNUC__.
nt/makefile.w32-in ($(TRES)): Use $(EMACS_MANIFEST).
nt/inc/sys/socket.h: Don't map Winsock error codes to standard ones
that are already defined.
nt/inc/ms-w32.h (EMACS_INT, EMACS_UINT, EMACS_INT_MAX, PRIuMAX)
(pI, _INTPTR) [_MSC_VER]: Fix definitions for MSVC.
[_MSC_VER]: Add pragmas to suppress some MSVC warnings.
nt/preprep.c (pfnCheckSumMappedFile, rva_to_section)
(offset_to_section, relocate_offset, OFFSET_TO_RVA)
(RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET, PTR_TO_RVA)
(OFFSET_TO_PTR, ROUND_UP, ROUND_DOWN)
(copy_executable_and_move_sections, ADJUST_IMPORT_RVA, main): Use
DWORD_PTR instead of DWORD for compatibility with x64.
nt/nmake.defs: Support AMD64.
(EMACS_HEAPSIZE, EMACS_PURESIZE, EMACS_MANIFEST): New macros.
nt/gmake.defs: (EMACS_HEAPSIZE, EMACS_PURESIZE, EMACS_MANIFEST):
New macros.
nt/addsection.c (pfnCheckSumMappedFile, rva_to_section)
(offset_to_section, relocate_offset, OFFSET_TO_RVA)
(RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET, PTR_TO_RVA)
(OFFSET_TO_PTR, ROUND_UP, ROUND_DOWN)
(copy_executable_and_add_section, main): Use DWORD_PTR instead of
DWORD, for compatibility with x64.
nt/emacs-x64.manifest: New file.
nt/emacs-x86.manifest: Renamed from emacs.manifest.
lib-src/ntlib.c (gettimeofday): Copy from src/w32.c. lib/gettime.
needs this function.
+2012-09-30 Eli Zaretskii <eliz@gnu.org>
+
+ * ntlib.c (gettimeofday): Copy from src/w32.c. lib/gettime.c
+ needs this function.
+
2012-09-26 Juanma Barranquero <lekktu@gmail.com>
* makefile.w32-in (obj): Add profiler.o.
#include <sys/stat.h>
#include <errno.h>
#include <ctype.h>
+#include <sys/timeb.h>
#include "ntlib.h"
+struct timezone
+{
+ int tz_minuteswest; /* minutes west of Greenwich */
+ int tz_dsttime; /* type of dst correction */
+};
+
#define MAXPATHLEN _MAX_PATH
/* Emulate sleep...we could have done this with a define, but that
return NULL;
}
+/* This is needed because lib/gettime.c calls gettimeofday, which MSVC
+ doesn't have. Copied from w32.c. */
+void
+gettimeofday (struct timeval *tv, struct timezone *tz)
+{
+ struct _timeb tb;
+ _ftime (&tb);
+
+ tv->tv_sec = tb.time;
+ tv->tv_usec = tb.millitm * 1000L;
+ /* Implementation note: _ftime sometimes doesn't update the dstflag
+ according to the new timezone when the system timezone is
+ changed. We could fix that by using GetSystemTime and
+ GetTimeZoneInformation, but that doesn't seem necessary, since
+ Emacs always calls gettimeofday with the 2nd argument NULL (see
+ current_emacs_time). */
+ if (tz)
+ {
+ tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich */
+ tz->tz_dsttime = tb.dstflag; /* type of dst correction */
+ }
+}
+
int
fchown (int fd, unsigned uid, unsigned gid)
{
+2012-09-30 Eli Zaretskii <eliz@gnu.org>
+
+ * makefile.w32-in ($(TRES)): Use $(EMACS_MANIFEST).
+
+2012-09-30 Fabrice Popineau <fabrice.popineau@supelec.fr>
+
+ * inc/sys/socket.h: Don't map Winsock error codes to standard ones
+ that are already defined.
+
+ * inc/ms-w32.h (EMACS_INT, EMACS_UINT, EMACS_INT_MAX, PRIuMAX)
+ (pI, _INTPTR) [_MSC_VER]: Fix definitions for MSVC.
+ [_MSC_VER]: Add pragmas to suppress some MSVC warnings.
+
+ * preprep.c (pfnCheckSumMappedFile, rva_to_section)
+ (offset_to_section, relocate_offset, OFFSET_TO_RVA)
+ (RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET, PTR_TO_RVA)
+ (OFFSET_TO_PTR, ROUND_UP, ROUND_DOWN)
+ (copy_executable_and_move_sections, ADJUST_IMPORT_RVA, main): Use
+ DWORD_PTR instead of DWORD for compatibility with x64.
+
+ * nmake.defs: Support AMD64.
+ (EMACS_HEAPSIZE, EMACS_PURESIZE, EMACS_MANIFEST): New macros.
+
+ * gmake.defs: (EMACS_HEAPSIZE, EMACS_PURESIZE, EMACS_MANIFEST):
+ New macros.
+
+ * addsection.c (pfnCheckSumMappedFile, rva_to_section)
+ (offset_to_section, relocate_offset, OFFSET_TO_RVA)
+ (RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET, PTR_TO_RVA)
+ (OFFSET_TO_PTR, ROUND_UP, ROUND_DOWN)
+ (copy_executable_and_add_section, main): Use DWORD_PTR instead of
+ DWORD, for compatibility with x64.
+
+ * emacs-x64.manifest: New file.
+
+ * emacs-x86.manifest: Renamed from emacs.manifest.
+
2012-09-30 Eli Zaretskii <eliz@gnu.org>
* inc/sys/time.h (ITIMER_REAL, ITIMER_PROF): Define.
in \\win32sdk\mstools\samples\image\include\imagehlp.h. */
PIMAGE_NT_HEADERS
-(__stdcall * pfnCheckSumMappedFile) (LPVOID BaseAddress,
- DWORD FileLength,
- LPDWORD HeaderSum,
- LPDWORD CheckSum);
+(__stdcall * pfnCheckSumMappedFile) (PVOID BaseAddress,
+ DWORD_PTR FileLength,
+ PDWORD_PTR HeaderSum,
+ PDWORD_PTR CheckSum);
#undef min
#undef max
/* Return pointer to section header for section containing the given
relative virtual address. */
IMAGE_SECTION_HEADER *
-rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
+rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
some very old exes (eg. gzip dated Dec 1993). Since
w32_executable_type relies on this function to work reliably,
we need to cope with this. */
- DWORD real_size = max (section->SizeOfRawData,
+ DWORD_PTR real_size = max (section->SizeOfRawData,
section->Misc.VirtualSize);
if (rva >= section->VirtualAddress
&& rva < section->VirtualAddress + real_size)
/* Return pointer to section header for section containing the given
offset in its raw data area. */
IMAGE_SECTION_HEADER *
-offset_to_section (DWORD offset, IMAGE_NT_HEADERS * nt_header)
+offset_to_section (DWORD_PTR offset, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
/* Return offset to an object in dst, given offset in src. We assume
there is at least one section in both src and dst images, and that
the some sections may have been added to dst (after sections in src). */
-static DWORD
-relocate_offset (DWORD offset,
+static DWORD_PTR
+relocate_offset (DWORD_PTR offset,
IMAGE_NT_HEADERS * src_nt_header,
IMAGE_NT_HEADERS * dst_nt_header)
{
}
#define OFFSET_TO_RVA(offset, section) \
- (section->VirtualAddress + ((DWORD)(offset) - section->PointerToRawData))
+ (section->VirtualAddress + ((DWORD_PTR)(offset) - section->PointerToRawData))
#define RVA_TO_OFFSET(rva, section) \
- (section->PointerToRawData + ((DWORD)(rva) - section->VirtualAddress))
+ (section->PointerToRawData + ((DWORD_PTR)(rva) - section->VirtualAddress))
#define RVA_TO_SECTION_OFFSET(rva, section) \
- ((DWORD)(rva) - section->VirtualAddress)
+ ((DWORD_PTR)(rva) - section->VirtualAddress)
/* Convert address in executing image to RVA. */
-#define PTR_TO_RVA(ptr) ((DWORD)(ptr) - (DWORD) GetModuleHandle (NULL))
+#define PTR_TO_RVA(ptr) ((DWORD_PTR)(ptr) - (DWORD_PTR) GetModuleHandle (NULL))
#define PTR_TO_OFFSET(ptr, pfile_data) \
((unsigned const char *)(ptr) - (pfile_data)->file_base)
#define OFFSET_TO_PTR(offset, pfile_data) \
- ((pfile_data)->file_base + (DWORD)(offset))
+ ((pfile_data)->file_base + (DWORD_PTR)(offset))
-#define ROUND_UP(p, align) (((DWORD)(p) + (align)-1) & ~((align)-1))
-#define ROUND_DOWN(p, align) ((DWORD)(p) & ~((align)-1))
+#define ROUND_UP(p, align) \
+ (((DWORD_PTR)(p) + (align)-1) & ~((DWORD_PTR)(align)-1))
+#define ROUND_DOWN(p, align) ((DWORD_PTR)(p) & ~((DWORD_PTR)(align)-1))
static void
copy_executable_and_add_section (file_data *p_infile,
file_data *p_outfile,
const char *new_section_name,
- DWORD new_section_size)
+ DWORD_PTR new_section_size)
{
unsigned char *dst;
PIMAGE_DOS_HEADER dos_header;
PIMAGE_NT_HEADERS dst_nt_header;
PIMAGE_SECTION_HEADER section;
PIMAGE_SECTION_HEADER dst_section;
- DWORD offset;
+ DWORD_PTR offset;
int i;
int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
Note that dst is updated implicitly by each COPY_CHUNK. */
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
- nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
+ nt_header = (PIMAGE_NT_HEADERS) (((unsigned char *) dos_header) +
dos_header->e_lfanew);
section = IMAGE_FIRST_SECTION (nt_header);
dst = (unsigned char *) p_outfile->file_base;
COPY_CHUNK ("Copying DOS header...", dos_header,
- (DWORD) nt_header - (DWORD) dos_header, be_verbose);
+ (DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
dst_nt_header = (PIMAGE_NT_HEADERS) dst;
COPY_CHUNK ("Copying NT header...", nt_header,
- (DWORD) section - (DWORD) nt_header, be_verbose);
+ (DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
dst_section = (PIMAGE_SECTION_HEADER) dst;
COPY_CHUNK ("Copying section table...", section,
nt_header->FileHeader.NumberOfSections * sizeof (*section),
/* Patch up header fields; profiler is picky about this. */
{
HANDLE hImagehelp = LoadLibrary ("imagehlp.dll");
- DWORD headersum;
- DWORD checksum;
+ DWORD_PTR headersum;
+ DWORD_PTR checksum;
dos_header = (PIMAGE_DOS_HEADER) out_file.file_base;
nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+ <dependency>
+ <dependentAssembly>
+ <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls"
+ version="6.0.0.0" processorArchitecture="AMD64"
+ publicKeyToken="6595b64144ccf1df"
+ language="*"/>
+ </dependentAssembly>
+ </dependency>
+ <assemblyIdentity version="1.0.0.0" processorArchitecture="AMD64"
+ name="emacs" type="win32"/>
+ <description>GNU Emacs</description>
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+ <security>
+ <requestedPrivileges>
+ <requestedExecutionLevel level="asInvoker"/>
+ </requestedPrivileges>
+ </security>
+ </trustInfo>
+</assembly>
Emacs ICON icons\emacs.ico
32649 CURSOR icons\hand.cur
-1 24 "emacs.manifest"
+#ifdef WIN64
+1 24 "emacs-x64.manifest"
+#else
+1 24 "emacs-x86.manifest"
+#endif
#ifndef VS_VERSION_INFO
#define VS_VERSION_INFO 1
ifeq "$(PROCESSOR_ARCHITECTURE)" "x86"
ARCH = i386
CPU = i386
+EMACS_HEAPSIZE = 27
+EMACS_PURESIZE = 5000000
+EMACS_MANIFEST = emacs-x86.manifest
else
ifeq "$(PROCESSOR_ARCHITECTURE)" "MIPS"
ARCH = mips
+EMACS_HEAPSIZE = 27
+EMACS_PURESIZE = 5000000
+EMACS_MANIFEST = emacs-mips.manifest
else
ifeq "$(PROCESSOR_ARCHITECTURE)" "ALPHA"
ARCH = alpha
+EMACS_HEAPSIZE = 27
+EMACS_PURESIZE = 5000000
+EMACS_MANIFEST = emacs-alpha.manifest
else
ifeq "$(PROCESSOR_ARCHITECTURE)" "PPC"
ARCH = ppc
+EMACS_HEAPSIZE = 27
+EMACS_PURESIZE = 5000000
+EMACS_MANIFEST = emacs-ppc.manifest
else
$(error Unknown architecture type "$(PROCESSOR_ARCHITECTURE)")
endif
extern int getloadavg (double *, int);
-#if defined (__MINGW32__) || _MSC_VER >= 1400
+#if defined (__MINGW32__)
/* Define to 1 if the system has the type `long long int'. */
# define HAVE_LONG_LONG_INT 1
/* Define to 1 if the system has the type `unsigned long long int'. */
# define HAVE_UNSIGNED_LONG_LONG_INT 1
-#elif _MSC_VER >= 1200
+#endif
+#ifdef _MSC_VER
+# if defined(_WIN64)
+typedef __int64 EMACS_INT;
+typedef unsigned __int64 EMACS_UINT;
+# define EMACS_INT_MAX LLONG_MAX
+# define PRIuMAX "llu"
+# define pI "ll"
+/* Fix a bug in MSVC headers : stdint.h */
+# define _INTPTR 2
+# elif defined(_WIN32)
/* Temporarily disable wider-than-pointer integers until they're tested more.
Build with CFLAGS='-DWIDE_EMACS_INT' to try them out. */
-# ifdef WIDE_EMACS_INT
+# ifdef WIDE_EMACS_INT
/* Use pre-C99-style 64-bit integers. */
typedef __int64 EMACS_INT;
typedef unsigned __int64 EMACS_UINT;
-# define EMACS_INT_MAX _I64_MAX
-# define pI "I64"
-
+# define EMACS_INT_MAX LLONG_MAX
+# define PRIuMAX "llu"
+# define pI "I64"
+# else
+typedef int EMACS_INT;
+typedef unsigned int EMACS_UINT;
+# define EMACS_INT_MAX LONG_MAX
+# define PRIuMAX "lu"
+# define pI "l"
+# endif
# endif
-
#endif
/* We need a little extra space, see ../../lisp/loadup.el. */
#define DebPrint(stuff)
#endif
+#ifdef _MSC_VER
+#if _MSC_VER >= 800 && !defined(__cplusplus)
+/* Unnamed type definition in parentheses.
+ A structure, union, or enumerated type with no name is defined in a
+ parenthetical expression. The type definition is meaningless. */
+#pragma warning(disable:4116)
+/* 'argument' : conversion from 'type1' to 'type2', possible loss of
+ data A floating point type was converted to an integer type. A
+ possible loss of data may have occurred. */
+#pragma warning(disable:4244)
+/* Negative integral constant converted to unsigned type.
+ An expression converts a negative integer constant to an unsigned type.
+ The result of the expression is probably meaningless. */
+#pragma warning(disable:4308)
+#endif
+#endif
#define TERM_HEADER "w32term.h"
extern int h_errno;
/* map winsock error codes to standard names */
+#if defined(EWOULDBLOCK)
+#undef EWOULDBLOCK
+#endif
#define EWOULDBLOCK WSAEWOULDBLOCK
+#if defined(EINPROGRESS)
+#undef EINPROGRESS
+#endif
#define EINPROGRESS WSAEINPROGRESS
+#if defined(EALREADY)
+#undef EALREADY
+#endif
#define EALREADY WSAEALREADY
+#if defined(ENOTSOCK)
+#undef ENOTSOCK
+#endif
#define ENOTSOCK WSAENOTSOCK
+#if defined(EDESTADDRREQ)
+#undef EDESTADDRREQ
+#endif
#define EDESTADDRREQ WSAEDESTADDRREQ
+#if defined(EMSGSIZE)
+#undef EMSGSIZE
+#endif
#define EMSGSIZE WSAEMSGSIZE
+#if defined(EPROTOTYPE)
+#undef EPROTOTYPE
+#endif
#define EPROTOTYPE WSAEPROTOTYPE
+#if defined(ENOPROTOOPT)
+#undef ENOPROTOOPT
+#endif
#define ENOPROTOOPT WSAENOPROTOOPT
+#if defined(EPROTONOSUPPORT)
+#undef EPROTONOSUPPORT
+#endif
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
+#if defined(ESOCKTNOSUPPORT)
+#undef ESOCKTNOSUPPORT
+#endif
#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
+#if defined(EOPNOTSUPP)
+#undef EOPNOTSUPP
+#endif
#define EOPNOTSUPP WSAEOPNOTSUPP
+#if defined(EPFNOSUPPORT)
+#undef EPFNOSUPPORT
+#endif
#define EPFNOSUPPORT WSAEPFNOSUPPORT
+#if defined(EAFNOSUPPORT)
+#undef EAFNOSUPPORT
+#endif
#define EAFNOSUPPORT WSAEAFNOSUPPORT
+#if defined(EADDRINUSE)
+#undef EADDRINUSE
+#endif
#define EADDRINUSE WSAEADDRINUSE
+#if defined(EADDRNOTAVAIL)
+#undef EADDRNOTAVAIL
+#endif
#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
+#if defined(ENETDOWN)
+#undef ENETDOWN
+#endif
#define ENETDOWN WSAENETDOWN
+#if defined(ENETUNREACH)
+#undef ENETUNREACH
+#endif
#define ENETUNREACH WSAENETUNREACH
+#if defined(ENETRESET)
+#undef ENETRESET
+#endif
#define ENETRESET WSAENETRESET
+#if defined(ECONNABORTED)
+#undef ECONNABORTED
+#endif
#define ECONNABORTED WSAECONNABORTED
+#if defined(ECONNRESET)
+#undef ECONNRESET
+#endif
#define ECONNRESET WSAECONNRESET
+#if defined(ENOBUFS)
+#undef ENOBUFS
+#endif
#define ENOBUFS WSAENOBUFS
+#if defined(EISCONN)
+#undef EISCONN
+#endif
#define EISCONN WSAEISCONN
+#if defined(ENOTCONN)
+#undef ENOTCONN
+#endif
#define ENOTCONN WSAENOTCONN
+#if defined(ESHUTDOWN)
+#undef ESHUTDOWN
+#endif
#define ESHUTDOWN WSAESHUTDOWN
+#if defined(ETOOMANYREFS)
+#undef ETOOMANYREFS
+#endif
#define ETOOMANYREFS WSAETOOMANYREFS
+#if defined(ETIMEDOUT)
+#undef ETIMEDOUT
+#endif
#define ETIMEDOUT WSAETIMEDOUT
+#if defined(ECONNREFUSED)
+#undef ECONNREFUSED
+#endif
#define ECONNREFUSED WSAECONNREFUSED
+#if defined(ELOOP)
+#undef ELOOP
+#endif
#define ELOOP WSAELOOP
/* #define ENAMETOOLONG WSAENAMETOOLONG */
+#if defined(EHOSTDOWN)
+#undef EHOSTDOWN
+#endif
#define EHOSTDOWN WSAEHOSTDOWN
+#if defined(EHOSTUNREACH)
+#undef EHOSTUNREACH
+#endif
#define EHOSTUNREACH WSAEHOSTUNREACH
/* #define ENOTEMPTY WSAENOTEMPTY */
+#if defined(EPROCLIM)
+#undef EPROCLIM
+#endif
#define EPROCLIM WSAEPROCLIM
+#if defined(EUSERS)
+#undef EUSERS
+#endif
#define EUSERS WSAEUSERS
+#if defined(EDQUOT)
+#undef EDQUOT
+#endif
#define EDQUOT WSAEDQUOT
+#if defined(ESTALE)
+#undef ESTALE
+#endif
#define ESTALE WSAESTALE
+#if defined(EREMOTE)
+#undef EREMOTE
+#endif
#define EREMOTE WSAEREMOTE
#endif /* _SOCKET_H_ */
# The resource file. NT 3.10 requires the use of cvtres; even though
# it is not necessary on later versions, it is still ok to use it.
#
-$(TRES): emacs.rc icons/emacs.ico emacs.manifest stamp_BLD
+$(TRES): emacs.rc icons/emacs.ico $(EMACS_MANIFEST) stamp_BLD
$(RC) $(RC_OUT)$(TRES) emacs.rc
$(CLIENTRES): emacsclient.rc stamp_BLD
! if "$(PROCESSOR_ARCHITECTURE)" == "PPC"\r
ARCH = ppc\r
! else\r
-! error Unknown architecture type "$(PROCESSOR_ARCHITECTURE)"\r
+! if "$(PROCESSOR_ARCHITECTURE)" == "AMD64"\r
+ARCH = AMD64\r
+! else\r
+! error Unknown architecture type "$(PROCESSOR_ARCHITECTURE)"\r
+! endif\r
! endif\r
! endif\r
! endif\r
CC_OUT = -Fo\r
LINK = link\r
LINK_OUT = -out:\r
-RC = rc\r
+RC = rc $(ARCH_RCFLAGS)\r
RC_OUT = -Fo\r
RC_INCLUDE = -i\r
\r
\r
MWINDOWS = -subsystem:windows -entry:mainCRTStartup\r
\r
-CFLAGS = -I. $(ARCH_CFLAGS) \\r
+CFLAGS = -I. $(ARCH_CFLAGS) -D_CRT_SECURE_NO_WARNINGS \\r
$(DEBUG_CFLAGS) $(USER_CFLAGS) $(LOCAL_FLAGS)\r
-ESC_CFLAGS = -I. $(ARCH_CFLAGS) \\r
+ESC_CFLAGS = -I. $(ARCH_CFLAGS) -D_CRT_SECURE_NO_WARNINGS \\r
$(DEBUG_CFLAGS) $(ESC_USER_CFLAGS) $(LOCAL_FLAGS)\r
\r
#SYS_LDFLAGS = -nologo -release -incremental:no -version:3.10 -swaprun:cd -swaprun:net setargv.obj\r
-!ifdef NOOPT\r
-SYS_LDFLAGS = -nologo -manifest -dynamicbase:no -debug -incremental:no -version:3.10 -swaprun:cd -swaprun:net setargv.obj\r
-!else\r
-SYS_LDFLAGS = -nologo -manifest -dynamicbase:no -release -incremental:no -version:3.10 -swaprun:cd -swaprun:net setargv.obj\r
-!endif\r
+SYS_LDFLAGS = -nologo -manifest -dynamicbase:no -incremental:no -version:3.10 -swaprun:cd -swaprun:net setargv.obj\r
\r
# see comments in allocate_heap in w32heap.c before changing any of the\r
# -stack, -heap, or -base settings.\r
-TEMACS_EXTRA_LINK = -stack:0x00800000 -heap:0x00100000 -base:0x01000000 -pdb:$(BLD)\temacs.pdb -machine:$(ARCH) $(SUBSYSTEM_CONSOLE) -entry:_start -map:$(BLD)\temacs.map $(EXTRA_LINK)\r
+!if "$(ARCH)" == "i386"\r
+TEMACS_EXTRA_LINK = -stack:0x00800000 -heap:0x00100000 -base:0x01000000 -pdb:$(BLD)\temacs.pdb -machine:x86 $(SUBSYSTEM_CONSOLE) -entry:_start -map:$(BLD)\temacs.map $(EXTRA_LINK)\r
+!elseif "$(ARCH)" == "AMD64"\r
+TEMACS_EXTRA_LINK = -stack:0x00800000 -heap:0x00100000 -base:0x400000000 -pdb:$(BLD)\temacs.pdb -machine:x64 $(SUBSYSTEM_CONSOLE) -entry:_start -map:$(BLD)\temacs.map $(EXTRA_LINK)\r
+!endif\r
\r
!ifdef NOOPT\r
OBJDIR = obj\r
ARCH_CFLAGS = -nologo -D_X86_=1 -c -Zl -Zp8 -W2 -Oi -Ot -Oy- -Ob2 -GF -Gy -Gd $(DEBUG_FLAG)\r
!endif\r
ARCH_LDFLAGS = $(SYS_LDFLAGS)\r
+EMACS_HEAPSIZE = 27\r
+EMACS_PURESIZE = 5000000\r
+EMACS_MANIFEST = emacs-x86.manifest\r
\r
!else\r
!if "$(ARCH)" == "mips"\r
ARCH_CFLAGS = -D_MIPS_=1 -c -W2 -Zi -Od -Gt0\r
ARCH_LDFLAGS = $(SYS_LDFLAGS)\r
+EMACS_HEAPSIZE = 27\r
+EMACS_PURESIZE = 5000000\r
+EMACS_MANIFEST = emacs-mips.manifest\r
\r
!else\r
!if "$(ARCH)" == "alpha"\r
ARCH_CFLAGS = -D_ALPHA_=1 -c -Ze -Zi -W2 -O1 -D__stdcall= -D__cdecl=\r
!endif\r
ARCH_LDFLAGS = $(SYS_LDFLAGS)\r
+EMACS_HEAPSIZE = 27\r
+EMACS_PURESIZE = 5000000\r
+EMACS_MANIFEST = emacs-alpha.manifest\r
\r
!else\r
!if "$(ARCH)" == "ppc"\r
# These flags are a guess...if they don't work, please send me mail.\r
-ARCH_CFLAGS = -D_PPC_=1 -c -Ze -Zi -W2 -Od\r
ARCH_LDFLAGS = $(SYS_LDFLAGS)\r
+EMACS_HEAPSIZE = 27\r
+EMACS_PURESIZE = 5000000\r
+EMACS_MANIFEST = emacs-ppc.manifest\r
+\r
+!else\r
+!if "$(ARCH)" == "AMD64"\r
+!ifdef NOOPT\r
+ARCH_CFLAGS = -nologo -D_AMD64_=1 -DWIN64 -D_WIN64 -DWIN32 -D_WIN32 -c -Zl -Zp8 -W2 -Od -Gd -Wp64 $(DEBUG_FLAG)\r
+!else\r
+ARCH_CFLAGS = -nologo -D_AMD64_=1 -DWIN64 -D_WIN64 -DWIN32 -D_WIN32 -c -Zl -Zp8 -W2 -O2x -GF -Gy -Gd $(DEBUG_FLAG)\r
+!endif\r
+ARCH_LDFLAGS = $(SYS_LDFLAGS) -machine:x64\r
+ARCH_RCFLAGS = -DWIN64\r
+EMACS_HEAPSIZE = 42\r
+EMACS_PURESIZE = 10000000\r
+EMACS_MANIFEST = emacs-x64.manifest\r
\r
!else\r
!ERROR Unknown architecture type "$(ARCH)".\r
!endif\r
!endif\r
!endif\r
+!endif\r
\r
LINK_FLAGS = $(ARCH_LDFLAGS) $(DEBUG_LINK) $(USER_LDFLAGS)\r
\r
.c{$(BLD)}.obj::\r
$(CC) $(CFLAGS) -Fo$(BLD)\ $<\r
!ENDIF\r
-\r
PIMAGE_NT_HEADERS
(__stdcall * pfnCheckSumMappedFile) (LPVOID BaseAddress,
- DWORD FileLength,
- LPDWORD HeaderSum,
- LPDWORD CheckSum);
+ DWORD_PTR FileLength,
+ PDWORD_PTR HeaderSum,
+ PDWORD_PTR CheckSum);
#undef min
#undef max
/* Return pointer to section header for section containing the given
relative virtual address. */
IMAGE_SECTION_HEADER *
-rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
+rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
some very old exes (eg. gzip dated Dec 1993). Since
w32_executable_type relies on this function to work reliably,
we need to cope with this. */
- DWORD real_size = max (section->SizeOfRawData,
+ DWORD_PTR real_size = max (section->SizeOfRawData,
section->Misc.VirtualSize);
if (rva >= section->VirtualAddress
&& rva < section->VirtualAddress + real_size)
/* Return pointer to section header for section containing the given
offset in its raw data area. */
IMAGE_SECTION_HEADER *
-offset_to_section (DWORD offset, IMAGE_NT_HEADERS * nt_header)
+offset_to_section (DWORD_PTR offset, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
/* Return offset to an object in dst, given offset in src. We assume
there is at least one section in both src and dst images, and that
the some sections may have been added to dst (after sections in src). */
-static DWORD
-relocate_offset (DWORD offset,
+static DWORD_PTR
+relocate_offset (DWORD_PTR offset,
IMAGE_NT_HEADERS * src_nt_header,
IMAGE_NT_HEADERS * dst_nt_header)
{
}
#define OFFSET_TO_RVA(offset, section) \
- (section->VirtualAddress + ((DWORD)(offset) - section->PointerToRawData))
+ (section->VirtualAddress + ((DWORD_PTR)(offset) - section->PointerToRawData))
#define RVA_TO_OFFSET(rva, section) \
- (section->PointerToRawData + ((DWORD)(rva) - section->VirtualAddress))
+ (section->PointerToRawData + ((DWORD_PTR)(rva) - section->VirtualAddress))
#define RVA_TO_SECTION_OFFSET(rva, section) \
- ((DWORD)(rva) - section->VirtualAddress)
+ ((DWORD_PTR)(rva) - section->VirtualAddress)
#define RVA_TO_PTR(var,section,filedata) \
((void *)(RVA_TO_OFFSET(var,section) + (filedata)->file_base))
/* Convert address in executing image to RVA. */
-#define PTR_TO_RVA(ptr) ((DWORD)(ptr) - (DWORD) GetModuleHandle (NULL))
+#define PTR_TO_RVA(ptr) ((DWORD_PTR)(ptr) - (DWORD_PTR) GetModuleHandle (NULL))
#define PTR_TO_OFFSET(ptr, pfile_data) \
((unsigned const char *)(ptr) - (pfile_data)->file_base)
#define OFFSET_TO_PTR(offset, pfile_data) \
- ((pfile_data)->file_base + (DWORD)(offset))
+ ((pfile_data)->file_base + (DWORD_PTR)(offset))
-#define ROUND_UP(p, align) (((DWORD)(p) + (align)-1) & ~((align)-1))
-#define ROUND_DOWN(p, align) ((DWORD)(p) & ~((align)-1))
+#define ROUND_UP(p, align) \
+ (((DWORD_PTR)(p) + (align)-1) & ~((DWORD_PTR)(align)-1))
+#define ROUND_DOWN(p, align) ((DWORD_PTR)(p) & ~((DWORD_PTR)(align)-1))
/* The MSVC prep program generates a ._xe file from .exe, where relevant
PIMAGE_SECTION_HEADER reloc_section;
PIMAGE_DATA_DIRECTORY import_dir;
PIMAGE_DATA_DIRECTORY reloc_dir;
- DWORD import_delta_rva;
- DWORD reloc_delta_rva;
- DWORD offset;
+ DWORD_PTR import_delta_rva;
+ DWORD_PTR reloc_delta_rva;
+ DWORD_PTR offset;
int i;
#define COPY_CHUNK(message, src, size) \
Note that dst is updated implicitly by each COPY_CHUNK. */
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
- nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
+ nt_header = (PIMAGE_NT_HEADERS) (((unsigned char *) dos_header) +
dos_header->e_lfanew);
section = IMAGE_FIRST_SECTION (nt_header);
dst = (unsigned char *) p_outfile->file_base;
COPY_CHUNK ("Copying DOS header...", dos_header,
- (DWORD) nt_header - (DWORD) dos_header);
+ (DWORD_PTR) nt_header - (DWORD_PTR) dos_header);
dst_nt_header = (PIMAGE_NT_HEADERS) dst;
COPY_CHUNK ("Copying NT header...", nt_header,
- (DWORD) section - (DWORD) nt_header);
+ (DWORD_PTR) section - (DWORD_PTR) nt_header);
dst_section = (PIMAGE_SECTION_HEADER) dst;
COPY_CHUNK ("Copying section table...", section,
nt_header->FileHeader.NumberOfSections * sizeof (*section));
#define ADJUST_IMPORT_RVA(var) \
do { \
if ((var) != 0) \
- *((DWORD *)&(var)) += import_delta_rva; \
+ *((DWORD_PTR *)&(var)) += import_delta_rva; \
} while (0)
dst_nt_header->OptionalHeader.SizeOfInitializedData = 0;
{
IMAGE_BASE_RELOCATION *relocs, *block, *start_block, *end_block;
- DWORD import_start = import_section->VirtualAddress + dst_nt_header->OptionalHeader.ImageBase;
- DWORD import_end = import_start + import_section->Misc.VirtualSize;
- DWORD len_import_relocs;
- DWORD len_remaining_relocs;
+ DWORD_PTR import_start = import_section->VirtualAddress + dst_nt_header->OptionalHeader.ImageBase;
+ DWORD_PTR import_end = import_start + import_section->Misc.VirtualSize;
+ DWORD_PTR len_import_relocs;
+ DWORD_PTR len_remaining_relocs;
int seen_high = 0;
WORD * high_word;
void * holder;
any; the profiler needs to be able to patch RVAs in the import
section itself. */
for (block = relocs, start_block = 0;
- (DWORD) block - (DWORD) relocs < reloc_dir->Size;
- block = (void *)((DWORD) block + block->SizeOfBlock))
+ (DWORD_PTR) block - (DWORD_PTR) relocs < reloc_dir->Size;
+ block = (void *)((DWORD_PTR) block + block->SizeOfBlock))
{
if (block->VirtualAddress >= import_section->VirtualAddress + import_section->Misc.VirtualSize)
{
}
if (start_block)
{
- len_import_relocs = (DWORD) end_block - (DWORD) start_block;
- len_remaining_relocs = (DWORD) relocs + reloc_dir->Size - (DWORD) end_block;
+ len_import_relocs = (DWORD_PTR) end_block - (DWORD_PTR) start_block;
+ len_remaining_relocs = (DWORD_PTR) relocs + reloc_dir->Size - (DWORD_PTR) end_block;
holder = malloc (len_import_relocs);
if (holder == 0)
abort ();
to the old import section location, and patching them to
reference the new location. */
for (block = relocs;
- (DWORD) block - (DWORD) relocs < reloc_dir->Size;
- block = (void *)((DWORD) block + block->SizeOfBlock))
+ (DWORD_PTR) block - (DWORD_PTR) relocs < reloc_dir->Size;
+ block = (void *)((DWORD_PTR) block + block->SizeOfBlock))
{
- DWORD page_rva = block->VirtualAddress;
- DWORD page_offset;
+ DWORD_PTR page_rva = block->VirtualAddress;
+ DWORD_PTR page_offset;
union {
WORD word;
- DWORD dword;
+ DWORD_PTR dword;
} * ploc;
WORD *fixup;
continue;
for (fixup = (WORD *) &block[1];
- (DWORD) fixup - (DWORD) block < block->SizeOfBlock;
+ (DWORD_PTR) fixup - (DWORD_PTR) block < block->SizeOfBlock;
fixup++)
{
page_offset = (*fixup) & 0xfff;
/* Patch up header fields; profiler is picky about this. */
{
HANDLE hImagehelp = LoadLibrary ("imagehlp.dll");
- DWORD headersum;
- DWORD checksum;
+ DWORD_PTR headersum;
+ DWORD_PTR checksum;
dos_header = (PIMAGE_DOS_HEADER) out_file.file_base;
nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
+2012-09-30 Fabrice Popineau <fabrice.popineau@supelec.fr>
+
+ Support x64 build on MS-Windows.
+ * w32term.h (SCROLL_BAR_PACK, SCROLL_BAR_UNPACK): Define for x64.
+ (SET_SCROLL_BAR_W32_WINDOW): Cast ID to intptr_t, for
+ compatibility with x64.
+
+ * w32term.c (w32_draw_underwave): Don't use GCC extensions for
+ defining an XRectangle structure.
+
+ * w32proc.c (RVA_TO_PTR, w32_executable_type): Fix pointer
+ arithmetics for compatibility with x64.
+
+ * w32menu.c (add_menu_item): Use UINT_PTR instead of UINT, for
+ compatibility with x64.
+
+ * w32heap.h: Adjust prototypes and declarations.
+
+ * w32heap.c (RVA_TO_PTR, allocate_heap, sbrk, init_heap)
+ (round_heap): Use DWORD_PTR, ptrdiff_t and size_t instead of
+ DWORD, long, and unsigned long, for compatibility with x64.
+ (allocate_heap) [_WIN64]: Reserve 32GB of memory.
+ (sbrk): Argument is now of type ptrdiff_t.
+
+ * w32fns.c (HMONITOR): Condition declaration on _WIN32_WINNT being
+ less than 0x0500.
+ (w32_msg_pump): Use WPARAM type for 'result'.
+
+ * w32.c (init_environment, get_emacs_configuration): Support AMD64
+ architecture.
+ (init_ntproc): Cast arguments of _open_osfhandle to intptr_t, for
+ compatibility with x64.
+
+ * vm-limit.c (lim_data): Now size_t.
+ (check_memory_limits): Adjust prototypes of real_morecore and
+ __morecore to receive argument of type ptrdiff_t. Use size_t for
+ five_percent and data_size.
+
+ * unexw32.c: Use DWORD_PTR instead of DWORD for file-scope
+ variables, for compatibility with x64.
+ (rva_to_section, offset_to_section, relocate_offset)
+ (OFFSET_TO_RVA, RVA_TO_OFFSET, RVA_TO_SECTION_OFFSET)
+ (PTR_TO_RVA, RVA_TO_PTR, OFFSET_TO_PTR, get_section_info)
+ (copy_executable_and_dump_data): Use DWORD_PTR instead of DWORD
+ for compatibility with x64.
+
+ * sysdep.c (STDERR_FILENO): Define if not already defined.
+
+ * ralloc.c (real_morecore): Argument type is now ptrdiff_t.
+ (__morecore): Argument type is now ptrdiff_t.
+ (ROUNDUP, MEM_ROUNDUP): Use size_t instead of 'unsigned long'.
+ (relinquish): Use ptrdiff_t type for 'excess'.
+ (r_alloc_sbrk): Argument type is now ptrdiff_t.
+
+ * makefile.w32-in (HEAPSIZE): Get value from EMACS_HEAPSIZE.
+ (bootstrap-temacs-CMD, bootstrap-temacs-SH): Use $(EMACS_PURESIZE)
+ instead of a literal number.
+
+ * gmalloc.c [WINDOWSNT]: Include w32heap.h.
+ (min): Define only if not already defined.
+
+ * frame.c (x_report_frame_params): Use EMACS_UINT for the return
+ value of FRAME_X_WINDOW, to fit a 64-bit pointer on 64-bit Windows
+ hosts.
+
+ * image.c (x_bitmap_pixmap): Return ptrdiff_t, not int, since
+ 'bitmaps' is a pointer.
+
+ * dispextern.h (x_bitmap_pixmap): Adjust prototype.
+
+ * alloc.c (gdb_make_enums_visible): Now conditional on __GNUC__.
+
2012-09-30 Paul Eggert <eggert@cs.ucla.edu>
file-attributes has a new optional arg FOLLOW-SYMLINKS.
#endif
#ifdef WINDOWSNT
#include "w32.h"
+#include "w32heap.h" /* for sbrk */
#endif
#ifdef DOUG_LEA_MALLOC
/* When compiled with GCC, GDB might say "No enum type named
pvec_type" if we don't have at least one symbol with that type, and
then xbacktrace could fail. Similarly for the other enums and
- their values. */
+ their values. Some non-GCC compilers don't like these constructs. */
+#ifdef __GNUC__
union
{
enum CHARTAB_SIZE_BITS CHARTAB_SIZE_BITS;
enum lsb_bits lsb_bits;
#endif
} const EXTERNALLY_VISIBLE gdb_make_enums_visible = {0};
+#endif /* __GNUC__ */
extern int x_bitmap_height (struct frame *, ptrdiff_t);
extern int x_bitmap_width (struct frame *, ptrdiff_t);
-extern int x_bitmap_pixmap (struct frame *, ptrdiff_t);
+extern ptrdiff_t x_bitmap_pixmap (struct frame *, ptrdiff_t);
extern void x_reference_bitmap (struct frame *, ptrdiff_t);
extern ptrdiff_t x_create_bitmap_from_data (struct frame *, char *,
unsigned int, unsigned int);
{
char buf[16];
Lisp_Object tem;
- unsigned long w;
+ EMACS_UINT w;
/* Represent negative positions (off the top or left screen edge)
in a way that Fmodify_frame_parameters will understand correctly. */
MS-Windows it returns a value whose type is HANDLE, which is
actually a pointer. Explicit casting avoids compiler
warnings. */
- w = (unsigned long) FRAME_X_WINDOW (f);
+ w = (EMACS_UINT) FRAME_X_WINDOW (f);
store_in_alist (alistptr, Qwindow_id,
- make_formatted_string (buf, "%lu", w));
+ make_formatted_string (buf, "%"pMu, w));
#ifdef HAVE_X_WINDOWS
#ifdef USE_X_TOOLKIT
/* Tooltip frame may not have this widget. */
if (FRAME_X_OUTPUT (f)->widget)
#endif
- w = (unsigned long) FRAME_OUTER_WINDOW (f);
+ w = (EMACS_UINT) FRAME_OUTER_WINDOW (f);
store_in_alist (alistptr, Qouter_window_id,
- make_formatted_string (buf, "%lu", w));
+ make_formatted_string (buf, "%"pMu, w));
#endif
store_in_alist (alistptr, Qicon_name, f->icon_name);
FRAME_SAMPLE_VISIBILITY (f);
#include <pthread.h>
#endif
+#ifdef WINDOWSNT
+#include <w32heap.h> /* for sbrk */
+#endif
+
#ifdef __cplusplus
extern "C"
{
The author may be reached (Email) at the address mike@ai.mit.edu,
or (US mail) as Mike Haertel c/o Free Software Foundation. */
+#ifndef min
#define min(A, B) ((A) < (B) ? (A) : (B))
+#endif
/* On Cygwin the dumped emacs may try to realloc storage allocated in
the static heap. We just malloc space in the new heap and copy the
}
#if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI)
-int
+ptrdiff_t
x_bitmap_pixmap (FRAME_PTR f, ptrdiff_t id)
{
/* HAVE_NTGUI needs the explicit cast here. */
- return (int) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
+ return (ptrdiff_t) FRAME_X_DISPLAY_INFO (f)->bitmaps[id - 1].pixmap;
}
#endif
EMACSLOADPATH=$(CURDIR)/../lisp
# Size in MBs of the static heap in temacs.exe.
-HEAPSIZE = 27
+HEAPSIZE = $(EMACS_HEAPSIZE)
LOCAL_FLAGS = -Demacs=1 -I../lib -I../nt/inc -DHAVE_NTGUI=1 $(EMACS_EXTRA_C_FLAGS)
# WARNING: Do NOT split the part inside $(ARGQUOTE)s into multiple lines as
# this can break with GNU Make 3.81 and later if sh.exe is used.
bootstrap-temacs-CMD:
- $(MAKE) $(MFLAGS) $(XMFLAGS) temacs CFLAGS=$(ARGQUOTE)$(ESC_CFLAGS) -DPURESIZE=5000000$(ARGQUOTE)
+ $(MAKE) $(MFLAGS) $(XMFLAGS) temacs CFLAGS=$(ARGQUOTE)$(ESC_CFLAGS) -DPURESIZE=$(EMACS_PURESIZE)$(ARGQUOTE)
bootstrap-temacs-SH:
- $(MAKE) $(MFLAGS) $(XMFLAGS) temacs CFLAGS=$(ARGQUOTE)$(CFLAGS) -DPURESIZE=5000000$(ARGQUOTE)
+ $(MAKE) $(MFLAGS) $(XMFLAGS) temacs CFLAGS=$(ARGQUOTE)$(CFLAGS) -DPURESIZE=$(EMACS_PURESIZE)$(ARGQUOTE)
bootstrap-temacs:
$(MAKE) $(MFLAGS) bootstrap-temacs-$(SHELLTYPE)
/* Declarations for working with the malloc, ralloc, and system breaks. */
/* Function to set the real break value. */
-POINTER (*real_morecore) (long int);
+POINTER (*real_morecore) (ptrdiff_t);
/* The break value, as seen by malloc. */
static POINTER virtual_break_value;
/* Macros for rounding. Note that rounding to any value is possible
by changing the definition of PAGE. */
#define PAGE (getpagesize ())
-#define ROUNDUP(size) (((unsigned long int) (size) + page_size - 1) \
- & ~(page_size - 1))
+#define ROUNDUP(size) (((size_t) (size) + page_size - 1) \
+ & ~((size_t)page_size - 1))
#define MEM_ALIGN sizeof (double)
-#define MEM_ROUNDUP(addr) (((unsigned long int)(addr) + MEM_ALIGN - 1) \
- & ~(MEM_ALIGN - 1))
+#define MEM_ROUNDUP(addr) (((size_t)(addr) + MEM_ALIGN - 1) \
+ & ~((size_t)MEM_ALIGN - 1))
/* The hook `malloc' uses for the function which gets more space
from the system. */
#ifndef SYSTEM_MALLOC
-extern POINTER (*__morecore) (long int);
+extern POINTER (*__morecore) (ptrdiff_t);
#endif
relinquish (void)
{
register heap_ptr h;
- long excess = 0;
+ ptrdiff_t excess = 0;
/* Add the amount of space beyond break_value
in all heaps which have extend beyond break_value at all. */
GNU malloc package. */
static POINTER
-r_alloc_sbrk (long int size)
+r_alloc_sbrk (ptrdiff_t size)
{
register bloc_ptr b;
POINTER address;
#ifdef WINDOWSNT
#define read sys_read
#define write sys_write
+#ifndef STDERR_FILENO
+#define STDERR_FILENO fileno(GetStdHandle(STD_ERROR_HANDLE))
+#endif
#include <windows.h>
#endif /* not WINDOWSNT */
/* Cached info about the .data section in the executable. */
PIMAGE_SECTION_HEADER data_section;
PCHAR data_start = 0;
-DWORD data_size = 0;
+DWORD_PTR data_size = 0;
/* Cached info about the .bss section in the executable. */
PIMAGE_SECTION_HEADER bss_section;
PCHAR bss_start = 0;
-DWORD bss_size = 0;
-DWORD extra_bss_size = 0;
+DWORD_PTR bss_size = 0;
+DWORD_PTR extra_bss_size = 0;
/* bss data that is static might be discontiguous from non-static. */
PIMAGE_SECTION_HEADER bss_section_static;
PCHAR bss_start_static = 0;
-DWORD bss_size_static = 0;
-DWORD extra_bss_size_static = 0;
+DWORD_PTR bss_size_static = 0;
+DWORD_PTR extra_bss_size_static = 0;
PIMAGE_SECTION_HEADER heap_section;
/* Return pointer to section header for section containing the given
relative virtual address. */
IMAGE_SECTION_HEADER *
-rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
+rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
some very old exes (eg. gzip dated Dec 1993). Since
w32_executable_type relies on this function to work reliably,
we need to cope with this. */
- DWORD real_size = max (section->SizeOfRawData,
+ DWORD_PTR real_size = max (section->SizeOfRawData,
section->Misc.VirtualSize);
if (rva >= section->VirtualAddress
&& rva < section->VirtualAddress + real_size)
/* Return pointer to section header for section containing the given
offset in its raw data area. */
IMAGE_SECTION_HEADER *
-offset_to_section (DWORD offset, IMAGE_NT_HEADERS * nt_header)
+offset_to_section (DWORD_PTR offset, IMAGE_NT_HEADERS * nt_header)
{
PIMAGE_SECTION_HEADER section;
int i;
/* Return offset to an object in dst, given offset in src. We assume
there is at least one section in both src and dst images, and that
the some sections may have been added to dst (after sections in src). */
-DWORD
-relocate_offset (DWORD offset,
+DWORD_PTR
+relocate_offset (DWORD_PTR offset,
IMAGE_NT_HEADERS * src_nt_header,
IMAGE_NT_HEADERS * dst_nt_header)
{
}
#define OFFSET_TO_RVA(offset, section) \
- (section->VirtualAddress + ((DWORD)(offset) - section->PointerToRawData))
+ (section->VirtualAddress + ((DWORD_PTR)(offset) - section->PointerToRawData))
#define RVA_TO_OFFSET(rva, section) \
- (section->PointerToRawData + ((DWORD)(rva) - section->VirtualAddress))
+ (section->PointerToRawData + ((DWORD_PTR)(rva) - section->VirtualAddress))
#define RVA_TO_SECTION_OFFSET(rva, section) \
- ((DWORD)(rva) - section->VirtualAddress)
+ ((DWORD_PTR)(rva) - section->VirtualAddress)
/* Convert address in executing image to RVA. */
-#define PTR_TO_RVA(ptr) ((DWORD)(ptr) - (DWORD) GetModuleHandle (NULL))
+#define PTR_TO_RVA(ptr) ((DWORD_PTR)(ptr) - (DWORD_PTR) GetModuleHandle (NULL))
#define RVA_TO_PTR(var,section,filedata) \
- ((void *)(RVA_TO_OFFSET (var,section) + (filedata).file_base))
+ ((DWORD_PTR)(RVA_TO_OFFSET (var,section) + (filedata).file_base))
#define PTR_TO_OFFSET(ptr, pfile_data) \
((unsigned char *)(ptr) - (pfile_data)->file_base)
#define OFFSET_TO_PTR(offset, pfile_data) \
- ((pfile_data)->file_base + (DWORD)(offset))
+ ((pfile_data)->file_base + (DWORD_PTR)(offset))
/* Flip through the executable and cache the info necessary for dumping. */
printf ("Unknown EXE header in %s...bailing.\n", p_infile->name);
exit (1);
}
- nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
+ nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
dos_header->e_lfanew);
if (nt_header == NULL)
{
PIMAGE_NT_HEADERS dst_nt_header;
PIMAGE_SECTION_HEADER section;
PIMAGE_SECTION_HEADER dst_section;
- DWORD offset;
+ DWORD_PTR offset;
int i;
int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
Note that dst is updated implicitly by each COPY_CHUNK. */
dos_header = (PIMAGE_DOS_HEADER) p_infile->file_base;
- nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
+ nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
dos_header->e_lfanew);
section = IMAGE_FIRST_SECTION (nt_header);
dst = (unsigned char *) p_outfile->file_base;
COPY_CHUNK ("Copying DOS header...", dos_header,
- (DWORD) nt_header - (DWORD) dos_header, be_verbose);
+ (DWORD_PTR) nt_header - (DWORD_PTR) dos_header, be_verbose);
dst_nt_header = (PIMAGE_NT_HEADERS) dst;
COPY_CHUNK ("Copying NT header...", nt_header,
- (DWORD) section - (DWORD) nt_header, be_verbose);
+ (DWORD_PTR) section - (DWORD_PTR) nt_header, be_verbose);
dst_section = (PIMAGE_SECTION_HEADER) dst;
COPY_CHUNK ("Copying section table...", section,
nt_header->FileHeader.NumberOfSections * sizeof (*section),
}
if (section == heap_section)
{
- DWORD heap_start = (DWORD) get_heap_start ();
- DWORD heap_size = get_committed_heap_size ();
+ DWORD_PTR heap_start = (DWORD_PTR) get_heap_start ();
+ DWORD_PTR heap_size = get_committed_heap_size ();
/* Dump the used portion of the predump heap, adjusting the
section's size to the appropriate size. */
static POINTER data_space_start;
/* Number of bytes of writable memory we can expect to be able to get. */
-static unsigned long lim_data;
+static size_t lim_data;
\f
#if defined (HAVE_GETRLIMIT) && defined (RLIMIT_AS)
static void
get_lim_data (void)
{
- extern unsigned long reserved_heap_size;
+ extern size_t reserved_heap_size;
lim_data = reserved_heap_size;
}
check_memory_limits (void)
{
#ifdef REL_ALLOC
- extern POINTER (*real_morecore) (long);
+ extern POINTER (*real_morecore) (ptrdiff_t);
#endif
- extern POINTER (*__morecore) (long);
+ extern POINTER (*__morecore) (ptrdiff_t);
register POINTER cp;
- unsigned long five_percent;
- unsigned long data_size;
+ size_t five_percent;
+ size_t data_size;
enum warnlevel new_warnlevel;
if (lim_data == 0)
/* FIXME: should use substring of get_emacs_configuration ().
But I don't think the Windows build supports alpha, mips etc
anymore, so have taken the easy option for now. */
- else if (p && xstrcasecmp (p, "\\i386") == 0)
+ else if (p && (xstrcasecmp (p, "\\i386") == 0
+ || xstrcasecmp (p, "\\AMD64") == 0))
{
*p = 0;
p = strrchr (modname, '\\');
case PROCESSOR_INTEL_386:
case PROCESSOR_INTEL_486:
case PROCESSOR_INTEL_PENTIUM:
+#ifdef _WIN64
+ arch = "amd64";
+#else
arch = "i386";
+#endif
+ break;
+#endif
+#ifdef PROCESSOR_AMD_X8664
+ case PROCESSOR_AMD_X8664:
+ arch = "amd64";
break;
#endif
fclose (stderr);
if (stdin_save != INVALID_HANDLE_VALUE)
- _open_osfhandle ((long) stdin_save, O_TEXT);
+ _open_osfhandle ((intptr_t) stdin_save, O_TEXT);
else
_open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
_fdopen (0, "r");
if (stdout_save != INVALID_HANDLE_VALUE)
- _open_osfhandle ((long) stdout_save, O_TEXT);
+ _open_osfhandle ((intptr_t) stdout_save, O_TEXT);
else
_open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
_fdopen (1, "w");
if (stderr_save != INVALID_HANDLE_VALUE)
- _open_osfhandle ((long) stderr_save, O_TEXT);
+ _open_osfhandle ((intptr_t) stderr_save, O_TEXT);
else
_open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
_fdopen (2, "w");
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
if (hnd == INVALID_HANDLE_VALUE)
error ("Could not open %s", port);
- fd = (int) _open_osfhandle ((int) hnd, 0);
+ fd = (int) _open_osfhandle ((intptr_t) hnd, 0);
if (fd == -1)
error ("Could not open %s", port);
};
/* Reportedly, MSVC does not have this in its headers. */
-#ifdef _MSC_VER
+#if defined (_MSC_VER) && _WIN32_WINNT < 0x0500
DECLARE_HANDLE(HMONITOR);
#endif
w32_msg_pump (deferred_msg * msg_buf)
{
MSG msg;
- int result;
+ WPARAM result;
HWND focus_window;
msh_mousewheel = RegisterWindowMessage (MSH_MOUSEWHEEL);
/* Reply is not expected. */
break;
case WM_EMACS_SETKEYBOARDLAYOUT:
- result = (int) ActivateKeyboardLayout ((HKL) msg.wParam, 0);
+ result = (WPARAM) ActivateKeyboardLayout ((HKL) msg.wParam, 0);
if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE,
result, 0))
emacs_abort ();
#include "w32heap.h"
#include "lisp.h" /* for VALMASK */
-#define RVA_TO_PTR(rva) ((unsigned char *)((DWORD)(rva) + (DWORD)GetModuleHandle (NULL)))
+#define RVA_TO_PTR(rva) ((unsigned char *)((DWORD_PTR)(rva) + (DWORD_PTR)GetModuleHandle (NULL)))
/* This gives us the page size and the size of the allocation unit on NT. */
SYSTEM_INFO sysinfo_cache;
/* This gives us version, build, and platform identification. */
OSVERSIONINFO osinfo_cache;
-unsigned long syspage_mask = 0;
+size_t syspage_mask = 0;
/* The major and minor versions of NT. */
int w32_major_version;
unsigned char *data_region_base = NULL;
unsigned char *data_region_end = NULL;
unsigned char *real_data_region_end = NULL;
-unsigned long reserved_heap_size = 0;
+size_t reserved_heap_size = 0;
/* The start of the data segment. */
unsigned char *
the preload heap section up to the usable address limit. Since GNU
malloc can handle gaps in the memory it gets from sbrk, we can
simply set the sbrk pointer to the base of the new heap region. */
- unsigned long base =
+ DWORD_PTR base =
ROUND_UP ((RVA_TO_PTR (preload_heap_section->VirtualAddress)
+ preload_heap_section->Misc.VirtualSize),
get_allocation_unit ());
- unsigned long end = 1 << VALBITS; /* 256MB */
+ DWORD_PTR end = ((unsigned __int64)1) << VALBITS; /* 256MB */
void *ptr = NULL;
while (!ptr && (base < end))
{
+#ifdef _WIN64
+ reserved_heap_size = min(end - base, 0x4000000000i64); /* Limit to 256Gb */
+#else
reserved_heap_size = end - base;
+#endif
ptr = VirtualAlloc ((void *) base,
get_reserved_heap_size (),
MEM_RESERVE,
static char *
allocate_heap (void)
{
- unsigned long size = 0x80000000; /* start by asking for 2GB */
+#ifdef _WIN64
+ size_t size = 0x4000000000i64; /* start by asking for 32GB */
+#else
+ size_t size = 0x80000000; /* start by asking for 2GB */
+#endif
void *ptr = NULL;
while (!ptr && size > 0x00100000)
be the address of the _start_ (not end) of the new block in case of
success, and zero (not -1) in case of failure. */
void *
-sbrk (unsigned long increment)
+sbrk (ptrdiff_t increment)
{
void *result;
- long size = (long) increment;
+ ptrdiff_t size = increment;
result = data_region_end;
/* If size is negative, shrink the heap by decommitting pages. */
if (size < 0)
{
- int new_size;
+ ptrdiff_t new_size;
unsigned char *new_data_region_end;
size = -size;
partial deallocation [cga]. */
new_data_region_end = (data_region_end - size);
new_data_region_end = (unsigned char *)
- ((long) (new_data_region_end + syspage_mask) & ~syspage_mask);
+ ((DWORD_PTR) (new_data_region_end + syspage_mask) & ~syspage_mask);
new_size = real_data_region_end - new_data_region_end;
real_data_region_end = new_data_region_end;
if (new_size > 0)
/* We really only commit full pages, so record where
the real end of committed memory is [cga]. */
real_data_region_end = (unsigned char *)
- ((long) (data_region_end + syspage_mask) & ~syspage_mask);
+ ((DWORD_PTR) (data_region_end + syspage_mask) & ~syspage_mask);
}
return result;
PIMAGE_NT_HEADERS nt_header;
dos_header = (PIMAGE_DOS_HEADER) RVA_TO_PTR (0);
- nt_header = (PIMAGE_NT_HEADERS) (((unsigned long) dos_header) +
+ nt_header = (PIMAGE_NT_HEADERS) (((DWORD_PTR) dos_header) +
dos_header->e_lfanew);
preload_heap_section = find_section ("EMHEAP", nt_header);
#if !USE_LSB_TAG
/* Ensure that the addresses don't use the upper tag bits since
the Lisp type goes there. */
- if (((unsigned long) data_region_base & ~VALMASK) != 0)
+ if (((DWORD_PTR) data_region_base & ~VALMASK) != 0)
{
printf ("Error: The heap was allocated in upper memory.\n");
exit (1);
/* Round the heap up to the given alignment. */
void
-round_heap (unsigned long align)
+round_heap (size_t align)
{
- unsigned long needs_to_be;
- unsigned long need_to_alloc;
+ DWORD_PTR needs_to_be;
+ DWORD_PTR need_to_alloc;
- needs_to_be = (unsigned long) ROUND_UP (get_heap_end (), align);
- need_to_alloc = needs_to_be - (unsigned long) get_heap_end ();
+ needs_to_be = (DWORD_PTR) ROUND_UP (get_heap_end (), align);
+ need_to_alloc = needs_to_be - (DWORD_PTR) get_heap_end ();
if (need_to_alloc)
sbrk (need_to_alloc);
#include <windows.h>
-#define ROUND_UP(p, align) (((DWORD)(p) + (align)-1) & ~((align)-1))
-#define ROUND_DOWN(p, align) ((DWORD)(p) & ~((align)-1))
+#define ROUND_UP(p, align) (((DWORD_PTR)(p) + (align)-1) & ~((DWORD_PTR)(align)-1))
+#define ROUND_DOWN(p, align) ((DWORD_PTR)(p) & ~((DWORD_PTR)(align)-1))
/*
* Heap related stuff.
extern unsigned char *get_data_start (void);
extern unsigned char *get_data_end (void);
-extern unsigned long reserved_heap_size;
+extern size_t reserved_heap_size;
extern SYSTEM_INFO sysinfo_cache;
extern OSVERSIONINFO osinfo_cache;
extern BOOL using_dynamic_heap;
extern int os_subtype;
/* Emulation of Unix sbrk(). */
-extern void *sbrk (unsigned long size);
+extern void *sbrk (ptrdiff_t size);
/* Initialize heap structures for sbrk on startup. */
extern void init_heap (void);
/* Round the heap to this size. */
-extern void round_heap (unsigned long size);
+extern void round_heap (size_t size);
/* Cache system info, e.g., the NT page size. */
extern void cache_system_info (void);
/* Return pointer to section header for section containing the given
relative virtual address. */
-IMAGE_SECTION_HEADER * rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header);
+IMAGE_SECTION_HEADER * rva_to_section (DWORD_PTR rva, IMAGE_NT_HEADERS * nt_header);
#endif /* NTHEAP_H_ */
utf8to16 (out_string, utf8_len, utf16_string);
return_value = unicode_append_menu (menu, fuFlags,
- item != NULL ? (UINT) item
- : (UINT) wv->call_data,
+ item != NULL ? (UINT_PTR) item
+ : (UINT_PTR) wv->call_data,
utf16_string);
if (!return_value)
{
of minor importance compared with menus not working at all. */
return_value =
AppendMenu (menu, fuFlags,
- item != NULL ? (UINT) item: (UINT) wv->call_data,
+ item != NULL ? (UINT_PTR) item: (UINT_PTR) wv->call_data,
out_string);
/* Don't use Unicode menus in future, unless this is Windows
NT or later, where a failure of AppendMenuW does NOT mean
return_value =
AppendMenu (menu,
fuFlags,
- item != NULL ? (UINT) item : (UINT) wv->call_data,
+ item != NULL ? (UINT_PTR) item : (UINT_PTR) wv->call_data,
out_string );
}
}
set_menu_item_info (menu,
- item != NULL ? (UINT) item : (UINT) wv->call_data,
+ item != NULL ? (UINT_PTR) item : (UINT_PTR) wv->call_data,
FALSE, &info);
}
}
#define RVA_TO_PTR(var,section,filedata) \
((void *)((section)->PointerToRawData \
- + ((DWORD)(var) - (section)->VirtualAddress) \
+ + ((DWORD_PTR)(var) - (section)->VirtualAddress) \
+ (filedata).file_base))
Lisp_Object Qhigh, Qlow;
if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
goto unwind;
- nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
+ nt_header = (PIMAGE_NT_HEADERS) ((unsigned char *) dos_header + dos_header->e_lfanew);
if ((char *) nt_header > (char *) dos_header + executable.size)
{
Lisp_Object w32_display_name_list;
-#ifndef GLYPHSET
+#if _WIN32_WINNT < 0x0500
/* Pre Windows 2000, this was not available, but define it here so
that Emacs compiled on such a platform will run on newer versions. */
/* Find and set clipping rectangle */
- wave_clip = (XRectangle){ x0, y0, width, wave_height };
+ wave_clip.x = x0;
+ wave_clip.y = y0;
+ wave_clip.width = width;
+ wave_clip.height = wave_height;
+
get_glyph_string_clip_rect (s, &w32_string_clip);
CONVERT_TO_XRECT (string_clip, w32_string_clip);
/* Turning a lisp vector value into a pointer to a struct scroll_bar. */
#define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec))
-
+#ifdef _WIN64
+/* Building a 64-bit C integer from two 32-bit lisp integers. */
+#define SCROLL_BAR_PACK(low, high) (XINT (high) << 32 | XINT (low))
+
+/* Setting two lisp integers to the low and high words of a 64-bit C int. */
+#define SCROLL_BAR_UNPACK(low, high, int64) \
+ (XSETINT ((low), ((DWORDLONG)(int64)) & 0xffffffff), \
+ XSETINT ((high), ((DWORDLONG)(int64) >> 32) & 0xffffffff))
+#else /* not _WIN64 */
/* Building a 32-bit C integer from two 16-bit lisp integers. */
#define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low))
#define SCROLL_BAR_UNPACK(low, high, int32) \
(XSETINT ((low), (int32) & 0xffff), \
XSETINT ((high), ((int32) >> 16) & 0xffff))
-
+#endif /* not _WIN64 */
/* Extract the window id of the scroll bar from a struct scroll_bar. */
#define SCROLL_BAR_W32_WINDOW(ptr) \
/* Store a window id in a struct scroll_bar. */
#define SET_SCROLL_BAR_W32_WINDOW(ptr, id) \
- (SCROLL_BAR_UNPACK ((ptr)->w32_window_low, (ptr)->w32_window_high, (int) id))
+ (SCROLL_BAR_UNPACK ((ptr)->w32_window_low, (ptr)->w32_window_high, (intptr_t) id))
/* Extract the X widget of the scroll bar from a struct scroll_bar. */
#define SCROLL_BAR_X_WIDGET(ptr) \