Back to index

lightning-sunbird  0.9+nobinonly
xptcinvoke_sparc_solaris.cpp
Go to the documentation of this file.
00001 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
00002 /* ***** BEGIN LICENSE BLOCK *****
00003  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
00004  *
00005  * The contents of this file are subject to the Mozilla Public License Version
00006  * 1.1 (the "License"); you may not use this file except in compliance with
00007  * the License. You may obtain a copy of the License at
00008  * http://www.mozilla.org/MPL/
00009  *
00010  * Software distributed under the License is distributed on an "AS IS" basis,
00011  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
00012  * for the specific language governing rights and limitations under the
00013  * License.
00014  *
00015  * The Original Code is mozilla.org code.
00016  *
00017  * The Initial Developer of the Original Code is
00018  * Netscape Communications Corporation.
00019  * Portions created by the Initial Developer are Copyright (C) 1998
00020  * the Initial Developer. All Rights Reserved.
00021  *
00022  * Contributor(s):
00023  *
00024  * Alternatively, the contents of this file may be used under the terms of
00025  * either of the GNU General Public License Version 2 or later (the "GPL"),
00026  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
00027  * in which case the provisions of the GPL or the LGPL are applicable instead
00028  * of those above. If you wish to allow use of your version of this file only
00029  * under the terms of either the GPL or the LGPL, and not to allow others to
00030  * use your version of this file under the terms of the MPL, indicate your
00031  * decision by deleting the provisions above and replace them with the notice
00032  * and other provisions required by the GPL or the LGPL. If you do not delete
00033  * the provisions above, a recipient may use your version of this file under
00034  * the terms of any one of the MPL, the GPL or the LGPL.
00035  *
00036  * ***** END LICENSE BLOCK ***** */
00037 
00038 /* Platform specific code to invoke XPCOM methods on native objects */
00039 
00040 #include "xptcprivate.h"
00041 
00042 /* solaris defines __sparc for workshop compilers and 
00043    linux defines __sparc__ */
00044 
00045 #if !defined(__sparc) && !defined(__sparc__)
00046 #error "This code is for Sparc only"
00047 #endif
00048 
00049 typedef unsigned nsXPCVariant;
00050 
00051 extern "C" PRUint32
00052 invoke_count_words(PRUint32 paramCount, nsXPTCVariant* s)
00053 {
00054     PRUint32 result = 0;
00055     for(PRUint32 i = 0; i < paramCount; i++, s++)
00056     {
00057         if(s->IsPtrData())
00058         {
00059             result++;
00060             continue;
00061         }
00062         switch(s->type)
00063         {
00064         case nsXPTType::T_I8     :
00065         case nsXPTType::T_I16    :
00066         case nsXPTType::T_I32    :
00067             result++;
00068             break;
00069         case nsXPTType::T_I64    :
00070             result+=2;
00071             break;
00072         case nsXPTType::T_U8     :
00073         case nsXPTType::T_U16    :
00074         case nsXPTType::T_U32    :
00075             result++;
00076             break;
00077         case nsXPTType::T_U64    :
00078             result+=2;
00079             break;
00080         case nsXPTType::T_FLOAT  :
00081             result++;
00082             break;
00083         case nsXPTType::T_DOUBLE :
00084             result+=2;
00085             break;
00086         case nsXPTType::T_BOOL   :
00087         case nsXPTType::T_CHAR   :
00088         case nsXPTType::T_WCHAR  :
00089             result++;
00090             break;
00091         default:
00092             // all the others are plain pointer types
00093             result++;
00094             break;
00095         }
00096     }
00097     // nuts, I know there's a cooler way of doing this, but it's late
00098     // now and it'll probably come to me in the morning.
00099     if (result & 0x3) result += 4 - (result & 0x3);     // ensure q-word alignment
00100     return result;
00101 }
00102 
00103 extern "C" PRUint32
00104 invoke_copy_to_stack(PRUint32* d, PRUint32 paramCount, nsXPTCVariant* s)
00105 {
00106 /*
00107     We need to copy the parameters for this function to locals and use them
00108     from there since the parameters occupy the same stack space as the stack
00109     we're trying to populate.
00110 */
00111     uint32 *l_d = d;
00112     nsXPTCVariant *l_s = s;
00113     uint32 l_paramCount = paramCount;
00114     uint32 regCount = 0;    // return the number of registers to load from the stack
00115 
00116     typedef struct {
00117         uint32 hi;
00118         uint32 lo;
00119     } DU;               // have to move 64 bit entities as 32 bit halves since
00120                         // stack slots are not guaranteed 16 byte aligned
00121 
00122     for(uint32 i = 0; i < l_paramCount; i++, l_d++, l_s++)
00123     {
00124        if (regCount < 5) regCount++;
00125         if(l_s->IsPtrData())
00126         {
00127             *((void**)l_d) = l_s->ptr;
00128             continue;
00129         }
00130         switch(l_s->type)
00131         {
00132         case nsXPTType::T_I8     : *((int32*)   l_d) = l_s->val.i8;          break;
00133         case nsXPTType::T_I16    : *((int32*)  l_d) = l_s->val.i16;         break;
00134         case nsXPTType::T_I32    : *((int32*)  l_d) = l_s->val.i32;         break;
00135         case nsXPTType::T_I64    : 
00136         case nsXPTType::T_U64    : 
00137         case nsXPTType::T_DOUBLE : *((uint32*) l_d++) = ((DU *)l_s)->hi;
00138                                if (regCount < 5) regCount++;
00139                                    *((uint32*) l_d) = ((DU *)l_s)->lo;
00140                                    break;
00141         case nsXPTType::T_U8     : *((uint32*)  l_d) = l_s->val.u8;          break;
00142         case nsXPTType::T_U16    : *((uint32*) l_d) = l_s->val.u16;         break;
00143         case nsXPTType::T_U32    : *((uint32*) l_d) = l_s->val.u32;         break;
00144         case nsXPTType::T_FLOAT  : *((float*)  l_d) = l_s->val.f;           break;
00145         case nsXPTType::T_BOOL   : *((PRBool*) l_d) = l_s->val.b;           break;
00146         case nsXPTType::T_CHAR   : *((uint32*)   l_d) = l_s->val.c;           break;
00147         case nsXPTType::T_WCHAR  : *((int32*)l_d) = l_s->val.wc;          break;
00148         default:
00149             // all the others are plain pointer types
00150             *((void**)l_d) = l_s->val.p;
00151             break;
00152         }
00153     }
00154     return regCount;
00155 }
00156