[Linux-ia64] Re: mozilla/ia64 patch

[Linux-ia64] Re: mozilla/ia64 patch

[Mike Shaver]

David Mosberger wrote:

> Below is a patch that makes mozilla work on IA-64 (native, not via
> IA-32 emulation).


I'll try and get this stuff into the tree before 0.9.1, including build 
mechanics for determining if we need to link against libffi, and 
verifying that it's present.

I'll also attach the libffi patch to the IA/64 xptcall bug, for the 
brave users who want to work with it.

Does anyone out there want to apply this patch to the 0.9 tree and do a 
build with a static libffi linkage?  I'd be overjoyed to put such a 
build on our site.

Thanks a million, David, for your work here.  You're a star.

Mike

[Linux-ia64] Re: mozilla/ia64 patch

[David Mosberger]

>>>>> On Tue, 15 May 2001 13:01:29 -0400, Bill Nottingham <notting@redhat.com> said:

  Bill> This part of the patch looks rather odd...  Bill

Oops, I goofed.  The patched contained a remnant of a botched diff
command.  You can either ignore the part starting with:

--- xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ffi.cpp	Mon May 14 18:03:08 2001
+++ xpcom/reflect/xptcall/src/md/unix/xptcstubs_ffi.cpp			Mon May 14 22:50:58 2001

up to the point where the next file starts:

--- /dev/null	Sat Mar 24 01:35:12 2001
+++ xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ffi.cpp	Mon May 14 18:03

or you can use the attached patch, which contains all mozilla changes
without the botched diff.

Sorry about that.

	--david

Index: nsprpub/pr/include/md/_linux.cfg
=================================RCS file: /cvsroot/mozilla/nsprpub/pr/include/md/_linux.cfg,v
retrieving revision 3.8.2.1
diff -u -r3.8.2.1 _linux.cfg
--- nsprpub/pr/include/md/nsprpub/pr/include/md/_linux.cfg	2000/07/29 01:01:57	3.8.2.1
+++ nsprpub/pr/include/md/nsprpub/pr/include/md/_linux.cfg	2001/05/15 06:26:04
@@ -120,6 +120,52 @@
 #define PR_BYTES_PER_WORD_LOG2  3
 #define PR_BYTES_PER_DWORD_LOG2 3
 
+#elif defined(__ia64__)
+
+#define IS_LITTLE_ENDIAN 1
+#undef  IS_BIG_ENDIAN
+#define IS_64
+
+#define PR_BYTES_PER_BYTE   1
+#define PR_BYTES_PER_SHORT  2
+#define PR_BYTES_PER_INT    4
+#define PR_BYTES_PER_INT64  8
+#define PR_BYTES_PER_LONG   8
+#define PR_BYTES_PER_FLOAT  4
+#define PR_BYTES_PER_DOUBLE 8
+#define PR_BYTES_PER_WORD   8
+#define PR_BYTES_PER_DWORD  8
+
+#define PR_BITS_PER_BYTE    8
+#define PR_BITS_PER_SHORT   16
+#define PR_BITS_PER_INT     32
+#define PR_BITS_PER_INT64   64
+#define PR_BITS_PER_LONG    64
+#define PR_BITS_PER_FLOAT   32
+#define PR_BITS_PER_DOUBLE  64
+#define PR_BITS_PER_WORD    64
+
+#define PR_BITS_PER_BYTE_LOG2   3
+#define PR_BITS_PER_SHORT_LOG2  4
+#define PR_BITS_PER_INT_LOG2    5
+#define PR_BITS_PER_INT64_LOG2  6
+#define PR_BITS_PER_LONG_LOG2   6
+#define PR_BITS_PER_FLOAT_LOG2  5
+#define PR_BITS_PER_DOUBLE_LOG2 6
+#define PR_BITS_PER_WORD_LOG2   6
+
+#define PR_ALIGN_OF_SHORT   2
+#define PR_ALIGN_OF_INT     4
+#define PR_ALIGN_OF_LONG    8
+#define PR_ALIGN_OF_INT64   8
+#define PR_ALIGN_OF_FLOAT   4
+#define PR_ALIGN_OF_DOUBLE  8
+#define PR_ALIGN_OF_POINTER 8
+#define PR_ALIGN_OF_WORD    8
+
+#define PR_BYTES_PER_WORD_LOG2  3
+#define PR_BYTES_PER_DWORD_LOG2 3
+
 #elif defined(__mc68000__)
 
 #undef  IS_LITTLE_ENDIAN
Index: nsprpub/pr/include/md/_linux.h
=================================RCS file: /cvsroot/mozilla/nsprpub/pr/include/md/_linux.h,v
retrieving revision 3.24.2.2
diff -u -r3.24.2.2 _linux.h
--- nsprpub/pr/include/md/nsprpub/pr/include/md/_linux.h	2000/05/02 01:47:17	3.24.2.2
+++ nsprpub/pr/include/md/nsprpub/pr/include/md/_linux.h	2001/05/15 06:26:04
@@ -31,6 +31,8 @@
 #define _PR_SI_ARCHITECTURE "ppc"
 #elif defined(__alpha)
 #define _PR_SI_ARCHITECTURE "alpha"
+#elif defined(__ia64__)
+#define _PR_SI_ARCHITECTURE "ia64"
 #elif defined(__mc68000__)
 #define _PR_SI_ARCHITECTURE "m68k"
 #elif defined(__sparc__)
@@ -78,7 +80,7 @@
 #endif
 #undef _PR_USE_POLL
 #define _PR_STAT_HAS_ONLY_ST_ATIME
-#if defined(__alpha)
+#if defined(__alpha) || defined(__ia64__)
 #define _PR_HAVE_LARGE_OFF_T
 #else
 #define _PR_NO_LARGE_FILES
@@ -141,6 +143,16 @@
 
 /* XXX not sure if this is correct, or maybe it should be 17? */
 #define PR_NUM_GCREGS 9
+
+#elif defined(__ia64)
+
+#define _MD_GET_SP(_t)		((long *)((_t)->md.context[0].__jmpbuf)[0])
+#define _MD_SET_FP(_t, val)
+#define _MD_GET_SP_PTR(_t)	&(_MD_GET_SP(_t))
+#define _MD_GET_FP_PTR(_t)	((void *) 0)
+#define _MD_SP_TYPE			long int
+
+#define PR_NUM_GCREGS		_JBLEN
 
 #elif defined(__mc68000__)
 /* m68k based Linux */
Index: xpcom/build/Makefile.in
=================================RCS file: /cvsroot/mozilla/xpcom/build/Makefile.in,v
retrieving revision 1.27
diff -u -r1.27 Makefile.in
--- xpcom/build/xpcom/build/Makefile.in	2001/04/28 19:45:51	1.27
+++ xpcom/build/xpcom/build/Makefile.in	2001/05/15 06:26:06
@@ -63,7 +63,9 @@
 		-I$(srcdir)/../proxy/src \
 		$(NULL)
 
+EXTRA_DSO_LDOPTS += -lffi	# XXX fix me
+
 ifdef MOZ_DEMANGLE_SYMBOLS
 EXTRA_DSO_LDOPTS += -liberty
 endif
--- /dev/null	Sat Mar 24 01:35:12 2001
+++ xpcom/reflect/xptcall/src/md/unix/xptcinvoke_ffi.cpp	Mon May 14 18:03:08 2001
@@ -0,0 +1,105 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * This file is Copyright (C) 2001 Hewlett-Packard Co.  All Rights
+ * Reserved.
+ *
+ * Contributor(s):
+ */
+
+/* Platform specific code to invoke XPCOM methods on native objects */
+
+/* contributed by David Mosberger <davidm@hpl.hp.com> */
+
+#include <alloca.h>
+#include <ffi.h>
+
+#include "xptcprivate.h"
+
+static void
+convert_args (PRUint32 n, nsXPTCVariant *params,
+              ffi_type **arg_types, void **args)
+{
+    ffi_type *t;
+    PRUint64 i;
+    void *v;
+#   define CVT(nst,ffit,field)						\
+	case nsXPTType::nst:						\
+		t = &ffit; v = &params[i].val.field; break;
+
+    for (i = 0; i < n; ++i) {
+        if (params[i].IsPtrData()) {
+            arg_types[i] = &ffi_type_pointer;
+            args[i] = &params[i].ptr;
+            continue;
+        }
+        switch (params[i].type) {
+            CVT(T_I8,		ffi_type_sint8,  i8);
+            CVT(T_I16,		ffi_type_sint16, i16);
+            CVT(T_I32,		ffi_type_sint32, i32);
+            CVT(T_I64,		ffi_type_sint64, i64);
+            CVT(T_U8,		ffi_type_uint8,  u8);
+            CVT(T_U16,		ffi_type_uint16, u16);
+            CVT(T_U32,		ffi_type_uint32, u32);
+            CVT(T_U64,		ffi_type_uint64, u64);
+            CVT(T_FLOAT,	ffi_type_float,  f);
+            CVT(T_DOUBLE,	ffi_type_double, u64);
+            CVT(T_BOOL,		ffi_type_sint32, b);
+            CVT(T_CHAR,		ffi_type_schar,  c);
+            CVT(T_WCHAR,	ffi_type_uint32, wc);
+            default:
+              // all the others are plain pointer types
+              t = &ffi_type_pointer;
+              v = &params[i].val.p;
+              break;
+        }
+        arg_types[i] = t;
+        args[i] = v;
+    }
+}
+
+XPTC_PUBLIC_API(nsresult)
+XPTC_InvokeByIndex(nsISupports* that, PRUint32 methodIndex,
+                   PRUint32 paramCount, nsXPTCVariant* params)
+{
+    struct vtable {
+        long offset;		/* offset to beginning of object */
+        unsigned long rtti;	/* address of run-time type info */
+        void (*methods[1]) ();	/* method table (variable length) */
+    } *vtable = *(struct vtable **) that;
+    ffi_type **arg_types;
+    void **args;
+    ffi_status status;
+    ffi_cif cif;
+    nsresult result;
+
+    arg_types = (ffi_type **) alloca((paramCount + 1) * sizeof (arg_types[0]));
+    args = (void **) alloca((paramCount + 1) * sizeof (args[0]));
+
+    arg_types[0] = &ffi_type_pointer;
+    args[0] = &that;
+    convert_args(paramCount, params, arg_types + 1, args + 1);
+    status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, paramCount + 1,
+                          &ffi_type_uint32, arg_types);
+    if (status != FFI_OK)
+        return NS_ERROR_INVALID_ARG;
+
+    ffi_call (&cif, vtable->methods[methodIndex], &result, args);
+    return result;
+}
--- /dev/null	Sat Mar 24 01:35:12 2001
+++ xpcom/reflect/xptcall/src/md/unix/xptcstubs_ffi.cpp	Mon May 14 22:50:58 2001
@@ -0,0 +1,173 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * This file is Copyright (C) 2001 Hewlett-Packard Co.  All Rights
+ * Reserved.
+ *
+ * Contributor(s):
+ */
+
+/* Implement shared vtbl methods.  This implementation should be
+   completely portable except for the mangled name of the stub
+   routines.  */
+
+/* contributed by David Mosberger <davidm@hpl.hp.com> */
+
+#include <alloca.h>
+#include <ffi.h>
+
+#include "xptcprivate.h"
+
+#define MANGLED_STUB_NAME(n)	Stub##n##__14nsXPTCStubBase
+
+static ffi_type *stub_common_arg_types[1] = { &ffi_type_pointer };
+static ffi_cif stub_common_cif;
+
+static void
+get_incoming_args (PRUint32 n, void *raw_args, const nsXPTMethodInfo* info,
+                   nsXPTCMiniVariant *p)
+{
+    ffi_type **arg_types, *t;
+    ffi_status status;
+    ffi_cif cif;
+    void **args;
+    PRUintn i;
+
+    /* create the cif (could be cached): */
+    arg_types = (ffi_type **) alloca ((n + 1) * sizeof (arg_types[0]));
+    arg_types[0] = &ffi_type_pointer;	/* implicit "this" argument */
+    for (i = 0; i < n; ++i) {
+        const nsXPTParamInfo& param = info->GetParam(i);
+        const nsXPTType& type = param.GetType();
+
+        if (param.IsOut() || !type.IsArithmetic()) {
+            arg_types[i + 1] = &ffi_type_pointer;
+            continue;
+        }
+        switch (type) {
+              case nsXPTType::T_I8 :	t = &ffi_type_sint8;  break;
+              case nsXPTType::T_I16:	t = &ffi_type_sint16; break;
+              case nsXPTType::T_I32:	t = &ffi_type_sint32; break;
+              case nsXPTType::T_I64:	t = &ffi_type_sint64; break;
+              case nsXPTType::T_U8 :	t = &ffi_type_uint8;  break;
+              case nsXPTType::T_U16:	t = &ffi_type_uint16; break;
+              case nsXPTType::T_U32:	t = &ffi_type_uint32; break;
+              case nsXPTType::T_U64:	t = &ffi_type_uint64; break;
+              case nsXPTType::T_FLOAT:	t = &ffi_type_float;  break;
+              case nsXPTType::T_DOUBLE:	t = &ffi_type_double; break;
+              case nsXPTType::T_BOOL:	t = &ffi_type_sint32; break;
+              case nsXPTType::T_CHAR:	t = &ffi_type_schar;  break;
+              case nsXPTType::T_WCHAR:	t = &ffi_type_uint32; break;
+
+              default:
+                NS_ASSERTION(0, "bad type");
+                break;
+        }
+        arg_types[i + 1] = t;
+    }
+    status = ffi_prep_cif(&cif, FFI_DEFAULT_ABI, n + 1, &ffi_type_uint32,
+                          arg_types);
+    NS_ASSERTION(status = FFI_OK, "status = FFI_OK");
+
+    /* extract the arguments: */
+    args = (void **) alloca((n + 1) * sizeof (args[0]));
+    ffi_prep_incoming_args(&cif, raw_args, args);
+
+    /* fill in the parameter vector: */
+
+    for (i = 0; i < n; ++i) {
+#       define CVT(nst,field,type)                                           \
+	  case FFI_TYPE_##nst: p[i].val.field = *(type *) args[i + 1]; break;
+        switch (arg_types[i + 1]->type) {
+          CVT(SINT8,   i8,  PRInt8);
+          CVT(SINT16,  i16, PRInt16);
+          CVT(SINT32,  i32, PRInt32);
+          CVT(SINT64,  i64, PRInt64);
+          CVT(UINT8,   u8,  PRUint8);
+          CVT(UINT16,  u16, PRUint16);
+          CVT(UINT32,  u32, PRUint32);
+          CVT(UINT64,  u64, PRUint64);
+          CVT(FLOAT,   u32, PRUint32);
+          CVT(DOUBLE,  u64, PRUint64);
+          CVT(POINTER, p,   void *);
+        default:
+          NS_ASSERTION(0, "unexpected ffi type");
+          break;
+        }
+    }
+}
+
+static void xptc_dispatch (ffi_cif *, void *, void **, void *, void *)
+     __asm__("xptc_dispatch") __attribute__((unused));
+
+static void
+xptc_dispatch (ffi_cif *common_cif, void *retp, void **common_args,
+               void *user_data, void *raw_args)
+{
+    uint32 method_index = (long) user_data;
+    nsIInterfaceInfo* iface_info = NULL;
+    const nsXPTMethodInfo* info;
+    nsXPTCMiniVariant *params;
+    nsXPTCStubBase *self;
+    PRUint8 param_count;
+
+    self = *(nsXPTCStubBase **) common_args[0];
+
+    NS_ASSERTION(self, "no self");
+
+    self->GetInterfaceInfo (&iface_info);
+    NS_ASSERTION(iface_info,"no interface info");
+
+    iface_info->GetMethodInfo (PRUint16(method_index), &info);
+    NS_ASSERTION(info,"no interface info");
+
+    param_count = info->GetParamCount ();
+    params = (nsXPTCMiniVariant *) alloca (param_count * sizeof (params[0]));
+    get_incoming_args (param_count, raw_args, info, params);
+
+    *(nsresult *) retp = self->CallMethod ((PRUint16)method_index, info,
+                                           params);
+
+    NS_RELEASE(iface_info);
+}
+
+static class init {
+  public:
+    init (void) {
+        ffi_prep_cif(&stub_common_cif, FFI_DEFAULT_ABI, 1, &ffi_type_pointer,
+                     stub_common_arg_types);
+    }
+} initializer;
+
+#define _STUB(name,arg)                                         \
+  FFI_STATIC_CLOSURE(name, stub_common_cif, xptc_dispatch, arg);
+
+/*
+ * nsresult nsXPTCStubBase::Stub##n()
+ */
+#define STUB_ENTRY(n)	_STUB(MANGLED_STUB_NAME(n), n)
+
+#define SENTINEL_ENTRY(n)                               \
+nsresult nsXPTCStubBase::Sentinel##n()                  \
+{                                                       \
+    NS_ASSERTION(0,"nsXPTCStubBase::Sentinel called");  \
+    return NS_ERROR_NOT_IMPLEMENTED;                    \
+}
+
+#include "xptcstubsdef.inc"