mirror/tp
1
0
Fork 0
mirror of https://github.com/zeldaret/tp synced 2026-08-21 22:41:04 -04:00
Code Issues Packages Projects Releases Wiki Activity

clean up dolphin files / work on some rels (#212)

Browse Source 
* d_a_alldie / d_a_tboxSw / d_a_tag_gstart / d_a_tag_hstop

* dolphin OS work / cleanup

* dolphin GX work / cleanup

* finish changing dolphin files to C

* more files into C

* match rest of MSL_C math functions

* more dolphin files converted to C

* remove asm

* d_bg_w work

* remove asm

* d_a_alink work / kytag14
This commit is contained in:
TakaRikka
2022-11-11 10:09:48 -08:00
committed by GitHub
parent f03b959831
commit 1114b13da8
665 changed files with 14863 additions and 30502 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libs/JSystem/J2DGraph/J2DTevs.cpp
+1 -1
View File
@@ -159,7 +159,7 @@ void J2DIndTevStage::load(u8 tevStage) {
/* 802EA098-802EA0CC 2E49D8 0034+00 0/0 1/1 0/0 .text load__12J2DIndTexMtxFUc */
void J2DIndTexMtx::load(u8 indTexMtx) {
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + indTexMtx), mIndTexMtxInfo.mMtx,
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + indTexMtx), (f32*)mIndTexMtxInfo.mMtx,
mIndTexMtxInfo.mScaleExp);
}
libs/JSystem/J3DGraphAnimator/J3DSkinDeform.cpp
-2
View File
@@ -49,14 +49,12 @@ extern "C" u8 sWorkArea_MtxReg__13J3DSkinDeform[2048 + 8 /* padding */];
//
SECTION_INIT void memcpy();
extern "C" void OSReport();
extern "C" void* __nwa__FUl();
extern "C" void* __nwa__FUli();
extern "C" void __dl__FPv();
extern "C" void J3DGQRSetup7__FUlUlUlUl();
extern "C" void J3DPSCalcInverseTranspose__FPA4_fPA3_f();
extern "C" void makeVcdVatCmd__8J3DShapeFv();
extern "C" void DCStoreRange();
extern "C" void __construct_new_array();
extern "C" void __save_gpr();
extern "C" void _savegpr_17();
libs/JSystem/J3DGraphBase/J3DGD.cpp
-6
View File
@@ -7,12 +7,6 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct _GXTlutSize {};
//
// Forward References:
//
libs/JSystem/J3DGraphBase/J3DMatBlock.cpp
-2
View File
@@ -484,7 +484,6 @@ extern "C" extern char const* const J3DMatBlock__stringBase0;
//
SECTION_INIT void memcpy();
extern "C" void OSReport();
extern "C" void patchTexNoAndTexCoordScale__11J3DTevBlockFv();
extern "C" void patch__10J3DPEBlockFv();
extern "C" void patch__11J3DTevBlockFv();
@@ -577,7 +576,6 @@ extern "C" void patchTexNo_PtrToIdx__FUlRCUs();
extern "C" void __as__16J3DIndTexMtxInfoFRC16J3DIndTexMtxInfo();
extern "C" void __as__10J3DFogInfoFRC10J3DFogInfo();
extern "C" void __as__15J3DNBTScaleInfoFRC15J3DNBTScaleInfo();
extern "C" void DCStoreRange();
extern "C" void GDOverflowed();
extern "C" void __destroy_arr();
extern "C" void _savegpr_24();
libs/JSystem/J3DGraphBase/J3DSys.cpp
+4 -4
View File
@@ -198,7 +198,7 @@ void J3DSys::drawInit() {
u8 i;
for (i = 0; i < 3; i++)
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + i), indTexMtx, 1);
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + i), (f32*)indTexMtx, 1);
GXSetChanMatColor(GX_COLOR0A0, j3dDefaultColInfo);
GXSetChanMatColor(GX_COLOR1A1, j3dDefaultColInfo);
@@ -380,9 +380,9 @@ void J3DSys::reinitIndStages() {
GXSetIndTexCoordScale(GX_INDTEXSTAGE1, GX_ITS_1, GX_ITS_1);
GXSetIndTexCoordScale(GX_INDTEXSTAGE2, GX_ITS_1, GX_ITS_1);
GXSetIndTexCoordScale(GX_INDTEXSTAGE3, GX_ITS_1, GX_ITS_1);
GXSetIndTexMtx(GX_ITM_0, IndMtx, 1);
GXSetIndTexMtx(GX_ITM_1, IndMtx, 1);
GXSetIndTexMtx(GX_ITM_2, IndMtx, 1);
GXSetIndTexMtx(GX_ITM_0, (f32*)IndMtx, 1);
GXSetIndTexMtx(GX_ITM_1, (f32*)IndMtx, 1);
GXSetIndTexMtx(GX_ITM_2, (f32*)IndMtx, 1);
}
/* 80310E3C-80310ED0 30B77C 0094+00 1/1 0/0 0/0 .text reinitPixelProc__6J3DSysFv */
libs/JSystem/J3DGraphBase/J3DVertex.cpp
+3 -3
View File
@@ -97,7 +97,7 @@ void J3DVertexBuffer::setArray() const {
s32 J3DVertexBuffer::copyLocalVtxPosArray(u32 flag) {
if (flag & 1) {
for (int i = 0; i < 2; i++) {
mVtxPosArray[i] = new (0x20) VertexPosition[mVtxData->getVtxNum()];
mVtxPosArray[i] = new (0x20) Vec[mVtxData->getVtxNum()];
if (mVtxPosArray[i] == NULL) {
return kJ3DError_Alloc;
@@ -109,7 +109,7 @@ s32 J3DVertexBuffer::copyLocalVtxPosArray(u32 flag) {
mVtxPosArray[0] = mVtxData->getVtxPosArray();
if (mVtxPosArray[1] == NULL) {
mVtxPosArray[1] = new (0x20) VertexPosition[mVtxData->getVtxNum()];
mVtxPosArray[1] = new (0x20) Vec[mVtxData->getVtxNum()];
if (mVtxPosArray[1] == NULL) {
return kJ3DError_Alloc;
}
@@ -209,7 +209,7 @@ s32 J3DVertexBuffer::allocTransformedVtxPosArray() {
for (int i = 0; i < 2; i++) {
if (i == 0 || mTransformedVtxPosArray[i] == NULL) {
mTransformedVtxPosArray[i] = new (0x20) VertexPosition[mVtxData->getVtxNum()];
mTransformedVtxPosArray[i] = new (0x20) Vec[mVtxData->getVtxNum()];
if (mTransformedVtxPosArray[i] == NULL)
return kJ3DError_Alloc;
}
libs/JSystem/JParticle/JPABaseShape.cpp
+1
View File
@@ -7,6 +7,7 @@
#include "JSystem/JParticle/JPAParticle.h"
#include "JSystem/JParticle/JPAResource.h"
#include "JSystem/JParticle/JPAResourceManager.h"
#include "dolphin/mtx/mtxvec.h"
#include "dol2asm.h"
#include "dolphin/types.h"
libs/JSystem/JParticle/JPAEmitter.cpp
+1
View File
@@ -10,6 +10,7 @@
#include "JSystem/JParticle/JPAResourceManager.h"
#include "dol2asm.h"
#include "dolphin/mtx/mtx.h"
#include "dolphin/mtx/mtxvec.h"
#include "dolphin/types.h"
//
libs/JSystem/JParticle/JPAParticle.cpp
+1
View File
@@ -4,6 +4,7 @@
//
#include "JSystem/JParticle/JPAParticle.h"
#include "dolphin/mtx/mtxvec.h"
#include "dol2asm.h"
#include "dolphin/types.h"
libs/JSystem/JParticle/JPAResource.cpp
+1
View File
@@ -9,6 +9,7 @@
#include "JSystem/JParticle/JPAParticle.h"
#include "dol2asm.h"
#include "dolphin/mtx/mtx.h"
#include "dolphin/mtx/mtxvec.h"
#include "dolphin/types.h"
//
libs/JSystem/JStudio/JStudio/functionvalue.cpp
+1
View File
@@ -4,6 +4,7 @@
//
#include "JSystem/JStudio/JStudio/functionvalue.h"
#include "JSystem/JUtility/JUTException.h"
#include "MSL_C/math.h"
#include "dol2asm.h"
#include "dolphin/types.h"
libs/JSystem/JStudio/JStudio/fvb.cpp
+1
View File
@@ -4,6 +4,7 @@
//
#include "JSystem/JStudio/JStudio/fvb.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "dolphin/types.h"
libs/JSystem/JStudio/JStudio/stb.cpp
+1
View File
@@ -1,4 +1,5 @@
#include "JSystem/JStudio/JStudio/stb.h"
#include "JSystem/JUtility/JUTException.h"
#include "dol2asm.h"
#include "dolphin/types.h"
libs/MSL_C/Makefile
+2
View File
@@ -121,6 +121,8 @@ LIBMSL_C_PPCEABI_BARE_H_A_O_FILES := \
LIBMSL_C_PPCEABI_BARE_H_A_CFLAGS := \
-O4,p \
-lang=c \
-fp_contract on \
-use_lmw_stmw on \
LIBMSL_C_PPCEABI_BARE_H_A_LDFLAGS := \
-nodefaults \
libs/MSL_C/Math/Double_precision/e_acos.c
+101 -84
View File
@@ -1,89 +1,106 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_acos
//
#include "MSL_C/Math/Double_precision/e_acos.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)e_acos.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/* __ieee754_acos(x)
* Method :
* acos(x) = pi/2 - asin(x)
* acos(-x) = pi/2 + asin(x)
* For |x|<=0.5
* acos(x) = pi/2 - (x + x*x^2*R(x^2)) (see asin.c)
* For x>0.5
* acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))
* = 2asin(sqrt((1-x)/2))
* = 2s + 2s*z*R(z) ...z=(1-x)/2, s=sqrt(z)
* = 2f + (2c + 2s*z*R(z))
* where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term
* for f so that f+c ~ sqrt(z).
* For x<-0.5
* acos(x) = pi - 2asin(sqrt((1-|x|)/2))
* = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)
*
* Special cases:
* if x is NaN, return x itself;
* if |x|>1, return NaN with invalid signal.
*
* Function needed: sqrt
*/
void __ieee754_acos();
#include "fdlibm.h"
#include "MSL_C/math.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
one= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
pi = 3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
void sqrt();
extern u32 __float_nan;
//
// Declarations:
//
/* ############################################################################################## */
/* 80456678-80456680 004C78 0008+00 1/1 0/0 0/0 .sdata2 @83 */
SECTION_SDATA2 static u8 lit_83[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 80456680-80456688 004C80 0008+00 1/1 0/0 0/0 .sdata2 @84 */
SECTION_SDATA2 static f64 lit_84 = 3.141592653589793;
/* 80456688-80456690 004C88 0008+00 1/1 0/0 0/0 .sdata2 @85 */
SECTION_SDATA2 static f64 lit_85 = 1.5707963267948966;
/* 80456690-80456698 004C90 0008+00 1/1 0/0 0/0 .sdata2 @86 */
SECTION_SDATA2 static f64 lit_86 = 6.123233995736766e-17;
/* 80456698-804566A0 004C98 0008+00 1/1 0/0 0/0 .sdata2 @87 */
SECTION_SDATA2 static f64 lit_87 = 1.0 / 6.0;
/* 804566A0-804566A8 004CA0 0008+00 1/1 0/0 0/0 .sdata2 @88 */
SECTION_SDATA2 static f64 lit_88 = -0.3255658186224009;
/* 804566A8-804566B0 004CA8 0008+00 1/1 0/0 0/0 .sdata2 @89 */
SECTION_SDATA2 static f64 lit_89 = 0.20121253213486293;
/* 804566B0-804566B8 004CB0 0008+00 1/1 0/0 0/0 .sdata2 @90 */
SECTION_SDATA2 static f64 lit_90 = -0.04005553450067941;
/* 804566B8-804566C0 004CB8 0008+00 1/1 0/0 0/0 .sdata2 @91 */
SECTION_SDATA2 static f64 lit_91 = 0.0007915349942898145;
/* 804566C0-804566C8 004CC0 0008+00 1/1 0/0 0/0 .sdata2 @92 */
SECTION_SDATA2 static f64 lit_92 = 3.479331075960212e-05;
/* 804566C8-804566D0 004CC8 0008+00 1/1 0/0 0/0 .sdata2 @93 */
SECTION_SDATA2 static f64 lit_93 = 1.0;
/* 804566D0-804566D8 004CD0 0008+00 1/1 0/0 0/0 .sdata2 @94 */
SECTION_SDATA2 static f64 lit_94 = -2.403394911734414;
/* 804566D8-804566E0 004CD8 0008+00 1/1 0/0 0/0 .sdata2 @95 */
SECTION_SDATA2 static f64 lit_95 = 2.0209457602335057;
/* 804566E0-804566E8 004CE0 0008+00 1/1 0/0 0/0 .sdata2 @96 */
SECTION_SDATA2 static f64 lit_96 = -0.6882839716054533;
/* 804566E8-804566F0 004CE8 0008+00 1/1 0/0 0/0 .sdata2 @97 */
SECTION_SDATA2 static f64 lit_97 = 0.07703815055590194;
/* 804566F0-804566F8 004CF0 0008+00 1/1 0/0 0/0 .sdata2 @98 */
SECTION_SDATA2 static f64 lit_98 = 0.5;
/* 804566F8-80456700 004CF8 0008+00 1/1 0/0 0/0 .sdata2 @99 */
SECTION_SDATA2 static f64 lit_99 = 2.0;
/* 80369274-803694B0 363BB4 023C+00 0/0 1/1 0/0 .text __ieee754_acos */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_acos() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_acos/__ieee754_acos.s"
}
#pragma pop
#ifdef __STDC__
double __ieee754_acos(double x)
#else
double __ieee754_acos(x)
double x;
#endif
{
double z,p,q,r,w,s,c,df;
int hx,ix;
hx = __HI(x);
ix = hx&0x7fffffff;
if(ix>=0x3ff00000) { /* |x| >= 1 */
if(((ix-0x3ff00000)|__LO(x))==0) { /* |x|==1 */
if(hx>0) return 0.0; /* acos(1) = 0 */
else return pi+2.0*pio2_lo; /* acos(-1)= pi */
}
return *__float_nan; /* acos(|x|>1) is NaN */
}
if(ix<0x3fe00000) { /* |x| < 0.5 */
if(ix<=0x3c600000) return pio2_hi+pio2_lo;/*if|x|<2**-57*/
z = x*x;
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
r = p/q;
return pio2_hi - (x - (pio2_lo-x*r));
} else if (hx<0) { /* x < -0.5 */
z = (one+x)*0.5;
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
s = sqrt(z);
r = p/q;
w = r*s-pio2_lo;
return pi - 2.0*(s+w);
} else { /* x > 0.5 */
z = (one-x)*0.5;
s = sqrt(z);
df = s;
__LO(df) = 0;
c = (z-df*df)/(s+df);
p = z*(pS0+z*(pS1+z*(pS2+z*(pS3+z*(pS4+z*pS5)))));
q = one+z*(qS1+z*(qS2+z*(qS3+z*qS4)));
r = p/q;
w = r*s+c;
return 2.0*(df+w);
}
}
libs/MSL_C/Math/Double_precision/e_asin.c
+112 -82
View File
@@ -1,87 +1,117 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_asin
//
#include "MSL_C/Math/Double_precision/e_asin.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)e_asin.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/* __ieee754_asin(x)
* Method :
* Since asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...
* we approximate asin(x) on [0,0.5] by
* asin(x) = x + x*x^2*R(x^2)
* where
* R(x^2) is a rational approximation of (asin(x)-x)/x^3
* and its remez error is bounded by
* |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75)
*
* For x in [0.5,1]
* asin(x) = pi/2-2*asin(sqrt((1-x)/2))
* Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;
* then for x>0.98
* asin(x) = pi/2 - 2*(s+s*z*R(z))
* = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)
* For x<=0.98, let pio4_hi = pio2_hi/2, then
* f = hi part of s;
* c = sqrt(z) - f = (z-f*f)/(s+f) ...f+c=sqrt(z)
* and
* asin(x) = pi/2 - 2*(s+s*z*R(z))
* = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)
* = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))
*
* Special cases:
* if x is NaN, return x itself;
* if |x|>1, return NaN with invalid signal.
*
*/
void __ieee754_asin();
#include "fdlibm.h"
#include "MSL_C/math.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
one
= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
huge = 1.000e+300, pio2_hi = 1.57079632679489655800e+00, /* 0x3FF921FB, 0x54442D18 */
pio2_lo = 6.12323399573676603587e-17, /* 0x3C91A626, 0x33145C07 */
pio4_hi = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */
/* coefficient for R(x^2) */
pS0 = 1.66666666666666657415e-01, /* 0x3FC55555, 0x55555555 */
pS1 = -3.25565818622400915405e-01, /* 0xBFD4D612, 0x03EB6F7D */
pS2 = 2.01212532134862925881e-01, /* 0x3FC9C155, 0x0E884455 */
pS3 = -4.00555345006794114027e-02, /* 0xBFA48228, 0xB5688F3B */
pS4 = 7.91534994289814532176e-04, /* 0x3F49EFE0, 0x7501B288 */
pS5 = 3.47933107596021167570e-05, /* 0x3F023DE1, 0x0DFDF709 */
qS1 = -2.40339491173441421878e+00, /* 0xC0033A27, 0x1C8A2D4B */
qS2 = 2.02094576023350569471e+00, /* 0x40002AE5, 0x9C598AC8 */
qS3 = -6.88283971605453293030e-01, /* 0xBFE6066C, 0x1B8D0159 */
qS4 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */
void sqrt();
extern u32 __float_nan;
//
// Declarations:
//
/* ############################################################################################## */
/* 80456700-80456708 004D00 0008+00 1/1 0/0 0/0 .sdata2 @94 */
SECTION_SDATA2 static f64 lit_94 = 1.5707963267948966;
/* 80456708-80456710 004D08 0008+00 1/1 0/0 0/0 .sdata2 @95 */
SECTION_SDATA2 static f64 lit_95 = 6.123233995736766e-17;
/* 80456710-80456718 004D10 0008+00 1/1 0/0 0/0 .sdata2 @96 */
SECTION_SDATA2 static f64 lit_96 = 1e+300;
/* 80456718-80456720 004D18 0008+00 1/1 0/0 0/0 .sdata2 @97 */
SECTION_SDATA2 static f64 lit_97 = 1.0;
/* 80456720-80456728 004D20 0008+00 1/1 0/0 0/0 .sdata2 @98 */
SECTION_SDATA2 static f64 lit_98 = 1.0 / 6.0;
/* 80456728-80456730 004D28 0008+00 1/1 0/0 0/0 .sdata2 @99 */
SECTION_SDATA2 static f64 lit_99 = -0.3255658186224009;
/* 80456730-80456738 004D30 0008+00 1/1 0/0 0/0 .sdata2 @100 */
SECTION_SDATA2 static f64 lit_100 = 0.20121253213486293;
/* 80456738-80456740 004D38 0008+00 1/1 0/0 0/0 .sdata2 @101 */
SECTION_SDATA2 static f64 lit_101 = -0.04005553450067941;
/* 80456740-80456748 004D40 0008+00 1/1 0/0 0/0 .sdata2 @102 */
SECTION_SDATA2 static f64 lit_102 = 0.0007915349942898145;
/* 80456748-80456750 004D48 0008+00 1/1 0/0 0/0 .sdata2 @103 */
SECTION_SDATA2 static f64 lit_103 = 3.479331075960212e-05;
/* 80456750-80456758 004D50 0008+00 1/1 0/0 0/0 .sdata2 @104 */
SECTION_SDATA2 static f64 lit_104 = -2.403394911734414;
/* 80456758-80456760 004D58 0008+00 1/1 0/0 0/0 .sdata2 @105 */
SECTION_SDATA2 static f64 lit_105 = 2.0209457602335057;
/* 80456760-80456768 004D60 0008+00 1/1 0/0 0/0 .sdata2 @106 */
SECTION_SDATA2 static f64 lit_106 = -0.6882839716054533;
/* 80456768-80456770 004D68 0008+00 1/1 0/0 0/0 .sdata2 @107 */
SECTION_SDATA2 static f64 lit_107 = 0.07703815055590194;
/* 80456770-80456778 004D70 0008+00 1/1 0/0 0/0 .sdata2 @108 */
SECTION_SDATA2 static f64 lit_108 = 0.5;
/* 80456778-80456780 004D78 0008+00 1/1 0/0 0/0 .sdata2 @109 */
SECTION_SDATA2 static f64 lit_109 = 2.0;
/* 80456780-80456788 004D80 0008+00 1/1 0/0 0/0 .sdata2 @110 */
SECTION_SDATA2 static f64 lit_110 = 0.7853981633974483;
/* 803694B0-803696E8 363DF0 0238+00 0/0 1/1 0/0 .text __ieee754_asin */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_asin() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_asin/__ieee754_asin.s"
}
#pragma pop
#ifdef __STDC__
double __ieee754_asin(double x)
#else
double __ieee754_asin(x) double x;
#endif
{
double t, w, p, q, c, r, s;
int hx, ix;
hx = __HI(x);
ix = hx & 0x7fffffff;
if (ix >= 0x3ff00000) { /* |x|>= 1 */
if (((ix - 0x3ff00000) | __LO(x)) == 0)
/* asin(1)=+-pi/2 with inexact */
return x * pio2_hi + x * pio2_lo;
return *__float_nan; /* asin(|x|>1) is NaN */
} else if (ix < 0x3fe00000) { /* |x|<0.5 */
if (ix < 0x3e400000) { /* if |x| < 2**-27 */
if (huge + x > one)
return x; /* return x with inexact if x!=0*/
} else
t = x * x;
p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5)))));
q = one + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4)));
w = p / q;
return x + x * w;
}
/* 1> |x|>= 0.5 */
w = one - fabs(x);
t = w * 0.5;
p = t * (pS0 + t * (pS1 + t * (pS2 + t * (pS3 + t * (pS4 + t * pS5)))));
q = one + t * (qS1 + t * (qS2 + t * (qS3 + t * qS4)));
s = sqrt(t);
if (ix >= 0x3FEF3333) { /* if |x| > 0.975 */
w = p / q;
t = pio2_hi - (2.0 * (s + s * w) - pio2_lo);
} else {
w = s;
__LO(w) = 0;
c = (t - w * w) / (s + w);
r = p / q;
p = 2.0 * s * r - (pio2_lo - 2.0 * c);
q = pio4_hi - 2.0 * w;
t = pio4_hi - (p - q);
}
if (hx > 0)
return t;
else
return -t;
}
libs/MSL_C/Math/Double_precision/e_atan2.c
+134 -61
View File
@@ -1,70 +1,143 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_atan2
//
#include "MSL_C/Math/Double_precision/e_atan2.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)e_atan2.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*
*/
//
// Forward References:
//
/* __ieee754_atan2(y,x)
* Method :
* 1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).
* 2. Reduce x to positive by (if x and y are unexceptional):
* ARG (x+iy) = arctan(y/x) ... if x > 0,
* ARG (x+iy) = pi - arctan[y/(-x)] ... if x < 0,
*
* Special cases:
*
* ATAN2((anything), NaN ) is NaN;
* ATAN2(NAN , (anything) ) is NaN;
* ATAN2(+-0, +(anything but NaN)) is +-0 ;
* ATAN2(+-0, -(anything but NaN)) is +-pi ;
* ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;
* ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;
* ATAN2(+-(anything but INF and NaN), -INF) is +-pi;
* ATAN2(+-INF,+INF ) is +-pi/4 ;
* ATAN2(+-INF,-INF ) is +-3pi/4;
* ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;
*
* Constants:
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
void __ieee754_atan2();
#include "fdlibm.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
tiny
= 1.0e-300,
zero = 0.0, pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */
pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */
pi = 3.1415926535897931160E+00, /* 0x400921FB, 0x54442D18 */
pi_lo = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
void atan();
#ifdef __STDC__
double __ieee754_atan2(double y, double x)
#else
double __ieee754_atan2(y, x) double y, x;
#endif
{
double z;
int k, m, hx, hy, ix, iy;
unsigned lx, ly;
//
// Declarations:
//
hx = __HI(x);
ix = hx & 0x7fffffff;
lx = __LO(x);
hy = __HI(y);
iy = hy & 0x7fffffff;
ly = __LO(y);
if (((ix | ((lx | -lx) >> 31)) > 0x7ff00000) || ((iy | ((ly | -ly) >> 31)) > 0x7ff00000)) /* x or y is NaN */
return x + y;
if ((hx - 0x3ff00000 | lx) == 0)
return atan(y); /* x=1.0 */
m = ((hy >> 31) & 1) | ((hx >> 30) & 2); /* 2*sign(x)+sign(y) */
/* ############################################################################################## */
/* 80456788-80456790 004D88 0008+00 1/1 0/0 0/0 .sdata2 @145 */
SECTION_SDATA2 static f64 lit_145 = 3.141592653589793;
/* when y = 0 */
if ((iy | ly) == 0) {
switch (m) {
case 0:
case 1:
return y; /* atan(+-0,+anything)=+-0 */
case 2:
return pi + tiny; /* atan(+0,-anything) = pi */
case 3:
return -pi - tiny; /* atan(-0,-anything) =-pi */
}
}
/* when x = 0 */
if ((ix | lx) == 0)
return (hy < 0) ? -pi_o_2 - tiny : pi_o_2 + tiny;
/* 80456790-80456798 004D90 0008+00 1/1 0/0 0/0 .sdata2 @146 */
SECTION_SDATA2 static f64 lit_146 = -3.141592653589793;
/* when x is INF */
if (ix == 0x7ff00000) {
if (iy == 0x7ff00000) {
switch (m) {
case 0:
return pi_o_4 + tiny; /* atan(+INF,+INF) */
case 1:
return -pi_o_4 - tiny; /* atan(-INF,+INF) */
case 2:
return 3.0 * pi_o_4 + tiny; /*atan(+INF,-INF)*/
case 3:
return -3.0 * pi_o_4 - tiny; /*atan(-INF,-INF)*/
}
} else {
switch (m) {
case 0:
return zero; /* atan(+...,+INF) */
case 1:
return -zero; /* atan(-...,+INF) */
case 2:
return pi + tiny; /* atan(+...,-INF) */
case 3:
return -pi - tiny; /* atan(-...,-INF) */
}
}
}
/* when y is INF */
if (iy == 0x7ff00000)
return (hy < 0) ? -pi_o_2 - tiny : pi_o_2 + tiny;
/* 80456798-804567A0 004D98 0008+00 1/1 0/0 0/0 .sdata2 @147 */
SECTION_SDATA2 static f64 lit_147 = -1.5707963267948966;
/* 804567A0-804567A8 004DA0 0008+00 1/1 0/0 0/0 .sdata2 @148 */
SECTION_SDATA2 static f64 lit_148 = 1.5707963267948966;
/* 804567A8-804567B0 004DA8 0008+00 1/1 0/0 0/0 .sdata2 @149 */
SECTION_SDATA2 static f64 lit_149 = 0.7853981633974483;
/* 804567B0-804567B8 004DB0 0008+00 1/1 0/0 0/0 .sdata2 @150 */
SECTION_SDATA2 static f64 lit_150 = -0.7853981633974483;
/* 804567B8-804567C0 004DB8 0008+00 1/1 0/0 0/0 .sdata2 @151 */
SECTION_SDATA2 static f64 lit_151 = 2.356194490192345;
/* 804567C0-804567C8 004DC0 0008+00 1/1 0/0 0/0 .sdata2 @152 */
SECTION_SDATA2 static f64 lit_152 = -2.356194490192345;
/* 804567C8-804567D0 004DC8 0008+00 1/1 0/0 0/0 .sdata2 @153 */
SECTION_SDATA2 static u8 lit_153[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 804567D0-804567D8 004DD0 0008+00 1/1 0/0 0/0 .sdata2 @154 */
SECTION_SDATA2 static f64 lit_154 = -0.0;
/* 804567D8-804567E0 004DD8 0008+00 1/1 0/0 0/0 .sdata2 @155 */
SECTION_SDATA2 static f64 lit_155 = 1.2246467991473532e-16;
/* 803696E8-80369978 364028 0290+00 0/0 1/1 0/0 .text __ieee754_atan2 */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_atan2() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_atan2/__ieee754_atan2.s"
}
#pragma pop
/* compute y/x */
k = (iy - ix) >> 20;
if (k > 60)
z = pi_o_2 + 0.5 * pi_lo; /* |y/x| > 2**60 */
else if (hx < 0 && k < -60)
z = 0.0; /* |y|/x < -2**60 */
else
z = atan(__fabs(y / x)); /* safe to do y/x */
switch (m) {
case 0:
return z; /* atan(+,+) */
case 1:
__HI(z) ^= 0x80000000;
return z; /* atan(-,+) */
case 2:
return pi - (z - pi_lo); /* atan(+,-) */
default: /* case 3 */
return (z - pi_lo) - pi; /* atan(-,-) */
}
}
libs/MSL_C/Math/Double_precision/e_exp.c
+153 -95
View File
@@ -1,104 +1,162 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_exp
//
#include "MSL_C/Math/Double_precision/e_exp.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)e_exp.c 1.6 04/04/22 */
/*
* ====================================================
* Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.
*
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/* __ieee754_exp(x)
* Returns the exponential of x.
*
* Method
* 1. Argument reduction:
* Reduce x to an r so that |r| <= 0.5*ln2 ~ 0.34658.
* Given x, find r and integer k such that
*
* x = k*ln2 + r, |r| <= 0.5*ln2.
*
* Here r will be represented as r = hi-lo for better
* accuracy.
*
* 2. Approximation of exp(r) by a special rational function on
* the interval [0,0.34658]:
* Write
* R(r**2) = r*(exp(r)+1)/(exp(r)-1) = 2 + r*r/6 - r**4/360 + ...
* We use a special Remes algorithm on [0,0.34658] to generate
* a polynomial of degree 5 to approximate R. The maximum error
* of this polynomial approximation is bounded by 2**-59. In
* other words,
* R(z) ~ 2.0 + P1*z + P2*z**2 + P3*z**3 + P4*z**4 + P5*z**5
* (where z=r*r, and the values of P1 to P5 are listed below)
* and
* | 5 | -59
* | 2.0+P1*z+...+P5*z - R(z) | <= 2
* | |
* The computation of exp(r) thus becomes
* 2*r
* exp(r) = 1 + -------
* R - r
* r*R1(r)
* = 1 + r + ----------- (for better accuracy)
* 2 - R1(r)
* where
* 2 4 10
* R1(r) = r - (P1*r + P2*r + ... + P5*r ).
*
* 3. Scale back to obtain exp(x):
* From step 1, we have
* exp(x) = 2^k * exp(r)
*
* Special cases:
* exp(INF) is INF, exp(NaN) is NaN;
* exp(-INF) is 0, and
* for finite argument, only exp(0)=1 is exact.
*
* Accuracy:
* according to an error analysis, the error is always less than
* 1 ulp (unit in the last place).
*
* Misc. info.
* For IEEE double
* if x > 7.09782712893383973096e+02 then exp(x) overflow
* if x < -7.45133219101941108420e+02 then exp(x) underflow
*
* Constants:
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
void __ieee754_exp();
#include "fdlibm.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
one = 1.0,
halF[2] = {0.5,-0.5,},
huge = 1.0e+300,
twom1000= 9.33263618503218878990e-302, /* 2**-1000=0x01700000,0*/
o_threshold= 7.09782712893383973096e+02, /* 0x40862E42, 0xFEFA39EF */
u_threshold= -7.45133219101941108420e+02, /* 0xc0874910, 0xD52D3051 */
ln2HI[2] ={ 6.93147180369123816490e-01, /* 0x3fe62e42, 0xfee00000 */
-6.93147180369123816490e-01,},/* 0xbfe62e42, 0xfee00000 */
ln2LO[2] ={ 1.90821492927058770002e-10, /* 0x3dea39ef, 0x35793c76 */
-1.90821492927058770002e-10,},/* 0xbdea39ef, 0x35793c76 */
invln2 = 1.44269504088896338700e+00, /* 0x3ff71547, 0x652b82fe */
P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
P5 = 4.13813679705723846039e-08; /* 0x3E663769, 0x72BEA4D0 */
//
// Declarations:
//
#ifdef __STDC__
double __ieee754_exp(double x) /* default IEEE double exp */
#else
double __ieee754_exp(x) /* default IEEE double exp */
double x;
#endif
{
double y, hi, lo, c, t;
int k, xsb;
unsigned hx;
/* ############################################################################################## */
/* 803A2340-803A2350 02E9A0 0010+00 1/1 0/0 0/0 .rodata halF */
SECTION_RODATA static u8 const halF[16] = {
0x3F, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
COMPILER_STRIP_GATE(0x803A2340, &halF);
hx = __HI(x); /* high word of x */
xsb = (hx >> 31) & 1; /* sign bit of x */
hx &= 0x7fffffff; /* high word of |x| */
/* 803A2350-803A2360 02E9B0 0010+00 0/1 0/0 0/0 .rodata ln2HI */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const ln2HI[16] = {
0x3F, 0xE6, 0x2E, 0x42, 0xFE, 0xE0, 0x00, 0x00, 0xBF, 0xE6, 0x2E, 0x42, 0xFE, 0xE0, 0x00, 0x00,
};
COMPILER_STRIP_GATE(0x803A2350, &ln2HI);
#pragma pop
/* filter out non-finite argument */
if (hx >= 0x40862E42) { /* if |x|>=709.78... */
if (hx >= 0x7ff00000) {
if (((hx & 0xfffff) | __LO(x)) != 0)
return x + x; /* NaN */
else
return (xsb == 0) ? x : 0.0; /* exp(+-inf)={inf,0} */
}
if (x > o_threshold)
return huge * huge; /* overflow */
if (x < u_threshold)
return twom1000 * twom1000; /* underflow */
}
/* 803A2360-803A2370 02E9C0 0010+00 0/1 0/0 0/0 .rodata ln2LO */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const ln2LO[16] = {
0x3D, 0xEA, 0x39, 0xEF, 0x35, 0x79, 0x3C, 0x76, 0xBD, 0xEA, 0x39, 0xEF, 0x35, 0x79, 0x3C, 0x76,
};
COMPILER_STRIP_GATE(0x803A2360, &ln2LO);
#pragma pop
/* argument reduction */
if (hx > 0x3fd62e42) { /* if |x| > 0.5 ln2 */
if (hx < 0x3FF0A2B2) { /* and |x| < 1.5 ln2 */
hi = x - ln2HI[xsb];
lo = ln2LO[xsb];
k = 1 - xsb - xsb;
} else {
k = (int)(invln2 * x + halF[xsb]);
t = k;
hi = x - t * ln2HI[0]; /* t*ln2HI is exact here */
lo = t * ln2LO[0];
}
x = hi - lo;
} else if (hx < 0x3e300000) { /* when |x|<2**-28 */
if (huge + x > one)
return one + x; /* trigger inexact */
} else
k = 0;
/* 804567E0-804567E8 004DE0 0008+00 1/1 0/0 0/0 .sdata2 @115 */
SECTION_SDATA2 static u8 lit_115[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 804567E8-804567F0 004DE8 0008+00 1/1 0/0 0/0 .sdata2 @116 */
SECTION_SDATA2 static f64 lit_116 = 709.782712893384;
/* 804567F0-804567F8 004DF0 0008+00 1/1 0/0 0/0 .sdata2 @117 */
SECTION_SDATA2 static f64 lit_117 = DOUBLE_INF;
/* 804567F8-80456800 004DF8 0008+00 1/1 0/0 0/0 .sdata2 @118 */
SECTION_SDATA2 static f64 lit_118 = -745.1332191019411;
/* 80456800-80456808 004E00 0008+00 1/1 0/0 0/0 .sdata2 @119 */
SECTION_SDATA2 static f64 lit_119 = 1.4426950408889634;
/* 80456808-80456810 004E08 0008+00 1/1 0/0 0/0 .sdata2 @120 */
SECTION_SDATA2 static f64 lit_120 = 1e+300;
/* 80456810-80456818 004E10 0008+00 1/1 0/0 0/0 .sdata2 @121 */
SECTION_SDATA2 static f64 lit_121 = 1.0;
/* 80456818-80456820 004E18 0008+00 1/1 0/0 0/0 .sdata2 @122 */
SECTION_SDATA2 static f64 lit_122 = 0.16666666666666602;
/* 80456820-80456828 004E20 0008+00 1/1 0/0 0/0 .sdata2 @123 */
SECTION_SDATA2 static f64 lit_123 = -0.0027777777777015593;
/* 80456828-80456830 004E28 0008+00 1/1 0/0 0/0 .sdata2 @124 */
SECTION_SDATA2 static f64 lit_124 = 6.613756321437934e-05;
/* 80456830-80456838 004E30 0008+00 1/1 0/0 0/0 .sdata2 @125 */
SECTION_SDATA2 static f64 lit_125 = -1.6533902205465252e-06;
/* 80456838-80456840 004E38 0008+00 1/1 0/0 0/0 .sdata2 @126 */
SECTION_SDATA2 static f64 lit_126 = 4.1381367970572385e-08;
/* 80456840-80456848 004E40 0008+00 1/1 0/0 0/0 .sdata2 @127 */
SECTION_SDATA2 static f64 lit_127 = 2.0;
/* 80456848-80456850 004E48 0008+00 1/1 0/0 0/0 .sdata2 @128 */
SECTION_SDATA2 static f64 lit_128 = 9.332636185032189e-302;
/* 80456850-80456858 004E50 0008+00 1/1 0/0 0/0 .sdata2 @131 */
SECTION_SDATA2 static f64 lit_131 = 4503601774854144.0 /* cast s32 to float */;
/* 80369978-80369B9C 3642B8 0224+00 0/0 1/1 0/0 .text __ieee754_exp */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_exp() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_exp/__ieee754_exp.s"
}
#pragma pop
/* x is now in primary range */
t = x * x;
c = x - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
if (k == 0)
return one - ((x * c) / (c - 2.0) - x);
else
y = one - ((lo - (x * c) / (2.0 - c)) - hi);
if (k >= -1021) {
__HI(y) += (k << 20); /* add k to y's exponent */
return y;
} else {
__HI(y) += ((k + 1000) << 20); /* add k to y's exponent */
return y * twom1000;
}
}
libs/MSL_C/Math/Double_precision/e_pow.c
+380 -138
View File
@@ -1,166 +1,408 @@
//========================================================================
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_pow
// e_pow.c
//
#include "MSL_C/Math/Double_precision/e_pow.h"
#include "dol2asm.h"
#include "dolphin/types.h"
// Part of the standard mathematical function library
//
// Forward References:
//========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
void __ieee754_pow();
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// External References:
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
void ldexp();
void sqrt();
extern u32 __float_nan;
extern u8 errno[4 + 4 /* padding */];
// You should have received a copy of the GNU General Public License along
// with eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// Declarations:
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): jlarmour
// Contributors:
// Date: 2001-07-20
// Purpose:
// Description:
// Usage:
//
//####DESCRIPTIONEND####
//
//========================================================================
/* ############################################################################################## */
/* 803A2380-803A2390 02E9E0 0010+00 1/1 0/0 0/0 .rodata bp */
SECTION_RODATA static u8 const bp[16] = {
0x3F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
COMPILER_STRIP_GATE(0x803A2380, &bp);
// CONFIGURATION
/* 803A2390-803A23A0 02E9F0 0010+00 0/1 0/0 0/0 .rodata dp_h */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const dp_h[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xE2, 0xB8, 0x03, 0x40, 0x00, 0x00, 0x00,
};
COMPILER_STRIP_GATE(0x803A2390, &dp_h);
#pragma pop
/* @(#)e_pow.c 5.1 93/09/24 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
/* 803A23A0-803A23B0 02EA00 0010+00 0/1 0/0 0/0 .rodata dp_l */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const dp_l[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x4C, 0xFD, 0xEB, 0x43, 0xCF, 0xD0, 0x06,
};
COMPILER_STRIP_GATE(0x803A23A0, &dp_l);
#pragma pop
/* __ieee754_pow(x,y) return x**y
*
* n
* Method: Let x = 2 * (1+f)
* 1. Compute and return log2(x) in two pieces:
* log2(x) = w1 + w2,
* where w1 has 53-24 = 29 bit trailing zeros.
* 2. Perform y*log2(x) = n+y' by simulating muti-precision
* arithmetic, where |y'|<=0.5.
* 3. Return x**y = 2**n*exp(y'*log2)
*
* Special cases:
* 1. (anything) ** 0 is 1
* 2. (anything) ** 1 is itself
* 3. (anything) ** NAN is NAN
* 4. NAN ** (anything except 0) is NAN
* 5. +-(|x| > 1) ** +INF is +INF
* 6. +-(|x| > 1) ** -INF is +0
* 7. +-(|x| < 1) ** +INF is +0
* 8. +-(|x| < 1) ** -INF is +INF
* 9. +-1 ** +-INF is NAN
* 10. +0 ** (+anything except 0, NAN) is +0
* 11. -0 ** (+anything except 0, NAN, odd integer) is +0
* 12. +0 ** (-anything except 0, NAN) is +INF
* 13. -0 ** (-anything except 0, NAN, odd integer) is +INF
* 14. -0 ** (odd integer) = -( +0 ** (odd integer) )
* 15. +INF ** (+anything except 0,NAN) is +INF
* 16. +INF ** (-anything except 0,NAN) is +0
* 17. -INF ** (anything) = -0 ** (-anything)
* 18. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)
* 19. (-anything except 0 and inf) ** (non-integer) is NAN
*
* Accuracy:
* pow(x,y) returns x**y nearly rounded. In particular
* pow(integer,integer)
* always returns the correct integer provided it is
* representable.
*
* Constants :
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
/* 80456858-80456860 004E58 0008+00 1/1 0/0 0/0 .sdata2 @336 */
SECTION_SDATA2 static f64 lit_336 = 1.0;
#include "types.h"
#include "errno.h"
#include "MSL_C/math.h"
#include "fdlibm.h"
/* 80456860-80456868 004E60 0008+00 1/1 0/0 0/0 .sdata2 @337 */
SECTION_SDATA2 static u8 lit_337[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
#ifndef _DOUBLE_IS_32BITS
/* 80456868-80456870 004E68 0008+00 1/1 0/0 0/0 .sdata2 @338 */
SECTION_SDATA2 static f64 lit_338 = DOUBLE_INF;
#ifdef __STDC__
static const double
#else
static double
#endif
bp[] = {1.0, 1.5,},
dp_h[] = { 0.0, 5.84962487220764160156e-01,}, /* 0x3FE2B803, 0x40000000 */
dp_l[] = { 0.0, 1.35003920212974897128e-08,}, /* 0x3E4CFDEB, 0x43CFD006 */
zero = 0.0,
one = 1.0,
two = 2.0,
two53 = 9007199254740992.0, /* 0x43400000, 0x00000000 */
huge = 1.0e300,
tiny = 1.0e-300,
/* poly coefs for (3/2)*(log(x)-2s-2/3*s**3 */
L1 = 5.99999999999994648725e-01, /* 0x3FE33333, 0x33333303 */
L2 = 4.28571428578550184252e-01, /* 0x3FDB6DB6, 0xDB6FABFF */
L3 = 3.33333329818377432918e-01, /* 0x3FD55555, 0x518F264D */
L4 = 2.72728123808534006489e-01, /* 0x3FD17460, 0xA91D4101 */
L5 = 2.30660745775561754067e-01, /* 0x3FCD864A, 0x93C9DB65 */
L6 = 2.06975017800338417784e-01, /* 0x3FCA7E28, 0x4A454EEF */
P1 = 1.66666666666666019037e-01, /* 0x3FC55555, 0x5555553E */
P2 = -2.77777777770155933842e-03, /* 0xBF66C16C, 0x16BEBD93 */
P3 = 6.61375632143793436117e-05, /* 0x3F11566A, 0xAF25DE2C */
P4 = -1.65339022054652515390e-06, /* 0xBEBBBD41, 0xC5D26BF1 */
P5 = 4.13813679705723846039e-08, /* 0x3E663769, 0x72BEA4D0 */
lg2 = 6.93147180559945286227e-01, /* 0x3FE62E42, 0xFEFA39EF */
lg2_h = 6.93147182464599609375e-01, /* 0x3FE62E43, 0x00000000 */
lg2_l = -1.90465429995776804525e-09, /* 0xBE205C61, 0x0CA86C39 */
ovt = 8.0085662595372944372e-0017, /* -(1024-log2(ovfl+.5ulp)) */
cp = 9.61796693925975554329e-01, /* 0x3FEEC709, 0xDC3A03FD =2/(3ln2) */
cp_h = 9.61796700954437255859e-01, /* 0x3FEEC709, 0xE0000000 =(float)cp */
cp_l = -7.02846165095275826516e-09, /* 0xBE3E2FE0, 0x145B01F5 =tail of cp_h*/
ivln2 = 1.44269504088896338700e+00, /* 0x3FF71547, 0x652B82FE =1/ln2 */
ivln2_h = 1.44269502162933349609e+00, /* 0x3FF71547, 0x60000000 =24b 1/ln2*/
ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/
/* 80456870-80456878 004E70 0008+00 1/1 0/0 0/0 .sdata2 @339 */
SECTION_SDATA2 static f64 lit_339 = 0.5;
#ifdef __STDC__
double __ieee754_pow(double x, double y)
#else
double __ieee754_pow(x, y) double x, y;
#endif
{
double z, ax, z_h, z_l, p_h, p_l;
double y1, t1, t2, r, s, t, u, v, w;
double qqq; // necessary temp
int i0, i1, i, j, k, yisint, n;
int hx, hy, ix, iy;
u32 lx, ly;
/* 80456878-80456880 004E78 0008+00 1/1 0/0 0/0 .sdata2 @340 */
SECTION_SDATA2 static f64 lit_340 = 1.0 / 3.0;
i0 = ((*(int*)&one) >> 29) ^ 1;
i1 = 1 - i0;
hx = __HI(x);
lx = __LO(x);
hy = __HI(y);
ly = __LO(y);
ix = hx & 0x7fffffff;
iy = hy & 0x7fffffff;
/* 80456880-80456888 004E80 0008+00 1/1 0/0 0/0 .sdata2 @341 */
SECTION_SDATA2 static f64 lit_341 = 0.25;
/* y==zero: x**0 = 1 */
if ((iy | ly) == 0)
return one;
/* 80456888-80456890 004E88 0008+00 1/1 0/0 0/0 .sdata2 @342 */
SECTION_SDATA2 static f64 lit_342 = 1.4426950216293335;
/* +-NaN return x+y */
if (ix > 0x7ff00000 || ((ix == 0x7ff00000) && (lx != 0)) || iy > 0x7ff00000 || ((iy == 0x7ff00000) && (ly != 0)))
return x + y;
/* 80456890-80456898 004E90 0008+00 1/1 0/0 0/0 .sdata2 @343 */
SECTION_SDATA2 static f64 lit_343 = 1.9259629911266175e-08;
/* determine if y is an odd int when x < 0
* yisint = 0 ... y is not an integer
* yisint = 1 ... y is an odd int
* yisint = 2 ... y is an even int
*/
yisint = 0;
if (hx < 0) {
if (iy >= 0x43400000)
yisint = 2; /* even integer y */
else if (iy >= 0x3ff00000) {
k = (iy >> 20) - 0x3ff; /* exponent */
if (k > 20) {
j = ly >> (52 - k);
if ((j << (52 - k)) == ly)
yisint = 2 - (j & 1);
} else if (ly == 0) {
j = iy >> (20 - k);
if ((j << (20 - k)) == iy)
yisint = 2 - (j & 1);
}
}
}
/* 80456898-804568A0 004E98 0008+00 1/1 0/0 0/0 .sdata2 @344 */
SECTION_SDATA2 static f64 lit_344 = 1.4426950408889634;
/* special value of y */
if (ly == 0) {
if (iy == 0x7ff00000) { /* y is +-inf */
if (((ix - 0x3ff00000) | lx) == 0)
return y - y; /* inf**+-1 is NaN */
else if (ix >= 0x3ff00000) /* (|x|>1)**+-inf = inf,0 */
return (hy >= 0) ? y : zero;
else /* (|x|<1)**-,+inf = inf,0 */
return (hy < 0) ? -y : zero;
}
if (iy == 0x3ff00000) { /* y is +-1 */
if (hy < 0)
return one / x;
else
return x;
}
if (hy == 0x40000000)
return x * x; /* y is 2 */
if (hy == 0x3fe00000) { /* y is 0.5 */
if (hx >= 0) /* x >= +0 */
return sqrt(x);
}
}
/* 804568A0-804568A8 004EA0 0008+00 1/1 0/0 0/0 .sdata2 @345 */
SECTION_SDATA2 static f64 lit_345 = 9007199254740992.0;
ax = __fabs(x);
qqq = ax; /*x is +-0,+-inf,+-1*/
/* special value of x */
if (lx == 0) {
if (ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000) {
z = qqq; /*x is +-0,+-inf,+-1*/
if (hy < 0)
z = one / z; /* z = (1/|x|) */
if (hx < 0) {
if (((ix - 0x3ff00000) | yisint) == 0) {
z = (z - z) / (z - z); /* (-1)**non-int is NaN */
} else if (yisint == 1)
z = -z; /* (x<0)**odd = -(|x|**odd) */
}
return z;
}
}
/* 804568A8-804568B0 004EA8 0008+00 1/1 0/0 0/0 .sdata2 @346 */
SECTION_SDATA2 static f64 lit_346 = 0.5999999999999946;
/* (x<0)**(non-int) is NaN */
/* CYGNUS LOCAL: This used to be
if((((hx>>31)+1)|yisint)==0) return (x-x)/(x-x);
but ANSI C says a right shift of a signed negative quantity is
implementation defined. */
/* 804568B0-804568B8 004EB0 0008+00 1/1 0/0 0/0 .sdata2 @347 */
SECTION_SDATA2 static f64 lit_347 = 0.4285714285785502;
if (((((int)hx >> 31) + 1) | yisint) == 0) {
errno = 33;
return (double)*__float_nan;
};
/* 804568B8-804568C0 004EB8 0008+00 1/1 0/0 0/0 .sdata2 @348 */
SECTION_SDATA2 static f64 lit_348 = 0.33333332981837743;
/* |y| is huge */
if (iy > 0x41e00000) { /* if |y| > 2**31 */
if (iy > 0x43f00000) { /* if |y| > 2**64, must o/uflow */
if (ix <= 0x3fefffff)
return (hy < 0) ? huge * huge : tiny * tiny;
if (ix >= 0x3ff00000)
return (hy > 0) ? huge * huge : tiny * tiny;
}
/* over/underflow if x is not close to one */
if (ix < 0x3fefffff)
return (hy < 0) ? huge * huge : tiny * tiny;
if (ix > 0x3ff00000)
return (hy > 0) ? huge * huge : tiny * tiny;
/* now |1-x| is tiny <= 2**-20, suffice to compute
log(x) by x-x^2/2+x^3/3-x^4/4 */
t = x - 1; /* t has 20 trailing zeros */
w = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25));
u = ivln2_h * t; /* ivln2_h has 21 sig. bits */
v = t * ivln2_l - w * ivln2;
t1 = u + v;
__LO(t1) = 0;
t2 = v - (t1 - u);
} else {
double s2, s_h, s_l, t_h, t_l;
n = 0;
/* take care subnormal number */
if (ix < 0x00100000) {
ax *= two53;
n -= 53;
ix = __HI(ax);
}
n += ((ix) >> 20) - 0x3ff;
j = ix & 0x000fffff;
/* determine interval */
ix = j | 0x3ff00000; /* normalize ix */
if (j <= 0x3988E)
k = 0; /* |x|<sqrt(3/2) */
else if (j < 0xBB67A)
k = 1; /* |x|<sqrt(3) */
else {
k = 0;
n += 1;
ix -= 0x00100000;
}
__HI(ax) = ix;
/* 804568C0-804568C8 004EC0 0008+00 1/1 0/0 0/0 .sdata2 @349 */
SECTION_SDATA2 static f64 lit_349 = 0.272728123808534;
/* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */
u = ax - bp[k]; /* bp[0]=1.0, bp[1]=1.5 */
v = one / (ax + bp[k]);
s = u * v;
s_h = s;
__LO(s_h) = 0;
/* t_h=ax+bp[k] High */
t_h = zero;
__HI(t_h) = ((ix >> 1) | 0x20000000) + 0x00080000 + (k << 18);
t_l = ax - (t_h - bp[k]);
s_l = v * ((u - s_h * t_h) - s_h * t_l);
/* compute log(ax) */
s2 = s * s;
r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));
r += s_l * (s_h + s);
s2 = s_h * s_h;
t_h = 3.0 + s2 + r;
__LO(t_h) = 0;
t_l = r - ((t_h - 3.0) - s2);
/* u+v = s*(1+...) */
u = s_h * t_h;
v = s_l * t_h + t_l * s;
/* 2/(3log2)*(s+...) */
p_h = u + v;
__LO(p_h) = 0;
p_l = v - (p_h - u);
z_h = cp_h * p_h; /* cp_h+cp_l = 2/(3*log2) */
z_l = cp_l * p_h + p_l * cp + dp_l[k];
/* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */
t = (double)n;
t1 = (((z_h + z_l) + dp_h[k]) + t);
__LO(t1) = 0;
t2 = z_l - (((t1 - t) - dp_h[k]) - z_h);
}
/* 804568C8-804568D0 004EC8 0008+00 1/1 0/0 0/0 .sdata2 @350 */
SECTION_SDATA2 static f64 lit_350 = 0.23066074577556175;
s = one; /* s (sign of result -ve**odd) = -1 else = 1 */
if (((((int)hx >> 31) + 1) | (yisint - 1)) == 0)
s = -one; /* (-ve)**(odd int) */
/* 804568D0-804568D8 004ED0 0008+00 1/1 0/0 0/0 .sdata2 @351 */
SECTION_SDATA2 static f64 lit_351 = 0.20697501780033842;
/* 804568D8-804568E0 004ED8 0008+00 1/1 0/0 0/0 .sdata2 @352 */
SECTION_SDATA2 static f64 lit_352 = 3.0;
/* 804568E0-804568E8 004EE0 0008+00 1/1 0/0 0/0 .sdata2 @353 */
SECTION_SDATA2 static f64 lit_353 = 0.9617967009544373;
/* 804568E8-804568F0 004EE8 0008+00 1/1 0/0 0/0 .sdata2 @354 */
SECTION_SDATA2 static f64 lit_354 = -7.028461650952758e-09;
/* 804568F0-804568F8 004EF0 0008+00 1/1 0/0 0/0 .sdata2 @355 */
SECTION_SDATA2 static f64 lit_355 = 0.9617966939259756;
/* 804568F8-80456900 004EF8 0008+00 1/1 0/0 0/0 .sdata2 @356 */
SECTION_SDATA2 static f64 lit_356 = -1.0;
/* 80456900-80456908 004F00 0008+00 1/1 0/0 0/0 .sdata2 @357 */
SECTION_SDATA2 static f64 lit_357 = 1e+300;
/* 80456908-80456910 004F08 0008+00 1/1 0/0 0/0 .sdata2 @358 */
SECTION_SDATA2 static f64 lit_358 = 8.008566259537294e-17;
/* 80456910-80456918 004F10 0008+00 1/1 0/0 0/0 .sdata2 @359 */
SECTION_SDATA2 static f64 lit_359 = 1e-300;
/* 80456918-80456920 004F18 0008+00 1/1 0/0 0/0 .sdata2 @360 */
SECTION_SDATA2 static f64 lit_360 = 0.6931471824645996;
/* 80456920-80456928 004F20 0008+00 1/1 0/0 0/0 .sdata2 @361 */
SECTION_SDATA2 static f64 lit_361 = 0.6931471805599453;
/* 80456928-80456930 004F28 0008+00 1/1 0/0 0/0 .sdata2 @362 */
SECTION_SDATA2 static f64 lit_362 = -1.904654299957768e-09;
/* 80456930-80456938 004F30 0008+00 1/1 0/0 0/0 .sdata2 @363 */
SECTION_SDATA2 static f64 lit_363 = 0.16666666666666602;
/* 80456938-80456940 004F38 0008+00 1/1 0/0 0/0 .sdata2 @364 */
SECTION_SDATA2 static f64 lit_364 = -0.0027777777777015593;
/* 80456940-80456948 004F40 0008+00 1/1 0/0 0/0 .sdata2 @365 */
SECTION_SDATA2 static f64 lit_365 = 6.613756321437934e-05;
/* 80456948-80456950 004F48 0008+00 1/1 0/0 0/0 .sdata2 @366 */
SECTION_SDATA2 static f64 lit_366 = -1.6533902205465252e-06;
/* 80456950-80456958 004F50 0008+00 1/1 0/0 0/0 .sdata2 @367 */
SECTION_SDATA2 static f64 lit_367 = 4.1381367970572385e-08;
/* 80456958-80456960 004F58 0008+00 1/1 0/0 0/0 .sdata2 @368 */
SECTION_SDATA2 static f64 lit_368 = 2.0;
/* 80456960-80456968 004F60 0008+00 1/1 0/0 0/0 .sdata2 @370 */
SECTION_SDATA2 static f64 lit_370 = 4503601774854144.0 /* cast s32 to float */;
/* 80369ED8-8036A708 364818 0830+00 0/0 1/1 0/0 .text __ieee754_pow */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_pow() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_pow/__ieee754_pow.s"
/* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */
y1 = y;
__LO(y1) = 0;
p_l = (y - y1) * t1 + y * t2;
p_h = y1 * t1;
z = p_l + p_h;
j = __HI(z);
i = __LO(z);
if (j >= 0x40900000) { /* z >= 1024 */
if (((j - 0x40900000) | i) != 0) /* if z > 1024 */
return s * huge * huge; /* overflow */
else {
if (p_l + ovt > z - p_h)
return s * huge * huge; /* overflow */
}
} else if ((j & 0x7fffffff) >= 0x4090cc00) { /* z <= -1075 */
if (((j - 0xc090cc00) | i) != 0) /* z < -1075 */
return s * tiny * tiny; /* underflow */
else {
if (p_l <= z - p_h)
return s * tiny * tiny; /* underflow */
}
}
/*
* compute 2**(p_h+p_l)
*/
i = j & 0x7fffffff;
k = (i >> 20) - 0x3ff;
n = 0;
if (i > 0x3fe00000) { /* if |z| > 0.5, set n = [z+0.5] */
n = j + (0x00100000 >> (k + 1));
k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */
t = zero;
__HI(t) = (n & ~(0x000fffff >> k));
n = ((n & 0x000fffff) | 0x00100000) >> (20 - k);
if (j < 0)
n = -n;
p_h -= t;
}
t = p_l + p_h;
__LO(t) = 0;
u = t * lg2_h;
v = (p_l - (t - p_h)) * lg2 + t * lg2_l;
z = u + v;
w = v - (z - u);
t = z * z;
t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));
r = (z * t1) / (t1 - two) - (w + z * w);
z = one - (r - z);
j = __HI(z);
j += (n << 20);
if ((j >> 20) <= 0)
z = ldexp(z, n); /* subnormal output */
else
__HI(z) += (n << 20);
return s * z;
}
#pragma pop
#endif /* defined(_DOUBLE_IS_32BITS) */
// EOF e_pow.c
libs/MSL_C/Math/Double_precision/e_rem_pio2.c
+171 -95
View File
@@ -1,105 +1,181 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_rem_pio2
//
#include "MSL_C/Math/Double_precision/e_rem_pio2.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)e_rem_pio2.c 1.4 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*
*/
//
// Forward References:
//
/* __ieee754_rem_pio2(x,y)
*
* return the remainder of x rem pi/2 in y[0]+y[1]
* use __kernel_rem_pio2()
*/
void __ieee754_rem_pio2();
#include "fdlibm.h"
#include "MSL_C/math.h"
//
// External References:
//
void __kernel_rem_pio2();
//
// Declarations:
//
/* ############################################################################################## */
/* 803A23B0-803A24B8 02EA10 0108+00 1/1 0/0 0/0 .rodata two_over_pi */
SECTION_RODATA static u8 const two_over_pi[264] = {
0x00, 0xA2, 0xF9, 0x83, 0x00, 0x6E, 0x4E, 0x44, 0x00, 0x15, 0x29, 0xFC, 0x00, 0x27, 0x57, 0xD1,
0x00, 0xF5, 0x34, 0xDD, 0x00, 0xC0, 0xDB, 0x62, 0x00, 0x95, 0x99, 0x3C, 0x00, 0x43, 0x90, 0x41,
0x00, 0xFE, 0x51, 0x63, 0x00, 0xAB, 0xDE, 0xBB, 0x00, 0xC5, 0x61, 0xB7, 0x00, 0x24, 0x6E, 0x3A,
0x00, 0x42, 0x4D, 0xD2, 0x00, 0xE0, 0x06, 0x49, 0x00, 0x2E, 0xEA, 0x09, 0x00, 0xD1, 0x92, 0x1C,
0x00, 0xFE, 0x1D, 0xEB, 0x00, 0x1C, 0xB1, 0x29, 0x00, 0xA7, 0x3E, 0xE8, 0x00, 0x82, 0x35, 0xF5,
0x00, 0x2E, 0xBB, 0x44, 0x00, 0x84, 0xE9, 0x9C, 0x00, 0x70, 0x26, 0xB4, 0x00, 0x5F, 0x7E, 0x41,
0x00, 0x39, 0x91, 0xD6, 0x00, 0x39, 0x83, 0x53, 0x00, 0x39, 0xF4, 0x9C, 0x00, 0x84, 0x5F, 0x8B,
0x00, 0xBD, 0xF9, 0x28, 0x00, 0x3B, 0x1F, 0xF8, 0x00, 0x97, 0xFF, 0xDE, 0x00, 0x05, 0x98, 0x0F,
0x00, 0xEF, 0x2F, 0x11, 0x00, 0x8B, 0x5A, 0x0A, 0x00, 0x6D, 0x1F, 0x6D, 0x00, 0x36, 0x7E, 0xCF,
0x00, 0x27, 0xCB, 0x09, 0x00, 0xB7, 0x4F, 0x46, 0x00, 0x3F, 0x66, 0x9E, 0x00, 0x5F, 0xEA, 0x2D,
0x00, 0x75, 0x27, 0xBA, 0x00, 0xC7, 0xEB, 0xE5, 0x00, 0xF1, 0x7B, 0x3D, 0x00, 0x07, 0x39, 0xF7,
0x00, 0x8A, 0x52, 0x92, 0x00, 0xEA, 0x6B, 0xFB, 0x00, 0x5F, 0xB1, 0x1F, 0x00, 0x8D, 0x5D, 0x08,
0x00, 0x56, 0x03, 0x30, 0x00, 0x46, 0xFC, 0x7B, 0x00, 0x6B, 0xAB, 0xF0, 0x00, 0xCF, 0xBC, 0x20,
0x00, 0x9A, 0xF4, 0x36, 0x00, 0x1D, 0xA9, 0xE3, 0x00, 0x91, 0x61, 0x5E, 0x00, 0xE6, 0x1B, 0x08,
0x00, 0x65, 0x99, 0x85, 0x00, 0x5F, 0x14, 0xA0, 0x00, 0x68, 0x40, 0x8D, 0x00, 0xFF, 0xD8, 0x80,
0x00, 0x4D, 0x73, 0x27, 0x00, 0x31, 0x06, 0x06, 0x00, 0x15, 0x56, 0xCA, 0x00, 0x73, 0xA8, 0xC9,
0x00, 0x60, 0xE2, 0x7B, 0x00, 0xC0, 0x8C, 0x6B,
};
COMPILER_STRIP_GATE(0x803A23B0, &two_over_pi);
/* 803A24B8-803A2538 02EB18 0080+00 1/1 0/0 0/0 .rodata npio2_hw */
SECTION_RODATA static u8 const npio2_hw[128] = {
0x3F, 0xF9, 0x21, 0xFB, 0x40, 0x09, 0x21, 0xFB, 0x40, 0x12, 0xD9, 0x7C, 0x40, 0x19, 0x21, 0xFB,
0x40, 0x1F, 0x6A, 0x7A, 0x40, 0x22, 0xD9, 0x7C, 0x40, 0x25, 0xFD, 0xBB, 0x40, 0x29, 0x21, 0xFB,
0x40, 0x2C, 0x46, 0x3A, 0x40, 0x2F, 0x6A, 0x7A, 0x40, 0x31, 0x47, 0x5C, 0x40, 0x32, 0xD9, 0x7C,
0x40, 0x34, 0x6B, 0x9C, 0x40, 0x35, 0xFD, 0xBB, 0x40, 0x37, 0x8F, 0xDB, 0x40, 0x39, 0x21, 0xFB,
0x40, 0x3A, 0xB4, 0x1B, 0x40, 0x3C, 0x46, 0x3A, 0x40, 0x3D, 0xD8, 0x5A, 0x40, 0x3F, 0x6A, 0x7A,
0x40, 0x40, 0x7E, 0x4C, 0x40, 0x41, 0x47, 0x5C, 0x40, 0x42, 0x10, 0x6C, 0x40, 0x42, 0xD9, 0x7C,
0x40, 0x43, 0xA2, 0x8C, 0x40, 0x44, 0x6B, 0x9C, 0x40, 0x45, 0x34, 0xAC, 0x40, 0x45, 0xFD, 0xBB,
0x40, 0x46, 0xC6, 0xCB, 0x40, 0x47, 0x8F, 0xDB, 0x40, 0x48, 0x58, 0xEB, 0x40, 0x49, 0x21, 0xFB,
};
COMPILER_STRIP_GATE(0x803A24B8, &npio2_hw);
/* 80456968-80456970 004F68 0008+00 1/1 0/0 0/0 .sdata2 @145 */
SECTION_SDATA2 static u8 lit_145[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
/*
* Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi
*/
#ifdef __STDC__
static const int two_over_pi[] = {
#else
static int two_over_pi[] = {
#endif
0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, 0x95993C, 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7,
0x246E3A, 0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129, 0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C,
0x7026B4, 0x5F7E41, 0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8, 0x97FFDE, 0x05980F, 0xEF2F11,
0x8B5A0A, 0x6D1F6D, 0x367ECF, 0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5, 0xF17B3D, 0x0739F7,
0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08, 0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, 0x91615E,
0xE61B08, 0x659985, 0x5F14A0, 0x68408D, 0xFFD880, 0x4D7327, 0x310606, 0x1556CA, 0x73A8C9, 0x60E27B, 0xC08C6B,
};
/* 80456970-80456978 004F70 0008+00 1/1 0/0 0/0 .sdata2 @146 */
SECTION_SDATA2 static f64 lit_146 = 1.5707963267341256;
#ifdef __STDC__
static const int npio2_hw[] = {
#else
static int npio2_hw[] = {
#endif
0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C, 0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C,
0x4032D97C, 0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A, 0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C,
0x4042106C, 0x4042D97C, 0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB, 0x404858EB, 0x404921FB,
};
/* 80456978-80456980 004F78 0008+00 1/1 0/0 0/0 .sdata2 @147 */
SECTION_SDATA2 static f64 lit_147 = 6.077100506506192e-11;
/*
* invpio2: 53 bits of 2/pi
* pio2_1: first 33 bit of pi/2
* pio2_1t: pi/2 - pio2_1
* pio2_2: second 33 bit of pi/2
* pio2_2t: pi/2 - (pio2_1+pio2_2)
* pio2_3: third 33 bit of pi/2
* pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3)
*/
/* 80456980-80456988 004F80 0008+00 1/1 0/0 0/0 .sdata2 @148 */
SECTION_SDATA2 static f64 lit_148 = 6.077100506303966e-11;
#ifdef __STDC__
static const double
#else
static double
#endif
zero
= 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */
half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */
pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */
pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */
pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */
pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */
pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */
pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
/* 80456988-80456990 004F88 0008+00 1/1 0/0 0/0 .sdata2 @149 */
SECTION_SDATA2 static f64 lit_149 = 2.0222662487959506e-21;
#ifdef __STDC__
int __ieee754_rem_pio2(double x, double* y)
#else
int __ieee754_rem_pio2(x, y) double x, y[];
#endif
{
double z, w, t, r, fn;
double tx[3];
int e0, i, j, nx, n, ix, hx;
/* 80456990-80456998 004F90 0008+00 1/1 0/0 0/0 .sdata2 @150 */
SECTION_SDATA2 static f64 lit_150 = 0.5;
/* 80456998-804569A0 004F98 0008+00 1/1 0/0 0/0 .sdata2 @151 */
SECTION_SDATA2 static f64 lit_151 = 0.6366197723675814;
/* 804569A0-804569A8 004FA0 0008+00 1/1 0/0 0/0 .sdata2 @152 */
SECTION_SDATA2 static f64 lit_152 = 2.0222662487111665e-21;
/* 804569A8-804569B0 004FA8 0008+00 1/1 0/0 0/0 .sdata2 @153 */
SECTION_SDATA2 static f64 lit_153 = 8.4784276603689e-32;
/* 804569B0-804569B8 004FB0 0008+00 1/1 0/0 0/0 .sdata2 @154 */
SECTION_SDATA2 static f64 lit_154 = 16777216.0;
/* 804569B8-804569C0 004FB8 0008+00 1/1 0/0 0/0 .sdata2 @157 */
SECTION_SDATA2 static f64 lit_157 = 4503601774854144.0 /* cast s32 to float */;
/* 8036A708-8036AAA8 365048 03A0+00 0/0 3/3 0/0 .text __ieee754_rem_pio2 */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_rem_pio2() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_rem_pio2/__ieee754_rem_pio2.s"
}
#pragma pop
hx = __HI(x); /* high word of x */
ix = hx & 0x7fffffff;
if (ix <= 0x3fe921fb) /* |x| ~<= pi/4 , no need for reduction */
{
y[0] = x;
y[1] = 0;
return 0;
}
if (ix < 0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */
if (hx > 0) {
z = x - pio2_1;
if (ix != 0x3ff921fb) { /* 33+53 bit pi is good enough */
y[0] = z - pio2_1t;
y[1] = (z - y[0]) - pio2_1t;
} else { /* near pi/2, use 33+33+53 bit pi */
z -= pio2_2;
y[0] = z - pio2_2t;
y[1] = (z - y[0]) - pio2_2t;
}
return 1;
} else { /* negative x */
z = x + pio2_1;
if (ix != 0x3ff921fb) { /* 33+53 bit pi is good enough */
y[0] = z + pio2_1t;
y[1] = (z - y[0]) + pio2_1t;
} else { /* near pi/2, use 33+33+53 bit pi */
z += pio2_2;
y[0] = z + pio2_2t;
y[1] = (z - y[0]) + pio2_2t;
}
return -1;
}
}
if (ix <= 0x413921fb) { /* |x| ~<= 2^19*(pi/2), medium size */
t = fabs(x);
n = (int)(t * invpio2 + half);
fn = (double)n;
r = t - fn * pio2_1;
w = fn * pio2_1t; /* 1st round good to 85 bit */
if (n < 32 && ix != npio2_hw[n - 1]) {
y[0] = r - w; /* quick check no cancellation */
} else {
j = ix >> 20;
y[0] = r - w;
i = j - (((__HI(y[0])) >> 20) & 0x7ff);
if (i > 16) { /* 2nd iteration needed, good to 118 */
t = r;
r = t - fn * pio2_2;
w = fn * pio2_2t - ((t - r) - fn * pio2_2);
y[0] = r - w;
i = j - (((__HI(y[0])) >> 20) & 0x7ff);
if (i > 49) { /* 3rd iteration need, 151 bits acc */
t = r; /* will cover all possible cases */
w = fn * pio2_3;
r = t - w;
w = fn * pio2_3t - ((t - r) - w);
y[0] = r - w;
}
}
}
y[1] = (r - y[0]) - w;
if (hx < 0) {
y[0] = -y[0];
y[1] = -y[1];
return -n;
} else
return n;
}
/*
* all other (large) arguments
*/
if (ix >= 0x7ff00000) { /* x is inf or NaN */
y[0] = y[1] = x - x;
return 0;
}
/* set z = scalbn(|x|,ilogb(x)-23) */
__LO(z) = __LO(x);
e0 = (ix >> 20) - 1046; /* e0 = ilogb(z)-23; */
__HI(z) = ix - (e0 << 20);
for (i = 0; i < 2; i++) {
tx[i] = (double)((int)(z));
z = (z - tx[i]) * two24;
}
tx[2] = z;
nx = 3;
while (tx[nx - 1] == zero)
nx--; /* skip zero term */
n = __kernel_rem_pio2(tx, y, e0, nx, 2, two_over_pi);
if (hx < 0) {
y[0] = -y[0];
y[1] = -y[1];
return -n;
}
return n;
}
libs/MSL_C/Math/Double_precision/e_sqrt.c
+453 -30
View File
@@ -1,39 +1,462 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/e_sqrt
//
/* @(#)e_sqrt.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
#include "MSL_C/Math/Double_precision/e_sqrt.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* __ieee754_sqrt(x)
* Return correctly rounded sqrt.
* ------------------------------------------
* | Use the hardware sqrt if you have one |
* ------------------------------------------
* Method:
* Bit by bit method using integer arithmetic. (Slow, but portable)
* 1. Normalization
* Scale x to y in [1,4) with even powers of 2:
* find an integer k such that 1 <= (y=x*2^(2k)) < 4, then
* sqrt(x) = 2^k * sqrt(y)
* 2. Bit by bit computation
* Let q = sqrt(y) truncated to i bit after binary point (q = 1),
* i 0
* i+1 2
* s = 2*q , and y = 2 * ( y - q ). (1)
* i i i i
*
* To compute q from q , one checks whether
* i+1 i
*
* -(i+1) 2
* (q + 2 ) <= y. (2)
* i
* -(i+1)
* If (2) is false, then q = q ; otherwise q = q + 2 .
* i+1 i i+1 i
*
* With some algebric manipulation, it is not difficult to see
* that (2) is equivalent to
* -(i+1)
* s + 2 <= y (3)
* i i
*
* The advantage of (3) is that s and y can be computed by
* i i
* the following recurrence formula:
* if (3) is false
*
* s = s , y = y ; (4)
* i+1 i i+1 i
*
* otherwise,
* -i -(i+1)
* s = s + 2 , y = y - s - 2 (5)
* i+1 i i+1 i i
*
* One may easily use induction to prove (4) and (5).
* Note. Since the left hand side of (3) contain only i+2 bits,
* it does not necessary to do a full (53-bit) comparison
* in (3).
* 3. Final rounding
* After generating the 53 bits result, we compute one more bit.
* Together with the remainder, we can decide whether the
* result is exact, bigger than 1/2ulp, or less than 1/2ulp
* (it will never equal to 1/2ulp).
* The rounding mode can be detected by checking whether
* huge + tiny is equal to huge, and whether huge - tiny is
* equal to huge for some floating point number "huge" and "tiny".
*
* Special cases:
* sqrt(+-0) = +-0 ... exact
* sqrt(inf) = inf
* sqrt(-ve) = NaN ... with invalid signal
* sqrt(NaN) = NaN ... with invalid signal for signaling NaN
*
* Other methods : see the appended file at the end of the program below.
*---------------
*/
//
// Forward References:
//
#include "fdlibm.h"
#include "errno.h"
#include "MSL_C/math.h"
void __ieee754_sqrt();
#ifdef __STDC__
static const double one = 1.0, tiny = 1.0e-300;
#else
static double one = 1.0, tiny = 1.0e-300;
#endif
//
// External References:
//
#ifdef __STDC__
double __ieee754_sqrt(double x)
#else
double __ieee754_sqrt(x) double x;
#endif
{
double z;
int sign = (int)0x80000000;
unsigned r, t1, s1, ix1, q1;
int ix0, s0, q, m, t, i;
extern u32 __float_nan;
extern u8 errno[4 + 4 /* padding */];
ix0 = __HI(x); /* high word of x */
ix1 = __LO(x); /* low word of x */
//
// Declarations:
//
/* take care of Inf and NaN */
if ((ix0 & 0x7ff00000) == 0x7ff00000) {
errno = 33;
return x * x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf
sqrt(-inf)=sNaN */
}
/* take care of zero */
if (ix0 <= 0) {
if (((ix0 & (~sign)) | ix1) == 0)
return x; /* sqrt(+-0) = +-0 */
else if (ix0 < 0) {
errno = 33;
return *__float_nan;
} /* sqrt(-ve) = sNaN */
}
/* normalize x */
m = (ix0 >> 20);
if (m == 0) { /* subnormal x */
while (ix0 == 0) {
m -= 21;
ix0 |= (ix1 >> 11);
ix1 <<= 21;
}
for (i = 0; (ix0 & 0x00100000) == 0; i++)
ix0 <<= 1;
m -= i - 1;
ix0 |= (ix1 >> (32 - i));
ix1 <<= i;
}
m -= 1023; /* unbias exponent */
ix0 = (ix0 & 0x000fffff) | 0x00100000;
if (m & 1) { /* odd m, double x to make it even */
ix0 += ix0 + ((ix1 & sign) >> 31);
ix1 += ix1;
}
m >>= 1; /* m = [m/2] */
/* ############################################################################################## */
/* 80456B48-80456B50 005148 0008+00 1/1 0/0 0/0 .sdata2 @164 */
SECTION_SDATA2 static f64 lit_164 = 1.0;
/* generate sqrt(x) bit by bit */
ix0 += ix0 + ((ix1 & sign) >> 31);
ix1 += ix1;
q = q1 = s0 = s1 = 0; /* [q,q1] = sqrt(x) */
r = 0x00200000; /* r = moving bit from right to left */
/* 8036C7A0-8036C9C4 3670E0 0224+00 0/0 1/1 0/0 .text __ieee754_sqrt */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ieee754_sqrt() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/e_sqrt/__ieee754_sqrt.s"
while (r != 0) {
t = s0 + r;
if (t <= ix0) {
s0 = t + r;
ix0 -= t;
q += r;
}
ix0 += ix0 + ((ix1 & sign) >> 31);
ix1 += ix1;
r >>= 1;
}
r = sign;
while (r != 0) {
t1 = s1 + r;
t = s0;
if ((t < ix0) || ((t == ix0) && (t1 <= ix1))) {
s1 = t1 + r;
if (((t1 & sign) == sign) && (s1 & sign) == 0)
s0 += 1;
ix0 -= t;
if (ix1 < t1)
ix0 -= 1;
ix1 -= t1;
q1 += r;
}
ix0 += ix0 + ((ix1 & sign) >> 31);
ix1 += ix1;
r >>= 1;
}
/* use floating add to find out rounding direction */
if ((ix0 | ix1) != 0) {
z = one - tiny; /* trigger inexact flag */
if (z >= one) {
z = one + tiny;
if (q1 == (unsigned)0xffffffff) {
q1 = 0;
q += 1;
} else if (z > one) {
if (q1 == (unsigned)0xfffffffe)
q += 1;
q1 += 2;
} else
q1 += (q1 & 1);
}
}
ix0 = (q >> 1) + 0x3fe00000;
ix1 = q1 >> 1;
if ((q & 1) == 1)
ix1 |= sign;
ix0 += (m << 20);
__HI(z) = ix0;
__LO(z) = ix1;
return z;
}
#pragma pop
/*
Other methods (use floating-point arithmetic)
-------------
(This is a copy of a drafted paper by Prof W. Kahan
and K.C. Ng, written in May, 1986)
Two algorithms are given here to implement sqrt(x)
(IEEE double precision arithmetic) in software.
Both supply sqrt(x) correctly rounded. The first algorithm (in
Section A) uses newton iterations and involves four divisions.
The second one uses reciproot iterations to avoid division, but
requires more multiplications. Both algorithms need the ability
to chop results of arithmetic operations instead of round them,
and the INEXACT flag to indicate when an arithmetic operation
is executed exactly with no roundoff error, all part of the
standard (IEEE 754-1985). The ability to perform shift, add,
subtract and logical AND operations upon 32-bit words is needed
too, though not part of the standard.
A. sqrt(x) by Newton Iteration
(1) Initial approximation
Let x0 and x1 be the leading and the trailing 32-bit words of
a floating point number x (in IEEE double format) respectively
1 11 52 ...widths
------------------------------------------------------
x: |s| e | f |
------------------------------------------------------
msb lsb msb lsb ...order
------------------------ ------------------------
x0: |s| e | f1 | x1: | f2 |
------------------------ ------------------------
By performing shifts and subtracts on x0 and x1 (both regarded
as integers), we obtain an 8-bit approximation of sqrt(x) as
follows.
k := (x0>>1) + 0x1ff80000;
y0 := k - T1[31&(k>>15)]. ... y ~ sqrt(x) to 8 bits
Here k is a 32-bit integer and T1[] is an integer array containing
correction terms. Now magically the floating value of y (y's
leading 32-bit word is y0, the value of its trailing word is 0)
approximates sqrt(x) to almost 8-bit.
Value of T1:
static int T1[32]= {
0, 1024, 3062, 5746, 9193, 13348, 18162, 23592,
29598, 36145, 43202, 50740, 58733, 67158, 75992, 85215,
83599, 71378, 60428, 50647, 41945, 34246, 27478, 21581,
16499, 12183, 8588, 5674, 3403, 1742, 661, 130,};
(2) Iterative refinement
Apply Heron's rule three times to y, we have y approximates
sqrt(x) to within 1 ulp (Unit in the Last Place):
y := (y+x/y)/2 ... almost 17 sig. bits
y := (y+x/y)/2 ... almost 35 sig. bits
y := y-(y-x/y)/2 ... within 1 ulp
Remark 1.
Another way to improve y to within 1 ulp is:
y := (y+x/y) ... almost 17 sig. bits to 2*sqrt(x)
y := y - 0x00100006 ... almost 18 sig. bits to sqrt(x)
2
(x-y )*y
y := y + 2* ---------- ...within 1 ulp
2
3y + x
This formula has one division fewer than the one above; however,
it requires more multiplications and additions. Also x must be
scaled in advance to avoid spurious overflow in evaluating the
expression 3y*y+x. Hence it is not recommended uless division
is slow. If division is very slow, then one should use the
reciproot algorithm given in section B.
(3) Final adjustment
By twiddling y's last bit it is possible to force y to be
correctly rounded according to the prevailing rounding mode
as follows. Let r and i be copies of the rounding mode and
inexact flag before entering the square root program. Also we
use the expression y+-ulp for the next representable floating
numbers (up and down) of y. Note that y+-ulp = either fixed
point y+-1, or multiply y by nextafter(1,+-inf) in chopped
mode.
I := FALSE; ... reset INEXACT flag I
R := RZ; ... set rounding mode to round-toward-zero
z := x/y; ... chopped quotient, possibly inexact
If(not I) then { ... if the quotient is exact
if(z=y) {
I := i; ... restore inexact flag
R := r; ... restore rounded mode
return sqrt(x):=y.
} else {
z := z - ulp; ... special rounding
}
}
i := TRUE; ... sqrt(x) is inexact
If (r=RN) then z=z+ulp ... rounded-to-nearest
If (r=RP) then { ... round-toward-+inf
y = y+ulp; z=z+ulp;
}
y := y+z; ... chopped sum
y0:=y0-0x00100000; ... y := y/2 is correctly rounded.
I := i; ... restore inexact flag
R := r; ... restore rounded mode
return sqrt(x):=y.
(4) Special cases
Square root of +inf, +-0, or NaN is itself;
Square root of a negative number is NaN with invalid signal.
B. sqrt(x) by Reciproot Iteration
(1) Initial approximation
Let x0 and x1 be the leading and the trailing 32-bit words of
a floating point number x (in IEEE double format) respectively
(see section A). By performing shifs and subtracts on x0 and y0,
we obtain a 7.8-bit approximation of 1/sqrt(x) as follows.
k := 0x5fe80000 - (x0>>1);
y0:= k - T2[63&(k>>14)]. ... y ~ 1/sqrt(x) to 7.8 bits
Here k is a 32-bit integer and T2[] is an integer array
containing correction terms. Now magically the floating
value of y (y's leading 32-bit word is y0, the value of
its trailing word y1 is set to zero) approximates 1/sqrt(x)
to almost 7.8-bit.
Value of T2:
static int T2[64]= {
0x1500, 0x2ef8, 0x4d67, 0x6b02, 0x87be, 0xa395, 0xbe7a, 0xd866,
0xf14a, 0x1091b,0x11fcd,0x13552,0x14999,0x15c98,0x16e34,0x17e5f,
0x18d03,0x19a01,0x1a545,0x1ae8a,0x1b5c4,0x1bb01,0x1bfde,0x1c28d,
0x1c2de,0x1c0db,0x1ba73,0x1b11c,0x1a4b5,0x1953d,0x18266,0x16be0,
0x1683e,0x179d8,0x18a4d,0x19992,0x1a789,0x1b445,0x1bf61,0x1c989,
0x1d16d,0x1d77b,0x1dddf,0x1e2ad,0x1e5bf,0x1e6e8,0x1e654,0x1e3cd,
0x1df2a,0x1d635,0x1cb16,0x1be2c,0x1ae4e,0x19bde,0x1868e,0x16e2e,
0x1527f,0x1334a,0x11051,0xe951, 0xbe01, 0x8e0d, 0x5924, 0x1edd,};
(2) Iterative refinement
Apply Reciproot iteration three times to y and multiply the
result by x to get an approximation z that matches sqrt(x)
to about 1 ulp. To be exact, we will have
-1ulp < sqrt(x)-z<1.0625ulp.
... set rounding mode to Round-to-nearest
y := y*(1.5-0.5*x*y*y) ... almost 15 sig. bits to 1/sqrt(x)
y := y*((1.5-2^-30)+0.5*x*y*y)... about 29 sig. bits to 1/sqrt(x)
... special arrangement for better accuracy
z := x*y ... 29 bits to sqrt(x), with z*y<1
z := z + 0.5*z*(1-z*y) ... about 1 ulp to sqrt(x)
Remark 2. The constant 1.5-2^-30 is chosen to bias the error so that
(a) the term z*y in the final iteration is always less than 1;
(b) the error in the final result is biased upward so that
-1 ulp < sqrt(x) - z < 1.0625 ulp
instead of |sqrt(x)-z|<1.03125ulp.
(3) Final adjustment
By twiddling y's last bit it is possible to force y to be
correctly rounded according to the prevailing rounding mode
as follows. Let r and i be copies of the rounding mode and
inexact flag before entering the square root program. Also we
use the expression y+-ulp for the next representable floating
numbers (up and down) of y. Note that y+-ulp = either fixed
point y+-1, or multiply y by nextafter(1,+-inf) in chopped
mode.
R := RZ; ... set rounding mode to round-toward-zero
switch(r) {
case RN: ... round-to-nearest
if(x<= z*(z-ulp)...chopped) z = z - ulp; else
if(x<= z*(z+ulp)...chopped) z = z; else z = z+ulp;
break;
case RZ:case RM: ... round-to-zero or round-to--inf
R:=RP; ... reset rounding mod to round-to-+inf
if(x<z*z ... rounded up) z = z - ulp; else
if(x>=(z+ulp)*(z+ulp) ...rounded up) z = z+ulp;
break;
case RP: ... round-to-+inf
if(x>(z+ulp)*(z+ulp)...chopped) z = z+2*ulp; else
if(x>z*z ...chopped) z = z+ulp;
break;
}
Remark 3. The above comparisons can be done in fixed point. For
example, to compare x and w=z*z chopped, it suffices to compare
x1 and w1 (the trailing parts of x and w), regarding them as
two's complement integers.
...Is z an exact square root?
To determine whether z is an exact square root of x, let z1 be the
trailing part of z, and also let x0 and x1 be the leading and
trailing parts of x.
If ((z1&0x03ffffff)!=0) ... not exact if trailing 26 bits of z!=0
I := 1; ... Raise Inexact flag: z is not exact
else {
j := 1 - [(x0>>20)&1] ... j = logb(x) mod 2
k := z1 >> 26; ... get z's 25-th and 26-th
fraction bits
I := i or (k&j) or ((k&(j+j+1))!=(x1&3));
}
R:= r ... restore rounded mode
return sqrt(x):=z.
If multiplication is cheaper then the foregoing red tape, the
Inexact flag can be evaluated by
I := i;
I := (z*z!=x) or I.
Note that z*z can overwrite I; this value must be sensed if it is
True.
Remark 4. If z*z = x exactly, then bit 25 to bit 0 of z1 must be
zero.
--------------------
z1: | f2 |
--------------------
bit 31 bit 0
Further more, bit 27 and 26 of z1, bit 0 and 1 of x1, and the odd
or even of logb(x) have the following relations:
-------------------------------------------------
bit 27,26 of z1 bit 1,0 of x1 logb(x)
-------------------------------------------------
00 00 odd and even
01 01 even
10 10 odd
10 00 even
11 01 even
-------------------------------------------------
(4) Special cases (see (4) of Section A).
*/
libs/MSL_C/Math/Double_precision/k_cos.c
+88 -55
View File
@@ -1,60 +1,93 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/k_cos
//
#include "MSL_C/Math/Double_precision/k_cos.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)k_cos.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/*
* __kernel_cos( x, y )
* kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164
* Input x is assumed to be bounded by ~pi/4 in magnitude.
* Input y is the tail of x.
*
* Algorithm
* 1. Since cos(-x) = cos(x), we need only to consider positive x.
* 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0.
* 3. cos(x) is approximated by a polynomial of degree 14 on
* [0,pi/4]
* 4 14
* cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x
* where the remez error is
*
* | 2 4 6 8 10 12 14 | -58
* |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2
* | |
*
* 4 6 8 10 12 14
* 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then
* cos(x) = 1 - x*x/2 + r
* since cos(x+y) ~ cos(x) - sin(x)*y
* ~ cos(x) - x*y,
* a correction term is necessary in cos(x) and hence
* cos(x+y) = 1 - (x*x/2 - (r - x*y))
* For better accuracy when x > 0.3, let qx = |x|/4 with
* the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125.
* Then
* cos(x+y) = (1-qx) - ((x*x/2-qx) - (r-x*y)).
* Note that 1-qx and (x*x/2-qx) is EXACT here, and the
* magnitude of the latter is at least a quarter of x*x/2,
* thus, reducing the rounding error in the subtraction.
*/
void __kernel_cos();
#include "fdlibm.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
one
= 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */
C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */
C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */
C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */
C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */
C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */
//
// Declarations:
//
/* ############################################################################################## */
/* 804569C0-804569C8 004FC0 0008+00 1/1 0/0 0/0 .sdata2 @65 */
SECTION_SDATA2 static f64 lit_65 = 1.0;
/* 804569C8-804569D0 004FC8 0008+00 1/1 0/0 0/0 .sdata2 @66 */
SECTION_SDATA2 static f64 lit_66 = 0.0416666666666666;
/* 804569D0-804569D8 004FD0 0008+00 1/1 0/0 0/0 .sdata2 @67 */
SECTION_SDATA2 static f64 lit_67 = -0.001388888888887411;
/* 804569D8-804569E0 004FD8 0008+00 1/1 0/0 0/0 .sdata2 @68 */
SECTION_SDATA2 static f64 lit_68 = 2.480158728947673e-05;
/* 804569E0-804569E8 004FE0 0008+00 1/1 0/0 0/0 .sdata2 @69 */
SECTION_SDATA2 static f64 lit_69 = -2.7557314351390663e-07;
/* 804569E8-804569F0 004FE8 0008+00 1/1 0/0 0/0 .sdata2 @70 */
SECTION_SDATA2 static f64 lit_70 = 2.087572321298175e-09;
/* 804569F0-804569F8 004FF0 0008+00 1/1 0/0 0/0 .sdata2 @71 */
SECTION_SDATA2 static f64 lit_71 = -1.1359647557788195e-11;
/* 804569F8-80456A00 004FF8 0008+00 1/1 0/0 0/0 .sdata2 @72 */
SECTION_SDATA2 static f64 lit_72 = 0.5;
/* 80456A00-80456A08 005000 0008+00 1/1 0/0 0/0 .sdata2 @73 */
SECTION_SDATA2 static f64 lit_73 = 0.28125;
/* 8036AAA8-8036AB9C 3653E8 00F4+00 0/0 2/2 0/0 .text __kernel_cos */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __kernel_cos() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/k_cos/__kernel_cos.s"
}
#pragma pop
#ifdef __STDC__
double __kernel_cos(double x, double y)
#else
double __kernel_cos(x, y) double x, y;
#endif
{
double a, hz, z, r, qx;
int ix;
ix = __HI(x) & 0x7fffffff; /* ix = |x|'s high word*/
if (ix < 0x3e400000) { /* if x < 2**27 */
if (((int)x) == 0)
return one; /* generate inexact */
}
z = x * x;
r = z * (C1 + z * (C2 + z * (C3 + z * (C4 + z * (C5 + z * C6)))));
if (ix < 0x3FD33333) /* if |x| < 0.3 */
return one - (0.5 * z - (z * r - x * y));
else {
if (ix > 0x3fe90000) { /* x > 0.78125 */
qx = 0.28125;
} else {
__HI(qx) = ix - 0x00200000; /* x/4 */
__LO(qx) = 0;
}
hz = 0.5 * z - qx;
a = one - qx;
return a - (hz - (z * r - x * y));
}
}
libs/MSL_C/Math/Double_precision/k_rem_pio2.c
+338 -64
View File
@@ -1,79 +1,353 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/k_rem_pio2
//
#include "MSL_C/Math/Double_precision/k_rem_pio2.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)k_rem_pio2.c 1.2 95/01/04 */
/* $Id: k_rem_pio2.c,v 1.2.14.1 2002/01/31 15:24:13 ceciliar Exp $ */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/*
* __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
* double x[],y[]; int e0,nx,prec; int ipio2[];
*
* __kernel_rem_pio2 return the last three digits of N with
* y = x - N*pi/2
* so that |y| < pi/2.
*
* The method is to compute the integer (mod 8) and fraction parts of
* (2/pi)*x without doing the full multiplication. In general we
* skip the part of the product that are known to be a huge integer (
* more accurately, = 0 mod 8 ). Thus the number of operations are
* independent of the exponent of the input.
*
* (2/pi) is represented by an array of 24-bit integers in ipio2[].
*
* Input parameters:
* x[] The input value (must be positive) is broken into nx
* pieces of 24-bit integers in double precision format.
* x[i] will be the i-th 24 bit of x. The scaled exponent
* of x[0] is given in input parameter e0 (i.e., x[0]*2^e0
* match x's up to 24 bits.
*
* Example of breaking a double positive z into x[0]+x[1]+x[2]:
* e0 = ilogb(z)-23
* z = ldexp(z,-e0)
* for i = 0,1,2
* x[i] = floor(z)
* z = (z-x[i])*2**24
*
*
* y[] ouput result in an array of double precision numbers.
* The dimension of y[] is:
* 24-bit precision 1
* 53-bit precision 2
* 64-bit precision 2
* 113-bit precision 3
* The actual value is the sum of them. Thus for 113-bit
* precison, one may have to do something like:
*
* long double t,w,r_head, r_tail;
* t = (long double)y[2] + (long double)y[1];
* w = (long double)y[0];
* r_head = t+w;
* r_tail = w - (r_head - t);
*
* e0 The exponent of x[0]
*
* nx dimension of x[]
*
* prec an integer indicating the precision:
* 0 24 bits (single)
* 1 53 bits (double)
* 2 64 bits (extended)
* 3 113 bits (quad)
*
* ipio2[]
* integer array, contains the (24*i)-th to (24*i+23)-th
* bit of 2/pi after binary point. The corresponding
* floating value is
*
* ipio2[i] * 2^(-24(i+1)).
*
* External function:
* double ldexp(), floor();
*
*
* Here is the description of some local variables:
*
* jk jk+1 is the initial number of terms of ipio2[] needed
* in the computation. The recommended value is 2,3,4,
* 6 for single, double, extended,and quad.
*
* jz local integer variable indicating the number of
* terms of ipio2[] used.
*
* jx nx - 1
*
* jv index for pointing to the suitable ipio2[] for the
* computation. In general, we want
* ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8
* is an integer. Thus
* e0-3-24*jv >= 0 or (e0-3)/24 >= jv
* Hence jv = max(0,(e0-3)/24).
*
* jp jp+1 is the number of terms in PIo2[] needed, jp = jk.
*
* q[] double array with integral value, representing the
* 24-bits chunk of the product of x and 2/pi.
*
* q0 the corresponding exponent of q[0]. Note that the
* exponent for q[i] would be q0-24*i.
*
* PIo2[] double precision array, obtained by cutting pi/2
* into 24 bits chunks.
*
* f[] ipio2[] in floating point
*
* iq[] integer array by breaking up q[] in 24-bits chunk.
*
* fq[] final product of x*(2/pi) in fq[0],..,fq[jk]
*
* ih integer. If >0 it indicates q[] is >= 0.5, hence
* it also indicates the *sign* of the result.
*
*/
void __kernel_rem_pio2();
/*
* Constants:
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
//
// External References:
//
#include "fdlibm.h"
void _savefpr_25();
void _restfpr_25();
void floor();
void ldexp();
#ifdef __STDC__
static const int init_jk[] = { 2, 3, 4, 6 };
/* initial value for jk */ /*- cc 020130 -*/
#else
static int init_jk[] = { 2, 3, 4, 6 }; /*- cc 020130 -*/
#endif
//
// Declarations:
//
/* ############################################################################################## */
/* 803A2538-803A2548 02EB98 0010+00 1/1 0/0 0/0 .rodata init_jk */
SECTION_RODATA static u8 const init_jk[16] = {
0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06,
};
COMPILER_STRIP_GATE(0x803A2538, &init_jk);
/* 803A2548-803A2588 02EBA8 0040+00 1/1 0/0 0/0 .rodata PIo2 */
SECTION_RODATA static u8 const PIo2[64] = {
0x3F, 0xF9, 0x21, 0xFB, 0x40, 0x00, 0x00, 0x00, 0x3E, 0x74, 0x44, 0x2D, 0x00, 0x00, 0x00, 0x00,
0x3C, 0xF8, 0x46, 0x98, 0x80, 0x00, 0x00, 0x00, 0x3B, 0x78, 0xCC, 0x51, 0x60, 0x00, 0x00, 0x00,
0x39, 0xF0, 0x1B, 0x83, 0x80, 0x00, 0x00, 0x00, 0x38, 0x7A, 0x25, 0x20, 0x40, 0x00, 0x00, 0x00,
0x36, 0xE3, 0x82, 0x22, 0x80, 0x00, 0x00, 0x00, 0x35, 0x69, 0xF3, 0x1D, 0x00, 0x00, 0x00, 0x00,
};
COMPILER_STRIP_GATE(0x803A2548, &PIo2);
/* 80456A08-80456A10 005008 0008+00 1/1 0/0 0/0 .sdata2 @436 */
SECTION_SDATA2 static u8 lit_436[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
#ifdef __STDC__
static const double PIo2[] = {
#else
static double PIo2[] = {
#endif
1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */
7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */
5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */
3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */
1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */
1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */
2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */
2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */
};
/* 80456A10-80456A18 005010 0008+00 1/1 0/0 0/0 .sdata2 @437 */
SECTION_SDATA2 static f64 lit_437 = 5.960464477539063e-08;
#ifdef __STDC__
static const double
#else
static double
#endif
zero
= 0.0,
one = 1.0, two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */
twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */
/* 80456A18-80456A20 005018 0008+00 1/1 0/0 0/0 .sdata2 @438 */
SECTION_SDATA2 static f64 lit_438 = 16777216.0;
#ifdef __STDC__
int __kernel_rem_pio2(double* x, double* y, int e0, int nx, int prec, const int* ipio2) /*- cc 020130 -*/
#else
int __kernel_rem_pio2(x, y, e0, nx, prec, ipio2) /*- cc 020130 -*/
double x[],
y[];
int e0, nx, prec;
int ipio2[]; /*- cc 020130 -*/
#endif
{
int jz, jx, jv, jp, jk, carry, n, iq[20], i, j, k, m, q0, ih; /*- cc 020130 -*/
double z, fw, f[20], fq[20], q[20];
/* 80456A20-80456A28 005020 0008+00 1/1 0/0 0/0 .sdata2 @439 */
SECTION_SDATA2 static f64 lit_439 = 8.0;
/* initialize jk*/
jk = init_jk[prec];
jp = jk;
/* 80456A28-80456A30 005028 0008+00 1/1 0/0 0/0 .sdata2 @440 */
SECTION_SDATA2 static f64 lit_440 = 0.125;
/* determine jx,jv,q0, note that 3>q0 */
jx = nx - 1;
jv = (e0 - 3) / 24;
if (jv < 0)
jv = 0;
q0 = e0 - 24 * (jv + 1);
/* 80456A30-80456A38 005030 0008+00 1/1 0/0 0/0 .sdata2 @441 */
SECTION_SDATA2 static f64 lit_441 = 0.5;
/* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */
j = jv - jx;
m = jx + jk;
for (i = 0; i <= m; i++, j++)
f[i] = (j < 0) ? zero : (double)ipio2[j];
/* 80456A38-80456A40 005038 0008+00 1/1 0/0 0/0 .sdata2 @442 */
SECTION_SDATA2 static f64 lit_442 = 1.0;
/* compute q[0],q[1],...q[jk] */
for (i = 0; i <= jk; i++) {
for (j = 0, fw = 0.0; j <= jx; j++)
fw += x[j] * f[jx + i - j];
q[i] = fw;
}
/* 80456A40-80456A48 005040 0008+00 1/1 0/0 0/0 .sdata2 @445 */
SECTION_SDATA2 static f64 lit_445 = 4503601774854144.0 /* cast s32 to float */;
jz = jk;
recompute:
/* distill q[] into iq[] reversingly */
for (i = 0, j = jz, z = q[jz]; j > 0; i++, j--) {
fw = (double)((int)(twon24 * z)); /*- cc 020130 -*/
iq[i] = (int)(z - two24 * fw); /*- cc 020130 -*/
z = q[j - 1] + fw;
}
/* 8036AB9C-8036B9F0 3654DC 0E54+00 0/0 1/1 0/0 .text __kernel_rem_pio2 */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __kernel_rem_pio2() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/k_rem_pio2/__kernel_rem_pio2.s"
}
#pragma pop
/* compute n */
z = ldexp(z, q0); /* actual value of z */
z -= 8.0 * floor(z * 0.125); /* trim off integer >= 8 */
n = (int)z; /*- cc 020130 -*/
z -= (double)n;
ih = 0;
if (q0 > 0) { /* need iq[jz-1] to determine n */
i = (iq[jz - 1] >> (24 - q0));
n += i;
iq[jz - 1] -= i << (24 - q0);
ih = iq[jz - 1] >> (23 - q0);
} else if (q0 == 0)
ih = iq[jz - 1] >> 23;
else if (z >= 0.5)
ih = 2;
if (ih > 0) { /* q > 0.5 */
n += 1;
carry = 0;
for (i = 0; i < jz; i++) { /* compute 1-q */
j = iq[i];
if (carry == 0) {
if (j != 0) {
carry = 1;
iq[i] = 0x1000000 - j;
}
} else
iq[i] = 0xffffff - j;
}
if (q0 > 0) { /* rare case: chance is 1 in 12 */
switch (q0) {
case 1:
iq[jz - 1] &= 0x7fffff;
break;
case 2:
iq[jz - 1] &= 0x3fffff;
break;
}
}
if (ih == 2) {
z = one - z;
if (carry != 0)
z -= ldexp(one, q0);
}
}
/* check if recomputation is needed */
if (z == zero) {
j = 0;
for (i = jz - 1; i >= jk; i--)
j |= iq[i];
if (j == 0) { /* need recomputation */
for (k = 1; iq[jk - k] == 0; k++)
; /* k = no. of terms needed */
for (i = jz + 1; i <= jz + k; i++) { /* add q[jz+1] to q[jz+k] */
f[jx + i] = (double)ipio2[jv + i];
for (j = 0, fw = 0.0; j <= jx; j++)
fw += x[j] * f[jx + i - j];
q[i] = fw;
}
jz += k;
goto recompute;
}
}
/* chop off zero terms */
if (z == 0.0) {
jz -= 1;
q0 -= 24;
while (iq[jz] == 0) {
jz--;
q0 -= 24;
}
} else { /* break z into 24-bit if necessary */
z = ldexp(z, -q0);
if (z >= two24) {
fw = (double)((int)(twon24 * z)); /*- cc 020130 -*/
iq[jz] = (int)(z - two24 * fw); /*- cc 020130 -*/
jz += 1;
q0 += 24;
iq[jz] = (int)fw; /*- cc 020130 -*/
} else
iq[jz] = (int)z; /*- cc 020130 -*/
}
/* convert integer "bit" chunk to floating-point value */
fw = ldexp(one, q0);
for (i = jz; i >= 0; i--) {
q[i] = fw * (double)iq[i];
fw *= twon24;
}
/* compute PIo2[0,...,jp]*q[jz,...,0] */
for (i = jz; i >= 0; i--) {
for (fw = 0.0, k = 0; k <= jp && k <= jz - i; k++)
fw += PIo2[k] * q[i + k];
fq[jz - i] = fw;
}
/* compress fq[] into y[] */
switch (prec) {
case 0:
fw = 0.0;
for (i = jz; i >= 0; i--)
fw += fq[i];
y[0] = (ih == 0) ? fw : -fw;
break;
case 1:
case 2:
fw = 0.0;
for (i = jz; i >= 0; i--)
fw += fq[i];
y[0] = (ih == 0) ? fw : -fw;
fw = fq[0] - fw;
for (i = 1; i <= jz; i++)
fw += fq[i];
y[1] = (ih == 0) ? fw : -fw;
break;
case 3: /* painful */
for (i = jz; i > 0; i--) {
fw = fq[i - 1] + fq[i];
fq[i] += fq[i - 1] - fw;
fq[i - 1] = fw;
}
for (i = jz; i > 1; i--) {
fw = fq[i - 1] + fq[i];
fq[i] += fq[i - 1] - fw;
fq[i - 1] = fw;
}
for (fw = 0.0, i = jz; i >= 2; i--)
fw += fq[i];
if (ih == 0) {
y[0] = fq[0];
y[1] = fq[1];
y[2] = fw;
} else {
y[0] = -fq[0];
y[1] = -fq[1];
y[2] = -fw;
}
}
return n & 7;
}
libs/MSL_C/Math/Double_precision/k_sin.c
+75 -49
View File
@@ -1,54 +1,80 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/k_sin
//
#include "MSL_C/Math/Double_precision/k_sin.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)k_sin.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
//
// Forward References:
//
/* __kernel_sin( x, y, iy)
* kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854
* Input x is assumed to be bounded by ~pi/4 in magnitude.
* Input y is the tail of x.
* Input iy indicates whether y is 0. (if iy=0, y assume to be 0).
*
* Algorithm
* 1. Since sin(-x) = -sin(x), we need only to consider positive x.
* 2. if x < 2^-27 (hx<0x3e400000 0), return x with inexact if x!=0.
* 3. sin(x) is approximated by a polynomial of degree 13 on
* [0,pi/4]
* 3 13
* sin(x) ~ x + S1*x + ... + S6*x
* where
*
* |sin(x) 2 4 6 8 10 12 | -58
* |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2
* | x |
*
* 4. sin(x+y) = sin(x) + sin'(x')*y
* ~ sin(x) + (1-x*x/2)*y
* For better accuracy, let
* 3 2 2 2 2
* r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6))))
* then 3 2
* sin(x) = x + (S1*x + (x *(r-y/2)+y))
*/
void __kernel_sin();
#include "fdlibm.h"
//
// External References:
//
#ifdef __STDC__
static const double
#else
static double
#endif
half
= 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */
S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */
S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */
S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */
S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */
S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */
S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */
//
// Declarations:
//
/* ############################################################################################## */
/* 80456A48-80456A50 005048 0008+00 1/1 0/0 0/0 .sdata2 @60 */
SECTION_SDATA2 static f64 lit_60 = 0.00833333333332249;
/* 80456A50-80456A58 005050 0008+00 1/1 0/0 0/0 .sdata2 @61 */
SECTION_SDATA2 static f64 lit_61 = -0.0001984126982985795;
/* 80456A58-80456A60 005058 0008+00 1/1 0/0 0/0 .sdata2 @62 */
SECTION_SDATA2 static f64 lit_62 = 2.7557313707070068e-06;
/* 80456A60-80456A68 005060 0008+00 1/1 0/0 0/0 .sdata2 @63 */
SECTION_SDATA2 static f64 lit_63 = -2.5050760253406863e-08;
/* 80456A68-80456A70 005068 0008+00 1/1 0/0 0/0 .sdata2 @64 */
SECTION_SDATA2 static f64 lit_64 = 1.58969099521155e-10;
/* 80456A70-80456A78 005070 0008+00 1/1 0/0 0/0 .sdata2 @65 */
SECTION_SDATA2 static f64 lit_65 = -0.16666666666666632;
/* 80456A78-80456A80 005078 0008+00 1/1 0/0 0/0 .sdata2 @66 */
SECTION_SDATA2 static f64 lit_66 = 0.5;
/* 8036B9F0-8036BA90 366330 00A0+00 0/0 2/2 0/0 .text __kernel_sin */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __kernel_sin() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/k_sin/__kernel_sin.s"
}
#pragma pop
#ifdef __STDC__
double __kernel_sin(double x, double y, int iy)
#else
double __kernel_sin(x, y, iy) double x, y;
int iy; /* iy=0 if y is zero */
#endif
{
double z, r, v;
int ix;
ix = __HI(x) & 0x7fffffff; /* high word of x */
if (ix < 0x3e400000) /* |x| < 2**-27 */
{
if ((int)x == 0)
return x;
} /* generate inexact */
z = x * x;
v = z * x;
r = S2 + z * (S3 + z * (S4 + z * (S5 + z * S6)));
if (iy == 0)
return x + v * (S1 + z * r);
else
return x - ((z * (half * y - v * r) - y) - v * S1);
}
libs/MSL_C/Math/Double_precision/k_tan.c
+167 -54
View File
@@ -1,68 +1,181 @@
//===========================================================================
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/k_tan
// k_tan.c
//
#include "MSL_C/Math/Double_precision/k_tan.h"
#include "dol2asm.h"
#include "dolphin/types.h"
// Part of the standard mathematical function library
//
// Forward References:
//===========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
void __kernel_tan();
// eCos is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later version.
//
// External References:
// eCos is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// Declarations:
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//===========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): jlarmour
// Contributors: jlarmour
// Date: 1998-02-13
// Purpose:
// Description:
// Usage:
//
//####DESCRIPTIONEND####
//
//===========================================================================
/* ############################################################################################## */
/* 803A2588-803A25F0 02EBE8 0068+00 1/1 0/0 0/0 .rodata T */
SECTION_RODATA static u8 const T[104] = {
0x3F, 0xD5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x63, 0x3F, 0xC1, 0x11, 0x11, 0x11, 0x10, 0xFE,
0x7A, 0x3F, 0xAB, 0xA1, 0xBA, 0x1B, 0xB3, 0x41, 0xFE, 0x3F, 0x96, 0x64, 0xF4, 0x84, 0x06,
0xD6, 0x37, 0x3F, 0x82, 0x26, 0xE3, 0xE9, 0x6E, 0x84, 0x93, 0x3F, 0x6D, 0x6D, 0x22, 0xC9,
0x56, 0x03, 0x28, 0x3F, 0x57, 0xDB, 0xC8, 0xFE, 0xE0, 0x83, 0x15, 0x3F, 0x43, 0x44, 0xD8,
0xF2, 0xF2, 0x65, 0x01, 0x3F, 0x30, 0x26, 0xF7, 0x1A, 0x8D, 0x10, 0x68, 0x3F, 0x14, 0x7E,
0x88, 0xA0, 0x37, 0x92, 0xA6, 0x3F, 0x12, 0xB8, 0x0F, 0x32, 0xF0, 0xA7, 0xE9, 0xBE, 0xF3,
0x75, 0xCB, 0xDB, 0x60, 0x53, 0x73, 0x3E, 0xFB, 0x2A, 0x70, 0x74, 0xBF, 0x7A, 0xD4,
};
COMPILER_STRIP_GATE(0x803A2588, &T);
// Derived from code with the following copyright
/* 80456A80-80456A88 005080 0008+00 1/1 0/0 0/0 .sdata2 @94 */
SECTION_SDATA2 static f64 lit_94 = 1.0;
/* @(#)k_tan.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
/* 80456A88-80456A90 005088 0008+00 1/1 0/0 0/0 .sdata2 @95 */
SECTION_SDATA2 static f64 lit_95 = -1.0;
/* __kernel_tan( x, y, k )
* kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854
* Input x is assumed to be bounded by ~pi/4 in magnitude.
* Input y is the tail of x.
* Input k indicates whether tan (if k=1) or
* -1/tan (if k= -1) is returned.
*
* Algorithm
* 1. Since tan(-x) = -tan(x), we need only to consider positive x.
* 2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0.
* 3. tan(x) is approximated by a odd polynomial of degree 27 on
* [0,0.67434]
* 3 27
* tan(x) ~ x + T1*x + ... + T13*x
* where
*
* |tan(x) 2 4 26 | -59.2
* |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2
* | x |
*
* Note: tan(x+y) = tan(x) + tan'(x)*y
* ~ tan(x) + (1+x*x)*y
* Therefore, for better accuracy in computing tan(x+y), let
* 3 2 2 2 2
* r = x *(T2+x *(T3+x *(...+x *(T12+x *T13))))
* then
* 3 2
* tan(x+y) = x + (T1*x + (x *(r+y)+y))
*
* 4. For x in [0.67434,pi/4], let y = pi/4 - x, then
* tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y))
* = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y)))
*/
/* 80456A90-80456A98 005090 0008+00 1/1 0/0 0/0 .sdata2 @96 */
SECTION_SDATA2 static f64 lit_96 = 0.7853981633974483;
#include "fdlibm.h"
#include "MSL_C/math.h"
static const double one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */
pio4 = 7.85398163397448278999e-01, /* 0x3FE921FB, 0x54442D18 */
pio4lo = 3.06161699786838301793e-17, /* 0x3C81A626, 0x33145C07 */
T[] = {
3.33333333333334091986e-01, /* 0x3FD55555, 0x55555563 */
1.33333333333201242699e-01, /* 0x3FC11111, 0x1110FE7A */
5.39682539762260521377e-02, /* 0x3FABA1BA, 0x1BB341FE */
2.18694882948595424599e-02, /* 0x3F9664F4, 0x8406D637 */
8.86323982359930005737e-03, /* 0x3F8226E3, 0xE96E8493 */
3.59207910759131235356e-03, /* 0x3F6D6D22, 0xC9560328 */
1.45620945432529025516e-03, /* 0x3F57DBC8, 0xFEE08315 */
5.88041240820264096874e-04, /* 0x3F4344D8, 0xF2F26501 */
2.46463134818469906812e-04, /* 0x3F3026F7, 0x1A8D1068 */
7.81794442939557092300e-05, /* 0x3F147E88, 0xA03792A6 */
7.14072491382608190305e-05, /* 0x3F12B80F, 0x32F0A7E9 */
-1.85586374855275456654e-05, /* 0xBEF375CB, 0xDB605373 */
2.59073051863633712884e-05, /* 0x3EFB2A70, 0x74BF7AD4 */
};
/* 80456A98-80456AA0 005098 0008+00 1/1 0/0 0/0 .sdata2 @97 */
SECTION_SDATA2 static f64 lit_97 = 3.061616997868383e-17;
/* 80456AA0-80456AA8 0050A0 0008+00 1/1 0/0 0/0 .sdata2 @98 */
SECTION_SDATA2 static u8 lit_98[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 80456AA8-80456AB0 0050A8 0008+00 1/1 0/0 0/0 .sdata2 @99 */
SECTION_SDATA2 static f64 lit_99 = 2.0;
/* 80456AB0-80456AB8 0050B0 0008+00 1/1 0/0 0/0 .sdata2 @101 */
SECTION_SDATA2 static f64 lit_101 = 4503601774854144.0 /* cast s32 to float */;
/* 8036BA90-8036BCA4 3663D0 0214+00 0/0 1/1 0/0 .text __kernel_tan */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __kernel_tan() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/k_tan/__kernel_tan.s"
double __kernel_tan(double x, double y, int iy)
{
double z, r, v, w, s;
int ix, hx;
hx = __HI(x); /* high word of x */
ix = hx & 0x7fffffff; /* high word of |x| */
if (ix < 0x3e300000) /* x < 2**-28 */
{
if ((int)x == 0) { /* generate inexact */
if (((ix | __LO(x)) | (iy + 1)) == 0) {
double ret = fabs(x);
return one / ret;
} else
return (iy == 1) ? x : -one / x;
}
}
if (ix >= 0x3FE59428) { /* |x|>=0.6744 */
if (hx < 0) {
x = -x;
y = -y;
}
z = pio4 - x;
w = pio4lo - y;
x = z + w;
y = 0.0;
}
z = x * x;
w = z * z;
/* Break x^5*(T[1]+x^2*T[2]+...) into
* x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +
* x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))
*/
r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));
v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));
s = z * x;
r = y + z * (s * (r + v) + y);
r += T[0] * s;
w = x + r;
if (ix >= 0x3FE59428) {
v = (double)iy;
return (double)(1 - ((hx >> 30) & 2)) * (v - 2.0 * (x - (w * w / (w + v) - r)));
}
if (iy == 1)
return w;
else { /* if allow error up to 2 ulp,
simply return -1.0/(x+r) here */
/* compute -1.0/(x+r) accurately */
double a, t;
z = w;
__LO(z) = 0;
v = r - (z - x); /* z+v = r+x */
t = a = -1.0 / w; /* a = -1.0/w */
__LO(t) = 0;
s = 1.0 + t * z;
return t + a * (s + t * v);
}
}
#pragma pop
// EOF k_tan.c
libs/MSL_C/Math/Double_precision/s_atan.c
+131 -67
View File
@@ -1,79 +1,143 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/s_atan
//
#include "MSL_C/Math/Double_precision/s_atan.h"
#include "dol2asm.h"
#include "dolphin/types.h"
/* @(#)s_atan.c 1.3 95/01/18 */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunSoft, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*
*/
//
// Forward References:
//
/* atan(x)
* Method
* 1. Reduce x to positive by atan(x) = -atan(-x).
* 2. According to the integer k=4t+0.25 chopped, t=x, the argument
* is further reduced to one of the following intervals and the
* arctangent of t is evaluated by the corresponding formula:
*
* [0,7/16] atan(x) = t-t^3*(a1+t^2*(a2+...(a10+t^2*a11)...)
* [7/16,11/16] atan(x) = atan(1/2) + atan( (t-0.5)/(1+t/2) )
* [11/16.19/16] atan(x) = atan( 1 ) + atan( (t-1)/(1+t) )
* [19/16,39/16] atan(x) = atan(3/2) + atan( (t-1.5)/(1+1.5t) )
* [39/16,INF] atan(x) = atan(INF) + atan( -1/t )
*
* Constants:
* The hexadecimal values are the intended ones for the following
* constants. The decimal values may be used, provided that the
* compiler will convert from decimal to binary accurately enough
* to produce the hexadecimal values shown.
*/
void atan();
#include "fdlibm.h"
//
// External References:
//
//
// Declarations:
//
/* ############################################################################################## */
/* 803A25F0-803A2610 02EC50 0020+00 1/1 0/0 0/0 .rodata atanhi */
SECTION_RODATA static u8 const atanhi[32] = {
0x3F, 0xDD, 0xAC, 0x67, 0x05, 0x61, 0xBB, 0x4F, 0x3F, 0xE9, 0x21, 0xFB, 0x54, 0x44, 0x2D, 0x18,
0x3F, 0xEF, 0x73, 0x0B, 0xD2, 0x81, 0xF6, 0x9B, 0x3F, 0xF9, 0x21, 0xFB, 0x54, 0x44, 0x2D, 0x18,
#ifdef __STDC__
static const double atanhi[] = {
#else
static double atanhi[] = {
#endif
4.63647609000806093515e-01, /* atan(0.5)hi 0x3FDDAC67, 0x0561BB4F */
7.85398163397448278999e-01, /* atan(1.0)hi 0x3FE921FB, 0x54442D18 */
9.82793723247329054082e-01, /* atan(1.5)hi 0x3FEF730B, 0xD281F69B */
1.57079632679489655800e+00, /* atan(inf)hi 0x3FF921FB, 0x54442D18 */
};
COMPILER_STRIP_GATE(0x803A25F0, &atanhi);
/* 803A2610-803A2630 02EC70 0020+00 0/1 0/0 0/0 .rodata atanlo */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const atanlo[32] = {
0x3C, 0x7A, 0x2B, 0x7F, 0x22, 0x2F, 0x65, 0xE2, 0x3C, 0x81, 0xA6, 0x26, 0x33, 0x14, 0x5C, 0x07,
0x3C, 0x70, 0x07, 0x88, 0x7A, 0xF0, 0xCB, 0xBD, 0x3C, 0x91, 0xA6, 0x26, 0x33, 0x14, 0x5C, 0x07,
#ifdef __STDC__
static const double atanlo[] = {
#else
static double atanlo[] = {
#endif
2.26987774529616870924e-17, /* atan(0.5)lo 0x3C7A2B7F, 0x222F65E2 */
3.06161699786838301793e-17, /* atan(1.0)lo 0x3C81A626, 0x33145C07 */
1.39033110312309984516e-17, /* atan(1.5)lo 0x3C700788, 0x7AF0CBBD */
6.12323399573676603587e-17, /* atan(inf)lo 0x3C91A626, 0x33145C07 */
};
COMPILER_STRIP_GATE(0x803A2610, &atanlo);
#pragma pop
/* 803A2630-803A2688 02EC90 0058+00 0/1 0/0 0/0 .rodata aT */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const aT[88] = {
0x3F, 0xD5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x0D, 0xBF, 0xC9, 0x99, 0x99, 0x99, 0x98, 0xEB,
0xC4, 0x3F, 0xC2, 0x49, 0x24, 0x92, 0x00, 0x83, 0xFF, 0xBF, 0xBC, 0x71, 0xC6, 0xFE, 0x23,
0x16, 0x71, 0x3F, 0xB7, 0x45, 0xCD, 0xC5, 0x4C, 0x20, 0x6E, 0xBF, 0xB3, 0xB0, 0xF2, 0xAF,
0x74, 0x9A, 0x6D, 0x3F, 0xB1, 0x0D, 0x66, 0xA0, 0xD0, 0x3D, 0x51, 0xBF, 0xAD, 0xDE, 0x2D,
0x52, 0xDE, 0xFD, 0x9A, 0x3F, 0xA9, 0x7B, 0x4B, 0x24, 0x76, 0x0D, 0xEB, 0xBF, 0xA2, 0xB4,
0x44, 0x2C, 0x6A, 0x6C, 0x2F, 0x3F, 0x90, 0xAD, 0x3A, 0xE3, 0x22, 0xDA, 0x11,
#ifdef __STDC__
static const double aT[] = {
#else
static double aT[] = {
#endif
3.33333333333329318027e-01, /* 0x3FD55555, 0x5555550D */
-1.99999999998764832476e-01, /* 0xBFC99999, 0x9998EBC4 */
1.42857142725034663711e-01, /* 0x3FC24924, 0x920083FF */
-1.11111104054623557880e-01, /* 0xBFBC71C6, 0xFE231671 */
9.09088713343650656196e-02, /* 0x3FB745CD, 0xC54C206E */
-7.69187620504482999495e-02, /* 0xBFB3B0F2, 0xAF749A6D */
6.66107313738753120669e-02, /* 0x3FB10D66, 0xA0D03D51 */
-5.83357013379057348645e-02, /* 0xBFADDE2D, 0x52DEFD9A */
4.97687799461593236017e-02, /* 0x3FA97B4B, 0x24760DEB */
-3.65315727442169155270e-02, /* 0xBFA2B444, 0x2C6A6C2F */
1.62858201153657823623e-02, /* 0x3F90AD3A, 0xE322DA11 */
};
COMPILER_STRIP_GATE(0x803A2630, &aT);
#pragma pop
/* 80456AB8-80456AC0 0050B8 0008+00 1/1 0/0 0/0 .sdata2 @115 */
SECTION_SDATA2 static f64 lit_115 = 1e+300;
#ifdef __STDC__
static const double
#else
static double
#endif
one
= 1.0,
huge = 1.0e300;
/* 80456AC0-80456AC8 0050C0 0008+00 1/1 0/0 0/0 .sdata2 @116 */
SECTION_SDATA2 static f64 lit_116 = 1.0;
#ifdef __STDC__
double atan(double x)
#else
double atan(x) double x;
#endif
{
double w, s1, s2, z;
int ix, hx, id;
/* 80456AC8-80456AD0 0050C8 0008+00 1/1 0/0 0/0 .sdata2 @117 */
SECTION_SDATA2 static f64 lit_117 = 2.0;
/* 80456AD0-80456AD8 0050D0 0008+00 1/1 0/0 0/0 .sdata2 @118 */
SECTION_SDATA2 static f64 lit_118 = 1.5;
/* 80456AD8-80456AE0 0050D8 0008+00 1/1 0/0 0/0 .sdata2 @119 */
SECTION_SDATA2 static f64 lit_119 = -1.0;
/* 8036BCA4-8036BEBC 3665E4 0218+00 0/0 2/2 0/0 .text atan */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void atan() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/s_atan/atan.s"
}
#pragma pop
hx = __HI(x);
ix = hx & 0x7fffffff;
if (ix >= 0x44100000) { /* if |x| >= 2^66 */
if (ix > 0x7ff00000 || (ix == 0x7ff00000 && (__LO(x) != 0)))
return x + x; /* NaN */
if (hx > 0)
return atanhi[3] + atanlo[3];
else
return -atanhi[3] - atanlo[3];
}
if (ix < 0x3fdc0000) { /* |x| < 0.4375 */
if (ix < 0x3e200000) { /* |x| < 2^-29 */
if (huge + x > one)
return x; /* raise inexact */
}
id = -1;
} else {
x = __fabs(x);
if (ix < 0x3ff30000) { /* |x| < 1.1875 */
if (ix < 0x3fe60000) { /* 7/16 <=|x|<11/16 */
id = 0;
x = (2.0 * x - one) / (2.0 + x);
} else { /* 11/16<=|x|< 19/16 */
id = 1;
x = (x - one) / (x + one);
}
} else {
if (ix < 0x40038000) { /* |x| < 2.4375 */
id = 2;
x = (x - 1.5) / (one + 1.5 * x);
} else { /* 2.4375 <= |x| < 2^66 */
id = 3;
x = -1.0 / x;
}
}
}
/* end of argument reduction */
z = x * x;
w = z * z;
/* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
s1 = z * (aT[0] + w * (aT[2] + w * (aT[4] + w * (aT[6] + w * (aT[8] + w * aT[10])))));
s2 = w * (aT[1] + w * (aT[3] + w * (aT[5] + w * (aT[7] + w * aT[9]))));
if (id < 0)
return x - x * (s1 + s2);
else {
z = atanhi[id] - ((x * (s1 + s2) - atanlo[id]) - x);
return (hx < 0) ? -z : z;
}
}
libs/MSL_C/Math/Double_precision/s_ceil.c
+53 -53
View File
@@ -34,57 +34,57 @@ double ceil(double x)
double ceil(x) double x;
#endif
{
int i0, i1, j0;
unsigned i, j;
i0 = __HI(x);
i1 = __LO(x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
if (j0 < 20) {
if (j0 < 0) { /* raise inexact if x != 0 */
if (huge + x > 0.0) { /* return 0*sign(x) if |x|<1 */
if (i0 < 0) {
i0 = 0x80000000;
i1 = 0;
} else if ((i0 | i1) != 0) {
i0 = 0x3ff00000;
i1 = 0;
}
}
} else {
i = (0x000fffff) >> j0;
if (((i0 & i) | i1) == 0)
return x; /* x is integral */
if (huge + x > 0.0) { /* raise inexact flag */
if (i0 > 0)
i0 += (0x00100000) >> j0;
i0 &= (~i);
i1 = 0;
}
}
} else if (j0 > 51) {
if (j0 == 0x400)
return x + x; /* inf or NaN */
else
return x; /* x is integral */
} else {
i = ((unsigned)(0xffffffff)) >> (j0 - 20);
if ((i1 & i) == 0)
return x; /* x is integral */
if (huge + x > 0.0) { /* raise inexact flag */
if (i0 > 0) {
if (j0 == 20)
i0 += 1;
else {
j = i1 + (1 << (52 - j0));
if (j < i1)
i0 += 1; /* got a carry */
i1 = j;
}
}
i1 &= (~i);
}
}
__HI(x) = i0;
__LO(x) = i1;
return x;
int i0, i1, j0;
unsigned i, j;
i0 = __HI(x);
i1 = __LO(x);
j0 = ((i0 >> 20) & 0x7ff) - 0x3ff;
if (j0 < 20) {
if (j0 < 0) { /* raise inexact if x != 0 */
if (huge + x > 0.0) { /* return 0*sign(x) if |x|<1 */
if (i0 < 0) {
i0 = 0x80000000;
i1 = 0;
} else if ((i0 | i1) != 0) {
i0 = 0x3ff00000;
i1 = 0;
}
}
} else {
i = (0x000fffff) >> j0;
if (((i0 & i) | i1) == 0)
return x; /* x is integral */
if (huge + x > 0.0) { /* raise inexact flag */
if (i0 > 0)
i0 += (0x00100000) >> j0;
i0 &= (~i);
i1 = 0;
}
}
} else if (j0 > 51) {
if (j0 == 0x400)
return x + x; /* inf or NaN */
else
return x; /* x is integral */
} else {
i = ((unsigned)(0xffffffff)) >> (j0 - 20);
if ((i1 & i) == 0)
return x; /* x is integral */
if (huge + x > 0.0) { /* raise inexact flag */
if (i0 > 0) {
if (j0 == 20)
i0 += 1;
else {
j = i1 + (1 << (52 - j0));
if (j < i1)
i0 += 1; /* got a carry */
i1 = j;
}
}
i1 &= (~i);
}
}
__HI(x) = i0;
__LO(x) = i1;
return x;
}
libs/MSL_C/Math/Double_precision/s_ldexp.c
+55 -48
View File
@@ -1,52 +1,59 @@
//
// Generated By: dol2asm
// Translation Unit: Math/Double_precision/s_ldexp
//
/* @(#)s_ldexp.c 1.2 95/01/04 */
/* $Id: s_ldexp.c,v 1.3.14.1 2002/01/31 15:24:14 ceciliar Exp $ */
/*
* ====================================================
* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
*
* Developed at SunPro, a Sun Microsystems, Inc. business.
* Permission to use, copy, modify, and distribute this
* software is freely granted, provided that this notice
* is preserved.
* ====================================================
*/
#include "MSL_C/Math/Double_precision/s_ldexp.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#include "fdlibm.h"
#include "MSL_C/math.h" /* for isfinite macro */
static const double
//
// Forward References:
//
two54
= 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
twom54 = 5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
big = 1.0e+300, tiny = 1.0e-300;
void ldexp();
double ldexp(double x, int n)
{
s32 k, hx, lx; /*- cc 020130 -*/
if (!isfinite(x) || x == 0.0)
return x;
//
// External References:
//
void copysign();
//
// Declarations:
//
/* ############################################################################################## */
/* 80456B10-80456B18 005110 0008+00 1/1 0/0 0/0 .sdata2 @91 */
SECTION_SDATA2 static u8 lit_91[8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
/* 80456B18-80456B20 005118 0008+00 1/1 0/0 0/0 .sdata2 @92 */
SECTION_SDATA2 static f64 lit_92 = 1.8014398509481984e+16;
/* 80456B20-80456B28 005120 0008+00 1/1 0/0 0/0 .sdata2 @93 */
SECTION_SDATA2 static f64 lit_93 = 1e-300;
/* 80456B28-80456B30 005128 0008+00 1/1 0/0 0/0 .sdata2 @94 */
SECTION_SDATA2 static f64 lit_94 = 1e+300;
/* 80456B30-80456B38 005130 0008+00 1/1 0/0 0/0 .sdata2 @95 */
SECTION_SDATA2 static f64 lit_95 = 5.551115123125783e-17;
/* 8036C2D0-8036C494 366C10 01C4+00 0/0 3/3 0/0 .text ldexp */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void ldexp() {
nofralloc
#include "asm/MSL_C/Math/Double_precision/s_ldexp/ldexp.s"
}
#pragma pop
hx = __HI(x);
lx = __LO(x);
k = (hx & 0x7ff00000) >> 20; /* extract exponent */
if (k == 0) { /* 0 or subnormal x */
if ((lx | (hx & 0x7fffffff)) == 0)
return x; /* +-0 */
x *= two54;
hx = __HI(x);
k = ((hx & 0x7ff00000) >> 20) - 54;
if (n < -50000)
return tiny * x; /*underflow*/
}
if (k == 0x7ff)
return x + x; /* NaN or Inf */
k = k + n;
if (k > 0x7fe)
return big * copysign(big, x); /* overflow */
if (k > 0) /* normal result */
{
__HI(x) = (hx & 0x800fffff) | (k << 20);
return x;
}
if (k <= -54)
if (n > 50000) /* in case integer overflow in n+k */
return big * copysign(big, x); /*overflow*/
else
return tiny * copysign(tiny, x); /*underflow*/
k += 54; /* subnormal result */
__HI(x) = (hx & 0x800fffff) | (k << 20);
return x * twom54;
}
libs/Runtime.PPCEABI.H/CPlusLibPPC.cpp
+14 -28
View File
@@ -1,32 +1,18 @@
//
// Generated By: dol2asm
// Translation Unit: CPlusLibPPC
//
#include "Runtime.PPCEABI.H/CPlusLibPPC.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void __copy();
//
// External References:
//
//
// Declarations:
//
/* 80361C3C-80361C6C 35C57C 0030+00 0/0 0/0 4/4 .text __copy */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __copy() {
nofralloc
#include "asm/Runtime.PPCEABI.H/CPlusLibPPC/__copy.s"
extern "C" void* __copy(char *dest, char *src, size_t size) {
char *p;
if (dest && size) {
p = dest;
do {
*p = *src;
++p;
++src;
--size;
} while (size);
}
return(dest);
}
#pragma pop
libs/Runtime.PPCEABI.H/GCN_Mem_Alloc.c
+36
View File
@@ -0,0 +1,36 @@
/**
* GCN_Mem_Alloc.c
* Description:
*/
#include "Runtime.PPCEABI.H/GCN_mem_alloc.h"
#include "dolphin/os/OS.h"
inline static void InitDefaultHeap(void) {
void* arenaLo;
void* arenaHi;
OSReport("GCN_Mem_Alloc.c : InitDefaultHeap. No Heap Available\n");
OSReport("Metrowerks CW runtime library initializing default heap\n");
arenaLo = OSGetArenaLo();
arenaHi = OSGetArenaHi();
arenaLo = OSInitAlloc(arenaLo, arenaHi, 1);
OSSetArenaLo(arenaLo);
arenaLo = OSRoundUpPtr(arenaLo, 0x20);
arenaHi = OSRoundDownPtr(arenaHi, 0x20);
OSSetCurrentHeap(OSCreateHeap(arenaLo, arenaHi));
OSSetArenaLo(arenaLo = arenaHi);
}
/* 80362914-803629CC 35D254 00B8+00 0/0 1/1 0/0 .text __sys_free */
void __sys_free(void* p) {
if (__OSCurrHeap == -1) {
InitDefaultHeap();
}
OSFreeToHeap(__OSCurrHeap, p);
}
libs/Runtime.PPCEABI.H/GCN_mem_alloc.cpp
-175
View File
@@ -1,175 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: GCN_mem_alloc
//
#include "Runtime.PPCEABI.H/GCN_mem_alloc.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void __sys_free();
//
// External References:
//
extern "C" void OSReport();
extern "C" void OSFreeToHeap();
extern "C" void OSSetCurrentHeap();
extern "C" void OSInitAlloc();
extern "C" void OSCreateHeap();
extern "C" void OSGetArenaHi();
extern "C" void OSGetArenaLo();
extern "C" void OSSetArenaLo();
extern "C" extern u32 __OSCurrHeap[1 + 1 /* padding */];
//
// Declarations:
//
/* ############################################################################################## */
/* 803A21A8-803A21E0 02E808 0036+02 1/1 0/0 0/0 .rodata @55 */
SECTION_RODATA static u8 const lit_55[54 + 2 /* padding */] = {
0x47,
0x43,
0x4E,
0x5F,
0x4D,
0x65,
0x6D,
0x5F,
0x41,
0x6C,
0x6C,
0x6F,
0x63,
0x2E,
0x63,
0x20,
0x3A,
0x20,
0x49,
0x6E,
0x69,
0x74,
0x44,
0x65,
0x66,
0x61,
0x75,
0x6C,
0x74,
0x48,
0x65,
0x61,
0x70,
0x2E,
0x20,
0x4E,
0x6F,
0x20,
0x48,
0x65,
0x61,
0x70,
0x20,
0x41,
0x76,
0x61,
0x69,
0x6C,
0x61,
0x62,
0x6C,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A21A8, &lit_55);
/* 803A21E0-803A2220 02E840 0039+07 1/1 0/0 0/0 .rodata @56 */
SECTION_RODATA static u8 const lit_56[57 + 7 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x77,
0x65,
0x72,
0x6B,
0x73,
0x20,
0x43,
0x57,
0x20,
0x72,
0x75,
0x6E,
0x74,
0x69,
0x6D,
0x65,
0x20,
0x6C,
0x69,
0x62,
0x72,
0x61,
0x72,
0x79,
0x20,
0x69,
0x6E,
0x69,
0x74,
0x69,
0x61,
0x6C,
0x69,
0x7A,
0x69,
0x6E,
0x67,
0x20,
0x64,
0x65,
0x66,
0x61,
0x75,
0x6C,
0x74,
0x20,
0x68,
0x65,
0x61,
0x70,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A21E0, &lit_56);
/* 80362914-803629CC 35D254 00B8+00 0/0 1/1 0/0 .text __sys_free */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __sys_free() {
nofralloc
#include "asm/Runtime.PPCEABI.H/GCN_mem_alloc/__sys_free.s"
}
#pragma pop
libs/Runtime.PPCEABI.H/Makefile
+14 -4
View File
@@ -3,15 +3,15 @@
#
LIBRUNTIME_PPCEABI_H_A_CPP_FILES := \
libs/Runtime.PPCEABI.H/__va_arg.cpp \
libs/Runtime.PPCEABI.H/__va_arg.c \
libs/Runtime.PPCEABI.H/global_destructor_chain.cpp \
libs/Runtime.PPCEABI.H/CPlusLibPPC.cpp \
libs/Runtime.PPCEABI.H/NMWException.cpp \
libs/Runtime.PPCEABI.H/ptmf.cpp \
libs/Runtime.PPCEABI.H/ptmf.c \
libs/Runtime.PPCEABI.H/runtime.cpp \
libs/Runtime.PPCEABI.H/__init_cpp_exceptions.cpp \
libs/Runtime.PPCEABI.H/Gecko_ExceptionPPC.cpp \
libs/Runtime.PPCEABI.H/GCN_mem_alloc.cpp \
libs/Runtime.PPCEABI.H/GCN_Mem_Alloc.c \
LIBRUNTIME_PPCEABI_H_A_O_FILES := \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/__va_arg.o \
@@ -22,9 +22,10 @@ LIBRUNTIME_PPCEABI_H_A_O_FILES := \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/runtime.o \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/__init_cpp_exceptions.o \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/Gecko_ExceptionPPC.o \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/GCN_mem_alloc.o \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/GCN_Mem_Alloc.o \
LIBRUNTIME_PPCEABI_H_A_CFLAGS := \
-O4,p \
LIBRUNTIME_PPCEABI_H_A_LDFLAGS := \
-nodefaults \
@@ -32,6 +33,10 @@ LIBRUNTIME_PPCEABI_H_A_LDFLAGS := \
-proc gekko \
-linkmode moreram \
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/GCN_Mem_Alloc.o: CFLAGS := -Cpp_exceptions off -proc gekko -fp hard -O4,p -nodefaults -str readonly -RTTI off -maxerrors 5 -enum int $(INCLUDES) -lang=c
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/__va_arg.o: CFLAGS := -Cpp_exceptions off -proc gekko -fp hard -O4,p -nodefaults -str pool,readonly,reuse -RTTI off -maxerrors 5 -enum int $(INCLUDES) -lang=c
$(BUILD_DIR)/libRuntime.PPCEABI.H.a: $(LIBRUNTIME_PPCEABI_H_A_O_FILES)
@echo linking... $(BUILD_DIR)/libRuntime.PPCEABI.H.a
@echo $(LIBRUNTIME_PPCEABI_H_A_O_FILES) > build/LIBRUNTIME_PPCEABI_H_A_ofiles
@@ -43,3 +48,8 @@ $(BUILD_DIR)/libs/Runtime.PPCEABI.H/%.o: libs/Runtime.PPCEABI.H/%.cpp
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).cpp
@$(CC) $(CFLAGS) $(LIBRUNTIME_PPCEABI_H_A_CFLAGS) -c -o $@ $(basename $@).cpp
$(BUILD_DIR)/libs/Runtime.PPCEABI.H/%.o: libs/Runtime.PPCEABI.H/%.c
@mkdir -p $(@D)
@echo building... $<
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).c
@$(CC) $(CFLAGS) -c -o $@ $(basename $@).c
libs/Runtime.PPCEABI.H/__init_cpp_exceptions.cpp
+1 -5
View File
@@ -52,11 +52,7 @@ SECTION_DTORS15 extern void* const __dtors_null_terminator = (void*)NULL;
/* ############################################################################################## */
/* 80450AD0-80450AD8 000550 0004+04 2/2 0/0 0/0 .sdata fragmentID */
SECTION_SDATA static u32 fragmentID[1 + 1 /* padding */] = {
0xFFFFFFFE,
/* padding */
0x00000000,
};
SECTION_SDATA static int fragmentID = -2;
/* 8036283C-80362870 35D17C 0034+00 1/0 1/0 0/0 .text __fini_cpp_exceptions */
#pragma push
libs/Runtime.PPCEABI.H/__va_arg.c
+50
View File
@@ -0,0 +1,50 @@
#include "Runtime.PPCEABI.H/__va_arg.h"
#undef __va_arg
/* 80361B14-80361BDC 35C454 00C8+00 0/0 3/3 0/0 .text __va_arg */
void* __va_arg(_va_list_struct* list, int type) {
char* addr;
char* reg = &(list->gpr);
int g_reg = list->gpr;
int maxsize = 8;
int size = 4;
int increment = 1;
int even = 0;
int fpr_offset = 0;
int regsize = 4;
if (type == 3) {
reg = &(list->fpr);
g_reg = list->fpr;
size = 8;
fpr_offset = 32;
regsize = 8;
}
if (type == 2) {
size = 8;
maxsize--;
if (g_reg & 1) {
even = 1;
}
increment = 2;
}
if (g_reg < maxsize) {
g_reg += even;
addr = list->reg_save_area + fpr_offset + (g_reg * regsize);
*reg = g_reg + increment;
} else {
*reg = 8;
addr = list->input_arg_area;
addr = (char*)(((u32)(addr) + ((size)-1)) & ~((size)-1));
list->input_arg_area = addr + size;
}
if (type == 0) {
addr = *((char**)addr);
}
return addr;
}
libs/Runtime.PPCEABI.H/__va_arg.cpp
-32
View File
@@ -1,32 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: __va_arg
//
#include "Runtime.PPCEABI.H/__va_arg.h"
#include "dol2asm.h"
#include "dolphin/types.h"
#undef __va_arg
//
// Forward References:
//
//
// External References:
//
//
// Declarations:
//
/* 80361B14-80361BDC 35C454 00C8+00 0/0 3/3 0/0 .text __va_arg */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __va_arg(void*, int) {
nofralloc
#include "asm/Runtime.PPCEABI.H/__va_arg/__va_arg.s"
}
#pragma pop
libs/Runtime.PPCEABI.H/ptmf.c
+73
View File
@@ -0,0 +1,73 @@
#include "Runtime.PPCEABI.H/ptmf.h"
/* ############################################################################################## */
/* 803A2180-803A2190 02E7E0 000C+04 0/0 23/23 249/249 .rodata __ptmf_null */
__ptmf const __ptmf_null = {
0,
0,
0,
};
/* 80362018-80362048 35C958 0030+00 0/0 10/10 345/345 .text __ptmf_test */
asm long __ptmf_test(register __ptmf* ptmf) {
// clang-format off
nofralloc
lwz r5, __ptmf.this_delta(r3)
lwz r6, __ptmf.v_offset(r3)
lwz r7, __ptmf.f_data(r3)
li r3, 1
cmpwi r5, 0
cmpwi cr6, r6, 0
cmpwi cr7, r7, 0
bnelr
bnelr cr6
bnelr cr7
li r3, 0
blr
// clang-format on
}
/* 80362048-80362084 35C988 003C+00 0/0 0/0 217/217 .text __ptmf_cmpr */
asm long __ptmf_cmpr(void) {
// clang-format off
nofralloc
lwz r5, 0(r3)
lwz r6, 0(r4)
lwz r7, 4(r3)
lwz r8, 4(r4)
lwz r9, 8(r3)
lwz r10, 8(r4)
li r3, 1
cmpw r5, r6
cmpw cr6, r7, r8
cmpw cr7, r9, r10
bnelr
bnelr cr6
bnelr cr7
li r3, 0
blr
// clang-format on
}
/* 80362084-803620AC 35C9C4 0028+00 0/0 125/125 741/741 .text __ptmf_scall */
asm void __ptmf_scall(...) {
// clang-format off
nofralloc
lwz r0, 0(r12)
lwz r11, 4(r12)
lwz r12, 8(r12)
add r3, r3, r0
cmpwi r11, 0
blt lbl_803620A4
lwzx r12, r3, r12
lwzx r12, r12, r11
lbl_803620A4:
mtctr r12
bctr
// clang-format on
}
libs/Runtime.PPCEABI.H/ptmf.cpp
-78
View File
@@ -1,78 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: ptmf
//
#include "Runtime.PPCEABI.H/ptmf.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void __ptmf_test();
extern "C" void __ptmf_cmpr();
extern "C" void __ptmf_scall();
extern "C" extern u8 const __ptmf_null[12 + 4 /* padding */];
//
// External References:
//
//
// Declarations:
//
/* 80362018-80362048 35C958 0030+00 0/0 10/10 345/345 .text __ptmf_test */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ptmf_test() {
nofralloc
#include "asm/Runtime.PPCEABI.H/ptmf/__ptmf_test.s"
}
#pragma pop
/* 80362048-80362084 35C988 003C+00 0/0 0/0 217/217 .text __ptmf_cmpr */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ptmf_cmpr() {
nofralloc
#include "asm/Runtime.PPCEABI.H/ptmf/__ptmf_cmpr.s"
}
#pragma pop
/* 80362084-803620AC 35C9C4 0028+00 0/0 125/125 741/741 .text __ptmf_scall */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void __ptmf_scall() {
nofralloc
#include "asm/Runtime.PPCEABI.H/ptmf/__ptmf_scall.s"
}
#pragma pop
/* ############################################################################################## */
/* 803A2180-803A2190 02E7E0 000C+04 0/0 23/23 249/249 .rodata __ptmf_null */
SECTION_RODATA extern u8 const __ptmf_null[12 + 4 /* padding */] = {
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2180, &__ptmf_null);
libs/SSystem/SComponent/c_bg_s_lin_chk.cpp
+2 -2
View File
@@ -24,7 +24,7 @@ cBgS_LinChk::~cBgS_LinChk() {}
/* 80267E48-80267ED0 262788 0088+00 1/1 0/0 0/0 .text ct__11cBgS_LinChkFv */
void cBgS_LinChk::ct() {
cXyz xyz(cXyz::Zero);
mLinP.SetStartEnd(xyz, xyz);
mLin.SetStartEnd(xyz, xyz);
field_0x40 = xyz;
setActorPid(0xFFFFFFFF);
field_0x4c = 0;
@@ -34,7 +34,7 @@ void cBgS_LinChk::ct() {
/* 80267ED0-80267F40 262810 0070+00 0/0 2/2 0/0 .text Set2__11cBgS_LinChkFPC4cXyzPC4cXyzUi */
void cBgS_LinChk::Set2(cXyz const* pStart, cXyz const* pEnd, unsigned int actorPid) {
mLinP.SetStartEnd(*pStart, *pEnd);
mLin.SetStartEnd(*pStart, *pEnd);
field_0x40 = *pEnd;
setActorPid(actorPid);
field_0x4c &= ~0x10;
libs/SSystem/SComponent/c_lib.cpp
+1 -1
View File
@@ -334,7 +334,7 @@ s16 cLib_targetAngleY(const Vec& lhs, const Vec& rhs) {
s16 cLib_targetAngleX(cXyz const* param_0, cXyz const* param_1) {
cXyz diff = *param_1 - *param_0;
f32 f1 = sqrtf(diff.getMagXZ());
return cM_atan2s(diff.GetY(), f1);
return cM_atan2s(diff.y, f1);
}
/* 80270DC0-80270E24 26B700 0064+00 0/0 2/2 118/118 .text cLib_offsetPos__FP4cXyzPC4cXyzsPC4cXyz
libs/SSystem/SComponent/c_m3d.cpp
+36 -36
View File
@@ -317,17 +317,17 @@ bool cM3d_Cross_AabCyl(const cM3dGAab* pAab, const cM3dGCyl* pCyl) {
#ifdef NONMATCHING
bool cM3d_Cross_AabSph(const cM3dGAab* pAab, const cM3dGSph* pSph) {
f32 radius = pSph->GetR();
if (pAab->GetMinX() > pSph->GetC().GetX() + radius) { // addition registers are flipped
if (pAab->GetMinX() > pSph->GetC().x + radius) { // addition registers are flipped
return false;
} else if (pAab->GetMaxX() < pSph->GetC().GetX() - radius) {
} else if (pAab->GetMaxX() < pSph->GetC().x - radius) {
return false;
} else if (pAab->GetMinZ() > pSph->GetC().GetZ() + radius) {
} else if (pAab->GetMinZ() > pSph->GetC().z + radius) {
return false;
} else if (pAab->GetMaxZ() < pSph->GetC().GetZ() - radius) {
} else if (pAab->GetMaxZ() < pSph->GetC().z - radius) {
return false;
} else if (pAab->GetMinY() > pSph->GetC().GetY() + radius) {
} else if (pAab->GetMinY() > pSph->GetC().y + radius) {
return false;
} else if (pAab->GetMaxY() < pSph->GetC().GetY() - radius) {
} else if (pAab->GetMaxY() < pSph->GetC().y - radius) {
return false;
} else {
return true;
@@ -564,51 +564,51 @@ asm bool cM3d_Cross_MinMaxBoxLine(Vec const* param_0, Vec const* param_1, Vec co
bool cM3d_InclusionCheckPosIn3PosBox3d(const Vec* pVecA, const Vec* pVecB, const Vec* pVecC,
const Vec* pVecD, f32 pF) {
f32 min, max;
if (pVecA->GetX() < pVecB->GetX()) {
min = pVecA->GetX();
max = pVecB->GetX();
if (pVecA->x < pVecB->x) {
min = pVecA->x;
max = pVecB->x;
} else {
min = pVecB->GetX();
max = pVecA->GetX();
min = pVecB->x;
max = pVecA->x;
}
if (min > pVecC->GetX()) {
min = pVecC->GetX();
} else if (max < pVecC->GetX()) {
max = pVecC->GetX();
if (min > pVecC->x) {
min = pVecC->x;
} else if (max < pVecC->x) {
max = pVecC->x;
}
if (min - pF > pVecD->GetX() || max + pF < pVecD->GetX()) {
if (min - pF > pVecD->x || max + pF < pVecD->x) {
return false;
}
if (pVecA->GetZ() < pVecB->GetZ()) {
min = pVecA->GetZ();
max = pVecB->GetZ();
if (pVecA->z < pVecB->z) {
min = pVecA->z;
max = pVecB->z;
} else {
min = pVecB->GetZ();
max = pVecA->GetZ();
min = pVecB->z;
max = pVecA->z;
}
if (min > pVecC->GetZ()) {
min = pVecC->GetZ();
} else if (max < pVecC->GetZ()) {
max = pVecC->GetZ();
if (min > pVecC->z) {
min = pVecC->z;
} else if (max < pVecC->z) {
max = pVecC->z;
}
if (min - pF > pVecD->GetZ() || max + pF < pVecD->GetZ()) {
if (min - pF > pVecD->z || max + pF < pVecD->z) {
return false;
}
if (pVecA->GetY() < pVecB->GetY()) {
min = pVecA->GetY();
max = pVecB->GetY();
if (pVecA->y < pVecB->y) {
min = pVecA->y;
max = pVecB->y;
} else {
min = pVecB->GetY();
max = pVecA->GetY();
min = pVecB->y;
max = pVecA->y;
}
if (min > pVecC->GetY()) {
min = pVecC->GetY();
} else if (max < pVecC->GetY()) {
max = pVecC->GetY();
if (min > pVecC->y) {
min = pVecC->y;
} else if (max < pVecC->y) {
max = pVecC->y;
}
if (min - pF > pVecD->GetY() || max + pF < pVecD->GetY()) {
if (min - pF > pVecD->y || max + pF < pVecD->y) {
return false;
}
return true;
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_DDH_GCN/main.cpp → libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_DDH_GCN/main.c
+46 -209
View File
@@ -11,38 +11,51 @@
// Forward References:
//
extern "C" void ddh_cc_initinterrupts();
extern "C" void ddh_cc_peek();
extern "C" void ddh_cc_post_stop();
extern "C" void ddh_cc_pre_continue();
extern "C" void ddh_cc_write();
extern "C" void ddh_cc_read();
extern "C" bool ddh_cc_close();
extern "C" void ddh_cc_open();
extern "C" bool ddh_cc_shutdown();
extern "C" void ddh_cc_initialize();
void ddh_cc_initinterrupts();
void ddh_cc_peek();
void ddh_cc_post_stop();
void ddh_cc_pre_continue();
void ddh_cc_write();
void ddh_cc_read();
u8 ddh_cc_close();
void ddh_cc_open();
u8 ddh_cc_shutdown();
void ddh_cc_initialize();
//
// External References:
//
extern "C" void CircleBufferReadBytes();
extern "C" void CircleBufferWriteBytes();
extern "C" void CircleBufferInitialize();
extern "C" void CBGetBytesAvailableForRead();
extern "C" void MWTRACE();
extern "C" void EXI2_Init();
extern "C" void EXI2_EnableInterrupts();
extern "C" bool EXI2_Poll();
extern "C" bool EXI2_ReadN();
extern "C" bool EXI2_WriteN();
extern "C" void EXI2_Reserve();
extern "C" void EXI2_Unreserve();
void CircleBufferReadBytes();
void CircleBufferWriteBytes();
void CircleBufferInitialize();
void CBGetBytesAvailableForRead();
void MWTRACE();
void EXI2_Init();
void EXI2_EnableInterrupts();
u8 EXI2_Poll();
u8 EXI2_ReadN();
u8 EXI2_WriteN();
void EXI2_Reserve();
void EXI2_Unreserve();
//
// Declarations:
//
/* ############################################################################################## */
/* 8044F830-80450030 07C550 0800+00 1/1 0/0 0/0 .bss gRecvBuf */
static u8 gRecvBuf[2048];
/* 80450030-80450050 07CD50 001C+04 3/3 0/0 0/0 .bss gRecvCB */
static u8 gRecvCB[28 + 4 /* padding */];
// copied from pikmin2. should try to find a real fix
static makeMainBSSOrderingWork() {
u8 buff[0x500];
memcpy(buff, gRecvBuf, 0x500);
}
/* 8037235C-80372380 36CC9C 0024+00 0/0 1/1 0/0 .text ddh_cc_initinterrupts */
#pragma push
#pragma optimization_level 0
@@ -53,13 +66,6 @@ asm void ddh_cc_initinterrupts() {
}
#pragma pop
/* ############################################################################################## */
/* 8044F830-80450030 07C550 0800+00 1/1 0/0 0/0 .bss gRecvBuf */
static u8 gRecvBuf[2048];
/* 80450030-80450050 07CD50 001C+04 3/3 0/0 0/0 .bss gRecvCB */
static u8 gRecvCB[28 + 4 /* padding */];
/* 80372380-803723F0 36CCC0 0070+00 0/0 1/1 0/0 .text ddh_cc_peek */
#pragma push
#pragma optimization_level 0
@@ -92,72 +98,20 @@ asm void ddh_cc_pre_continue() {
/* ############################################################################################## */
/* 803A2D10-803A2D24 02F370 0014+00 1/1 0/0 0/0 .rodata @318 */
SECTION_RODATA static u8 const lit_318[20] = {
0x63, 0x63, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x69, 0x6E, 0x69,
0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x65, 0x64, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_318[] = "cc not initialized\n";
COMPILER_STRIP_GATE(0x803A2D10, &lit_318);
/* 803A2D24-803A2D50 02F384 0029+03 0/1 0/0 0/0 .rodata @319 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_319[41 + 3 /* padding */] = {
0x63,
0x63,
0x5F,
0x77,
0x72,
0x69,
0x74,
0x65,
0x20,
0x3A,
0x20,
0x4F,
0x75,
0x74,
0x70,
0x75,
0x74,
0x20,
0x64,
0x61,
0x74,
0x61,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_319[] = "cc_write : Output data 0x%08x %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2D24, &lit_319);
#pragma pop
/* 803A2D50-803A2D6C 02F3B0 001C+00 0/1 0/0 0/0 .rodata @320 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_320[28] = {
0x63, 0x63, 0x5F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x73, 0x65, 0x6E, 0x64, 0x69,
0x6E, 0x67, 0x20, 0x25, 0x6C, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_320[] = "cc_write sending %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2D50, &lit_320);
#pragma pop
@@ -176,103 +130,11 @@ asm void ddh_cc_write() {
/* ############################################################################################## */
/* 803A2D6C-803A2D94 02F3CC 0025+03 1/1 0/0 0/0 .rodata @342 */
SECTION_RODATA static u8 const lit_342[37 + 3 /* padding */] = {
0x45,
0x78,
0x70,
0x65,
0x63,
0x74,
0x65,
0x64,
0x20,
0x70,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x20,
0x73,
0x69,
0x7A,
0x65,
0x20,
0x3A,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x28,
0x25,
0x6C,
0x64,
0x29,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_342[] = "Expected packet size : 0x%08x (%ld)\n";
COMPILER_STRIP_GATE(0x803A2D6C, &lit_342);
/* 803A2D94-803A2DC4 02F3F4 002D+03 1/1 0/0 0/0 .rodata @343 */
SECTION_RODATA static u8 const lit_343[45 + 3 /* padding */] = {
0x63,
0x63,
0x5F,
0x72,
0x65,
0x61,
0x64,
0x20,
0x3A,
0x20,
0x65,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x72,
0x65,
0x61,
0x64,
0x69,
0x6E,
0x67,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x20,
0x66,
0x72,
0x6F,
0x6D,
0x20,
0x45,
0x58,
0x49,
0x32,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_343[] = "cc_read : error reading bytes from EXI2 %ld\n";
COMPILER_STRIP_GATE(0x803A2D94, &lit_343);
/* 803724F8-803725E4 36CE38 00EC+00 0/0 1/1 0/0 .text ddh_cc_read */
@@ -286,8 +148,8 @@ asm void ddh_cc_read() {
#pragma pop
/* 803725E4-803725EC 36CF24 0008+00 0/0 1/1 0/0 .text ddh_cc_close */
bool ddh_cc_close() {
return false;
u8 ddh_cc_close() {
return 0;
}
/* 803725EC-80372610 36CF2C 0024+00 0/0 1/1 0/0 .text ddh_cc_open */
@@ -301,42 +163,17 @@ asm void ddh_cc_open() {
#pragma pop
/* 80372610-80372618 36CF50 0008+00 0/0 1/1 0/0 .text ddh_cc_shutdown */
bool ddh_cc_shutdown() {
return false;
u8 ddh_cc_shutdown() {
return 0;
}
/* ############################################################################################## */
/* 803A2DC4-803A2DD8 02F424 0013+01 1/1 0/0 0/0 .rodata @349 */
SECTION_RODATA static u8 const lit_349[19 + 1 /* padding */] = {
0x43,
0x41,
0x4C,
0x4C,
0x49,
0x4E,
0x47,
0x20,
0x45,
0x58,
0x49,
0x32,
0x5F,
0x49,
0x6E,
0x69,
0x74,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_349[] = "CALLING EXI2_Init\n";
COMPILER_STRIP_GATE(0x803A2DC4, &lit_349);
/* 803A2DD8-803A2DF0 02F438 0018+00 1/1 0/0 0/0 .rodata @350 */
SECTION_RODATA static u8 const lit_350[24] = {
0x44, 0x4F, 0x4E, 0x45, 0x20, 0x43, 0x41, 0x4C, 0x4C, 0x49, 0x4E, 0x47,
0x20, 0x45, 0x58, 0x49, 0x32, 0x5F, 0x49, 0x6E, 0x69, 0x74, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_350[] = "DONE CALLING EXI2_Init\n";
COMPILER_STRIP_GATE(0x803A2DD8, &lit_350);
/* 80372618-803726A0 36CF58 0088+00 0/0 1/1 0/0 .text ddh_cc_initialize */
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_GDEV_GCN/main.cpp → libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_GDEV_GCN/main.c
+46 -209
View File
@@ -11,38 +11,51 @@
// Forward References:
//
extern "C" void gdev_cc_initinterrupts();
extern "C" void gdev_cc_peek();
extern "C" void gdev_cc_post_stop();
extern "C" void gdev_cc_pre_continue();
extern "C" void gdev_cc_write();
extern "C" void gdev_cc_read();
extern "C" bool gdev_cc_close();
extern "C" void gdev_cc_open();
extern "C" bool gdev_cc_shutdown();
extern "C" void gdev_cc_initialize();
void gdev_cc_initinterrupts();
void gdev_cc_peek();
void gdev_cc_post_stop();
void gdev_cc_pre_continue();
void gdev_cc_write();
void gdev_cc_read();
u8 gdev_cc_close();
void gdev_cc_open();
u8 gdev_cc_shutdown();
void gdev_cc_initialize();
//
// External References:
//
extern "C" void CircleBufferReadBytes();
extern "C" void CircleBufferWriteBytes();
extern "C" void CircleBufferInitialize();
extern "C" void CBGetBytesAvailableForRead();
extern "C" void MWTRACE();
extern "C" void DBClose();
extern "C" void DBOpen();
extern "C" void DBWrite();
extern "C" void DBRead();
extern "C" void DBQueryData();
extern "C" void DBInitInterrupts();
extern "C" void DBInitComm();
void CircleBufferReadBytes();
void CircleBufferWriteBytes();
void CircleBufferInitialize();
void CBGetBytesAvailableForRead();
void MWTRACE();
void DBClose();
void DBOpen();
void DBWrite();
void DBRead();
void DBQueryData();
void DBInitInterrupts();
void DBInitComm();
//
// Declarations:
//
/* ############################################################################################## */
/* 80450050-80450550 07CD70 0500+00 1/1 0/0 0/0 .bss gRecvBuf */
static u8 gRecvBuf[1280];
/* 80450550-8045056C 07D270 001C+00 3/3 0/0 0/0 .bss gRecvCB */
static u8 gRecvCB[28];
// copied from pikmin2. should try to find a real fix
static makeMainBSSOrderingWork() {
u8 buff[0x500];
memcpy(buff, gRecvBuf, 0x500);
}
/* 80372908-8037292C 36D248 0024+00 0/0 1/1 0/0 .text gdev_cc_initinterrupts */
#pragma push
#pragma optimization_level 0
@@ -53,13 +66,6 @@ asm void gdev_cc_initinterrupts() {
}
#pragma pop
/* ############################################################################################## */
/* 80450050-80450550 07CD70 0500+00 1/1 0/0 0/0 .bss gRecvBuf */
static u8 gRecvBuf[1280];
/* 80450550-8045056C 07D270 001C+00 3/3 0/0 0/0 .bss gRecvCB */
static u8 gRecvCB[28];
/* 8037292C-8037299C 36D26C 0070+00 0/0 1/1 0/0 .text gdev_cc_peek */
#pragma push
#pragma optimization_level 0
@@ -92,72 +98,20 @@ asm void gdev_cc_pre_continue() {
/* ############################################################################################## */
/* 803A2DF0-803A2E04 02F450 0014+00 1/1 0/0 0/0 .rodata @318 */
SECTION_RODATA static u8 const lit_318[20] = {
0x63, 0x63, 0x20, 0x6E, 0x6F, 0x74, 0x20, 0x69, 0x6E, 0x69,
0x74, 0x69, 0x61, 0x6C, 0x69, 0x7A, 0x65, 0x64, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_318[] = "cc not initialized\n";
COMPILER_STRIP_GATE(0x803A2DF0, &lit_318);
/* 803A2E04-803A2E30 02F464 0029+03 0/1 0/0 0/0 .rodata @319 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_319[41 + 3 /* padding */] = {
0x63,
0x63,
0x5F,
0x77,
0x72,
0x69,
0x74,
0x65,
0x20,
0x3A,
0x20,
0x4F,
0x75,
0x74,
0x70,
0x75,
0x74,
0x20,
0x64,
0x61,
0x74,
0x61,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_319[] = "cc_write : Output data 0x%08x %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2E04, &lit_319);
#pragma pop
/* 803A2E30-803A2E4C 02F490 001C+00 0/1 0/0 0/0 .rodata @320 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_320[28] = {
0x63, 0x63, 0x5F, 0x77, 0x72, 0x69, 0x74, 0x65, 0x20, 0x73, 0x65, 0x6E, 0x64, 0x69,
0x6E, 0x67, 0x20, 0x25, 0x6C, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0A, 0x00,
};
SECTION_RODATA static u8 const lit_320[] = "cc_write sending %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2E30, &lit_320);
#pragma pop
@@ -176,103 +130,11 @@ asm void gdev_cc_write() {
/* ############################################################################################## */
/* 803A2E4C-803A2E74 02F4AC 0025+03 1/1 0/0 0/0 .rodata @341 */
SECTION_RODATA static u8 const lit_341[37 + 3 /* padding */] = {
0x45,
0x78,
0x70,
0x65,
0x63,
0x74,
0x65,
0x64,
0x20,
0x70,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x20,
0x73,
0x69,
0x7A,
0x65,
0x20,
0x3A,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x28,
0x25,
0x6C,
0x64,
0x29,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_341[] = "Expected packet size : 0x%08x (%ld)\n";
COMPILER_STRIP_GATE(0x803A2E4C, &lit_341);
/* 803A2E74-803A2EA4 02F4D4 002D+03 1/1 0/0 0/0 .rodata @342 */
SECTION_RODATA static u8 const lit_342[45 + 3 /* padding */] = {
0x63,
0x63,
0x5F,
0x72,
0x65,
0x61,
0x64,
0x20,
0x3A,
0x20,
0x65,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x72,
0x65,
0x61,
0x64,
0x69,
0x6E,
0x67,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x20,
0x66,
0x72,
0x6F,
0x6D,
0x20,
0x45,
0x58,
0x49,
0x32,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_342[] = "cc_read : error reading bytes from EXI2 %ld\n";
COMPILER_STRIP_GATE(0x803A2E74, &lit_342);
/* 80372AA4-80372B98 36D3E4 00F4+00 0/0 1/1 0/0 .text gdev_cc_read */
@@ -286,8 +148,8 @@ asm void gdev_cc_read() {
#pragma pop
/* 80372B98-80372BA0 36D4D8 0008+00 0/0 1/1 0/0 .text gdev_cc_close */
bool gdev_cc_close() {
return false;
u8 gdev_cc_close() {
return 0;
}
/* 80372BA0-80372BC4 36D4E0 0024+00 0/0 1/1 0/0 .text gdev_cc_open */
@@ -301,42 +163,17 @@ asm void gdev_cc_open() {
#pragma pop
/* 80372BC4-80372BCC 36D504 0008+00 0/0 1/1 0/0 .text gdev_cc_shutdown */
bool gdev_cc_shutdown() {
return false;
u8 gdev_cc_shutdown() {
return 0;
}
/* ############################################################################################## */
/* 803A2EA4-803A2EB8 02F504 0013+01 1/1 0/0 0/0 .rodata @348 */
SECTION_RODATA static u8 const lit_348[19 + 1 /* padding */] = {
0x43,
0x41,
0x4C,
0x4C,
0x49,
0x4E,
0x47,
0x20,
0x45,
0x58,
0x49,
0x32,
0x5F,
0x49,
0x6E,
0x69,
0x74,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_348[] = "CALLING EXI2_Init\n";
COMPILER_STRIP_GATE(0x803A2EA4, &lit_348);
/* 803A2EB8-803A2ED0 02F518 0018+00 1/1 0/0 0/0 .rodata @349 */
SECTION_RODATA static u8 const lit_349[24] = {
0x44, 0x4F, 0x4E, 0x45, 0x20, 0x43, 0x41, 0x4C, 0x4C, 0x49, 0x4E, 0x47,
0x20, 0x45, 0x58, 0x49, 0x32, 0x5F, 0x49, 0x6E, 0x69, 0x74, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_349[] = "DONE CALLING EXI2_Init\n";
COMPILER_STRIP_GATE(0x803A2EB8, &lit_349);
/* 80372BCC-80372C54 36D50C 0088+00 0/0 1/1 0/0 .text gdev_cc_initialize */
libs/TRK_MINNOW_DOLPHIN/Makefile
+37 -33
View File
@@ -3,35 +3,35 @@
#
LIBTRK_MINNOW_DOLPHIN_A_CPP_FILES := \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.cpp \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.cpp \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.cpp \
libs/TRK_MINNOW_DOLPHIN/ppc/Export/targsupp.cpp \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Export/mslsupp.cpp \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/UDP_Stubs.cpp \
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_DDH_GCN/main.cpp \
libs/TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.cpp \
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_GDEV_GCN/main.cpp \
libs/TRK_MINNOW_DOLPHIN/utils/common/MWTrace.cpp \
libs/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.cpp \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.c \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.c \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.c \
libs/TRK_MINNOW_DOLPHIN/ppc/Export/targsupp.c \
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.c \
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Export/mslsupp.c \
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/UDP_Stubs.c \
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_DDH_GCN/main.c \
libs/TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.c \
libs/TRK_MINNOW_DOLPHIN/GCN/EXI2_GDEV_GCN/main.c \
libs/TRK_MINNOW_DOLPHIN/utils/common/MWTrace.c \
libs/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.c \
LIBTRK_MINNOW_DOLPHIN_A_O_FILES := \
$(BUILD_DIR)/libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.o \
@@ -65,6 +65,9 @@ LIBTRK_MINNOW_DOLPHIN_A_O_FILES := \
$(BUILD_DIR)/libs/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.o \
LIBTRK_MINNOW_DOLPHIN_A_CFLAGS := \
-O4,p \
-lang=c \
-rostr
LIBTRK_MINNOW_DOLPHIN_A_LDFLAGS := \
-nodefaults \
@@ -72,14 +75,15 @@ LIBTRK_MINNOW_DOLPHIN_A_LDFLAGS := \
-proc gekko \
-linkmode moreram \
$(BUILD_DIR)/libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.o: CFLAGS := -Cpp_exceptions off -proc gekko -fp hard -O4,p -nodefaults -str reuse -RTTI off -maxerrors 5 -enum int $(INCLUDES) -lang=c
$(BUILD_DIR)/libTRK_MINNOW_DOLPHIN.a: $(LIBTRK_MINNOW_DOLPHIN_A_O_FILES)
@echo linking... $(BUILD_DIR)/libTRK_MINNOW_DOLPHIN.a
@echo $(LIBTRK_MINNOW_DOLPHIN_A_O_FILES) > build/LIBTRK_MINNOW_DOLPHIN_A_ofiles
@$(LD) -xm l $(LIBTRK_MINNOW_DOLPHIN_A_LDFLAGS) -o $(BUILD_DIR)/libTRK_MINNOW_DOLPHIN.a @build/LIBTRK_MINNOW_DOLPHIN_A_ofiles
$(BUILD_DIR)/libs/TRK_MINNOW_DOLPHIN/%.o: libs/TRK_MINNOW_DOLPHIN/%.cpp
$(BUILD_DIR)/libs/TRK_MINNOW_DOLPHIN/%.o: libs/TRK_MINNOW_DOLPHIN/%.c
@mkdir -p $(@D)
@echo building... $<
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).cpp
@$(CC) $(CFLAGS) $(LIBTRK_MINNOW_DOLPHIN_A_CFLAGS) -c -o $@ $(basename $@).cpp
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).c
@$(CC) $(CFLAGS) $(LIBTRK_MINNOW_DOLPHIN_A_CFLAGS) -c -o $@ $(basename $@).c
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Export/mslsupp.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Export/mslsupp.c
+5 -5
View File
@@ -11,16 +11,16 @@
// Forward References:
//
extern "C" void __TRK_write_console();
extern "C" void __read_console();
void __TRK_write_console();
void __read_console();
//
// External References:
//
extern "C" void GetTRKConnected();
extern "C" void TRKAccessFile();
extern "C" void GetUseSerialIO();
void GetTRKConnected();
void TRKAccessFile();
void GetUseSerialIO();
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.c
+70
View File
@@ -0,0 +1,70 @@
/**
* dispatch.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h"
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
/* 8036DB9C-8036DD0C 3684DC 0170+00 1/0 1/1 0/0 .text TRKDispatchMessage */
s32 TRKDispatchMessage(TRKBuffer* buffer) {
u32 ret;
ret = 0x500;
TRKSetBufferPosition(buffer, 0);
MWTRACE(1, "Dispatch command 0x%08x\n", buffer->m_buffer[0]);
switch (buffer->m_buffer[0]) {
case TRK_DISPATCH_CMD_CONNECT:
ret = TRKDoConnect(buffer);
break;
case TRK_DISPATCH_CMD_DISCONNECT:
ret = TRKDoDisconnect(buffer);
break;
case TRK_DISPATCH_CMD_RESET:
ret = TRKDoReset(buffer);
break;
case TRK_DISPATCH_CMD_OVERRIDE:
ret = TRKDoOverride(buffer);
break;
case TRK_DISPATCH_CMD_GETVERSION:
ret = TRKDoVersions(buffer);
break;
case TRK_DISPATCH_CMD_GETSUPPORTMASK:
ret = TRKDoSupportMask(buffer);
break;
case TRK_DISPATCH_CMD_READMEM:
ret = TRKDoReadMemory(buffer);
break;
case TRK_DISPATCH_CMD_WRITEMEM:
ret = TRKDoWriteMemory(buffer);
break;
case TRK_DISPATCH_CMD_READREGS:
ret = TRKDoReadRegisters(buffer);
break;
case TRK_DISPATCH_CMD_WRITEREGS:
ret = TRKDoWriteRegisters(buffer);
break;
case TRK_DISPATCH_CMD_CONTINUE:
ret = TRKDoContinue(buffer);
break;
case TRK_DISPATCH_CMD_STEP:
ret = TRKDoStep(buffer);
break;
case TRK_DISPATCH_CMD_STOP:
ret = TRKDoStop(buffer);
break;
case TRK_DISPATCH_CMD_SETOPTION:
ret = TRKDoSetOption(buffer);
break;
}
MWTRACE(1, "Dispatch complete err = %ld\n", ret);
return ret;
}
/* 8036DD0C-8036DD14 36864C 0008+00 0/0 1/1 0/0 .text TRKInitializeDispatcher */
u8 TRKInitializeDispatcher() {
return 0;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.cpp
-165
View File
@@ -1,165 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/dispatch
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKDispatchMessage();
extern "C" bool TRKInitializeDispatcher();
//
// External References:
//
extern "C" void TRKSetBufferPosition();
extern "C" void TRKDoSetOption();
extern "C" void TRKDoStop();
extern "C" void TRKDoStep();
extern "C" void TRKDoContinue();
extern "C" void TRKDoWriteRegisters();
extern "C" void TRKDoReadRegisters();
extern "C" void TRKDoWriteMemory();
extern "C" void TRKDoReadMemory();
extern "C" bool TRKDoSupportMask();
extern "C" bool TRKDoVersions();
extern "C" void TRKDoOverride();
extern "C" void TRKDoReset();
extern "C" void TRKDoDisconnect();
extern "C" void TRKDoConnect();
extern "C" void MWTRACE();
//
// Declarations:
//
/* ############################################################################################## */
/* 803A2890-803A28AC 02EEF0 0019+03 1/1 0/0 0/0 .rodata @126 */
SECTION_RODATA static u8 const lit_126[25 + 3 /* padding */] = {
0x44,
0x69,
0x73,
0x70,
0x61,
0x74,
0x63,
0x68,
0x20,
0x63,
0x6F,
0x6D,
0x6D,
0x61,
0x6E,
0x64,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2890, &lit_126);
/* 803A28AC-803A28D0 02EF0C 001D+07 1/1 0/0 0/0 .rodata @127 */
SECTION_RODATA static u8 const lit_127[29 + 7 /* padding */] = {
0x44,
0x69,
0x73,
0x70,
0x61,
0x74,
0x63,
0x68,
0x20,
0x63,
0x6F,
0x6D,
0x70,
0x6C,
0x65,
0x74,
0x65,
0x20,
0x65,
0x72,
0x72,
0x20,
0x3D,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A28AC, &lit_127);
/* 803D3190-803D3200 -00001 006C+04 1/1 0/0 0/0 .data @128 */
SECTION_DATA static void* lit_128[27 + 1 /* padding */] = {
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x60),
(void*)(((char*)TRKDispatchMessage) + 0x70),
(void*)(((char*)TRKDispatchMessage) + 0x80),
(void*)(((char*)TRKDispatchMessage) + 0xA0),
(void*)(((char*)TRKDispatchMessage) + 0xB0),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x90),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0xC0),
(void*)(((char*)TRKDispatchMessage) + 0xD0),
(void*)(((char*)TRKDispatchMessage) + 0xE0),
(void*)(((char*)TRKDispatchMessage) + 0xF0),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x13C),
(void*)(((char*)TRKDispatchMessage) + 0x130),
(void*)(((char*)TRKDispatchMessage) + 0x100),
(void*)(((char*)TRKDispatchMessage) + 0x110),
(void*)(((char*)TRKDispatchMessage) + 0x120),
/* padding */
NULL,
};
/* 8036DB9C-8036DD0C 3684DC 0170+00 1/0 1/1 0/0 .text TRKDispatchMessage */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDispatchMessage() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/dispatch/TRKDispatchMessage.s"
}
#pragma pop
/* 8036DD0C-8036DD14 36864C 0008+00 0/0 1/1 0/0 .text TRKInitializeDispatcher */
bool TRKInitializeDispatcher() {
return false;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.c
+27
View File
@@ -0,0 +1,27 @@
/**
* main_TRK.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h"
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.h"
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.h"
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
#include "dol2asm.h"
/* 8044F818-8044F820 07C538 0004+04 1/1 0/0 0/0 .bss TRK_mainError */
SECTION_BSS static s32 TRK_mainError;
/* 80371B9C-80371BF4 36C4DC 0058+00 0/0 2/2 0/0 .text TRK_main */
s32 TRK_main(void) {
MWTRACE(1, "TRK_Main \n");
TRK_mainError = TRKInitializeNub();
if (!TRK_mainError) {
TRKNubWelcome();
TRKNubMainLoop();
}
TRK_mainError = TRKTerminateNub();
return TRK_mainError;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.cpp
-64
View File
@@ -1,64 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/main_TRK
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRK_main();
//
// External References:
//
extern "C" void TRKNubMainLoop();
extern "C" void TRKNubWelcome();
extern "C" void TRKTerminateNub();
extern "C" void TRKInitializeNub();
extern "C" void MWTRACE();
//
// Declarations:
//
/* ############################################################################################## */
/* 803A2BF8-803A2C08 02F258 000B+05 1/1 0/0 0/0 .rodata @80 */
SECTION_RODATA static u8 const lit_80[11 + 5 /* padding */] = {
0x54,
0x52,
0x4B,
0x5F,
0x4D,
0x61,
0x69,
0x6E,
0x20,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2BF8, &lit_80);
/* 8044F818-8044F820 07C538 0004+04 1/1 0/0 0/0 .bss TRK_mainError */
SECTION_BSS static u8 TRK_mainError[4 + 4 /* padding */];
/* 80371B9C-80371BF4 36C4DC 0058+00 0/0 2/2 0/0 .text TRK_main */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRK_main() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK/TRK_main.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop.c
+11 -17
View File
@@ -7,26 +7,20 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKNubMainLoop();
//
// External References:
//
extern "C" void TRKDestructEvent();
extern "C" void TRKGetNextEvent();
extern "C" void TRKGetBuffer();
extern "C" void TRKGetInput();
extern "C" void TRKDispatchMessage();
extern "C" void TRKTargetStopped();
extern "C" void TRKTargetSupportRequest();
extern "C" void TRKTargetInterrupt();
extern "C" void TRKTargetContinue();
extern "C" extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
void TRKDestructEvent();
void TRKGetNextEvent();
void TRKGetBuffer();
void TRKGetInput();
void TRKDispatchMessage();
void TRKTargetStopped();
void TRKTargetSupportRequest();
void TRKTargetInterrupt();
void TRKTargetContinue();
extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
//
// Declarations:
@@ -36,7 +30,7 @@ extern "C" extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKNubMainLoop() {
asm void TRKNubMainLoop(void) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mainloop/TRKNubMainLoop.s"
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.c
+58
View File
@@ -0,0 +1,58 @@
/**
* mem_TRK.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
/* 8036F580-8036F638 369EC0 00B8+00 0/0 1/1 0/0 .text TRK_fill_mem */
void TRK_fill_mem(void* dst, int val, u32 n) {
u32 v, i, j;
v = (u8)val;
((u8*)dst) = ((u8*)dst) - 1;
if (n >= 32) {
i = (~(u32)dst) & 3;
if (i) {
n -= i;
do {
*++(((u8*)dst)) = v;
} while (--i);
}
if (v)
v |= v << 24 | v << 16 | v << 8;
((u32*)dst) = ((u32*)(((u8*)dst) + 4)) - 1;
((u32*)dst) = ((u32*)(((u8*)dst) + 1)) - 1;
i = n / 32;
if (i) {
do {
for (j = 0; j < 8; j++)
*++((u32*)dst) = v;
} while (--i);
}
i = (n / 4) % 8;
if (i) {
do {
*++((u32*)dst) = v;
} while (--i);
}
((u8*)dst) = ((u8*)(((u32*)dst) + 1)) - 1;
n %= 4;
}
if (n)
do {
*++((u8*)dst) = v;
} while (--n);
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.cpp
-32
View File
@@ -1,32 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/mem_TRK
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRK_fill_mem();
//
// External References:
//
//
// Declarations:
//
/* 8036F580-8036F638 369EC0 00B8+00 0/0 1/1 0/0 .text TRK_fill_mem */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRK_fill_mem() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mem_TRK/TRK_fill_mem.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.c
+15
View File
@@ -0,0 +1,15 @@
/**
* msg.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h"
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
/* 8036CFD8-8036D01C 367918 0044+00 0/0 6/6 0/0 .text TRKMessageSend */
s32 TRKMessageSend(TRK_Msg* msg) {
u32 write_val = TRKWriteUARTN(&msg->m_msg, msg->m_msgLength);
MWTRACE(1, "MessageSend : cc_write returned %ld\n", write_val);
return 0;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.cpp
-82
View File
@@ -1,82 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/msg
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKMessageSend();
//
// External References:
//
extern "C" void TRKWriteUARTN();
extern "C" void MWTRACE();
//
// Declarations:
//
/* ############################################################################################## */
/* 803A26B8-803A26E0 02ED18 0025+03 1/1 0/0 0/0 .rodata @98 */
SECTION_RODATA static u8 const lit_98[37 + 3 /* padding */] = {
0x4D,
0x65,
0x73,
0x73,
0x61,
0x67,
0x65,
0x53,
0x65,
0x6E,
0x64,
0x20,
0x3A,
0x20,
0x63,
0x63,
0x5F,
0x77,
0x72,
0x69,
0x74,
0x65,
0x20,
0x72,
0x65,
0x74,
0x75,
0x72,
0x6E,
0x65,
0x64,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A26B8, &lit_98);
/* 8036CFD8-8036D01C 367918 0044+00 0/0 6/6 0/0 .text TRKMessageSend */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKMessageSend() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msg/TRKMessageSend.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf.c
+19 -54
View File
@@ -11,20 +11,19 @@
// Forward References:
//
extern "C" void TRKReadBuffer_ui32();
extern "C" void TRKReadBuffer_ui8();
extern "C" void TRKReadBuffer1_ui64();
extern "C" void TRKAppendBuffer_ui32();
extern "C" void TRKAppendBuffer_ui8();
extern "C" void TRKAppendBuffer1_ui64();
extern "C" void TRKReadBuffer();
extern "C" void TRKAppendBuffer();
extern "C" void TRKSetBufferPosition();
extern "C" void TRKResetBuffer();
extern "C" void TRKReleaseBuffer();
extern "C" void TRKGetBuffer();
extern "C" void TRKGetFreeBuffer();
extern "C" void TRKInitializeMessageBuffers();
void TRKReadBuffer_ui32();
void TRKReadBuffer_ui8();
void TRKReadBuffer1_ui64();
void TRKAppendBuffer_ui32();
void TRKAppendBuffer_ui8();
void TRKAppendBuffer1_ui64();
void TRKReadBuffer();
void TRKAppendBuffer();
void TRKResetBuffer();
void TRKReleaseBuffer();
void TRKGetBuffer();
void TRKGetFreeBuffer();
void TRKInitializeMessageBuffers();
//
// External References:
@@ -32,10 +31,10 @@ extern "C" void TRKInitializeMessageBuffers();
SECTION_INIT void TRK_memset();
SECTION_INIT void TRK_memcpy();
extern "C" void usr_puts_serial();
extern "C" bool TRKReleaseMutex();
extern "C" bool TRKAcquireMutex();
extern "C" bool TRKInitializeMutex();
void usr_puts_serial();
u8 TRKReleaseMutex();
u8 TRKAcquireMutex();
u8 TRKInitializeMutex();
SECTION_BSS extern u8 gTRKBigEndian[4 + 4 /* padding */];
//
@@ -126,7 +125,7 @@ asm void TRKAppendBuffer() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKSetBufferPosition() {
asm s32 TRKSetBufferPosition(TRKBuffer*, u32) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msgbuf/TRKSetBufferPosition.s"
}
@@ -168,41 +167,7 @@ asm void TRKGetBuffer() {
/* ############################################################################################## */
/* 803A26E0-803A2700 02ED40 001D+03 1/1 0/0 0/0 .rodata @618 */
SECTION_RODATA static u8 const lit_618[29 + 3 /* padding */] = {
0x45,
0x52,
0x52,
0x4F,
0x52,
0x20,
0x3A,
0x20,
0x4E,
0x6F,
0x20,
0x62,
0x75,
0x66,
0x66,
0x65,
0x72,
0x20,
0x61,
0x76,
0x61,
0x69,
0x6C,
0x61,
0x62,
0x6C,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_618[] = "ERROR : No buffer available\n";
COMPILER_STRIP_GATE(0x803A26E0, &lit_618);
/* 8036D71C-8036D7E4 36805C 00C8+00 0/0 6/6 0/0 .text TRKGetFreeBuffer */
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.c
+59 -456
View File
@@ -11,23 +11,7 @@
// Forward References:
//
extern "C" void TRKDoSetOption();
extern "C" void TRKDoStop();
extern "C" void TRKDoStep();
extern "C" void TRKDoContinue();
extern "C" void TRKDoWriteRegisters();
extern "C" void TRKDoReadRegisters();
extern "C" void TRKDoWriteMemory();
extern "C" void TRKDoReadMemory();
extern "C" bool TRKDoSupportMask();
extern "C" bool TRKDoVersions();
extern "C" void TRKDoOverride();
extern "C" void TRKDoReset();
extern "C" void TRKDoDisconnect();
extern "C" void TRKDoConnect();
extern "C" void SetTRKConnected();
extern "C" void GetTRKConnected();
extern "C" void OutputData();
void OutputData();
//
// External References:
@@ -35,31 +19,30 @@ extern "C" void OutputData();
SECTION_INIT void memset();
SECTION_INIT void __TRK_reset();
extern "C" void TRKConstructEvent();
extern "C" void TRKPostEvent();
extern "C" void TRKMessageSend();
extern "C" void TRKAppendBuffer_ui8();
extern "C" void TRKReadBuffer();
extern "C" void TRKAppendBuffer();
extern "C" void TRKSetBufferPosition();
extern "C" void TRKResetBuffer();
extern "C" void usr_puts_serial();
extern "C" void TRKTargetAccessARAM();
extern "C" void TRKTargetStop();
extern "C" void TRKTargetStopped();
extern "C" void TRKTargetGetPC();
extern "C" void TRKTargetStepOutOfRange();
extern "C" void TRKTargetSingleStep();
extern "C" void TRKTargetAccessExtended2();
extern "C" void TRKTargetAccessExtended1();
extern "C" void TRKTargetAccessFP();
extern "C" void TRKTargetAccessDefault();
extern "C" void TRKTargetAccessMemory();
extern "C" void __TRK_copy_vectors();
extern "C" void TRKWriteUARTN();
extern "C" void TRKTargetContinue();
extern "C" void SetUseSerialIO();
extern "C" void MWTRACE();
void TRKConstructEvent();
void TRKPostEvent();
void TRKMessageSend();
void TRKAppendBuffer_ui8();
void TRKReadBuffer();
void TRKAppendBuffer();
void TRKResetBuffer();
void usr_puts_serial();
void TRKTargetAccessARAM();
void TRKTargetStop();
void TRKTargetStopped();
void TRKTargetGetPC();
void TRKTargetStepOutOfRange();
void TRKTargetSingleStep();
void TRKTargetAccessExtended2();
void TRKTargetAccessExtended1();
void TRKTargetAccessFP();
void TRKTargetAccessDefault();
void TRKTargetAccessMemory();
void __TRK_copy_vectors();
void TRKWriteUARTN();
void TRKTargetContinue();
void SetUseSerialIO();
void MWTRACE();
//
// Declarations:
@@ -67,70 +50,20 @@ extern "C" void MWTRACE();
/* ############################################################################################## */
/* 803A28D0-803A28F0 02EF30 001F+01 4/4 0/0 0/0 .rodata @321 */
SECTION_RODATA static u8 const lit_321[31 + 1 /* padding */] = {
0x0A,
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x4F,
0x70,
0x74,
0x69,
0x6F,
0x6E,
0x20,
0x3A,
0x20,
0x53,
0x65,
0x72,
0x69,
0x61,
0x6C,
0x49,
0x4F,
0x20,
0x2D,
0x20,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_321[] = "\nMetroTRK Option : SerialIO - ";
COMPILER_STRIP_GATE(0x803A28D0, &lit_321);
/* 803A28F0-803A28F8 02EF50 0008+00 0/1 0/0 0/0 .rodata @322 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_322[8] = {
0x45, 0x6E, 0x61, 0x62, 0x6C, 0x65, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_322[] = "Enable\n";
COMPILER_STRIP_GATE(0x803A28F0, &lit_322);
#pragma pop
/* 803A28F8-803A2904 02EF58 0009+03 0/1 0/0 0/0 .rodata @323 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_323[9 + 3 /* padding */] = {
0x44,
0x69,
0x73,
0x61,
0x62,
0x6C,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_323[] = "Disable\n";
COMPILER_STRIP_GATE(0x803A28F8, &lit_323);
#pragma pop
@@ -138,7 +71,7 @@ COMPILER_STRIP_GATE(0x803A28F8, &lit_323);
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoSetOption() {
asm s32 TRKDoSetOption(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoSetOption.s"
}
@@ -148,7 +81,7 @@ asm void TRKDoSetOption() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoStop() {
asm s32 TRKDoStop(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoStop.s"
}
@@ -158,7 +91,7 @@ asm void TRKDoStop() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoStep() {
asm s32 TRKDoStep(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoStep.s"
}
@@ -166,16 +99,14 @@ asm void TRKDoStep() {
/* ############################################################################################## */
/* 803A2904-803A2910 02EF64 000C+00 1/1 0/0 0/0 .rodata @370 */
SECTION_RODATA static u8 const lit_370[12] = {
0x44, 0x6F, 0x43, 0x6F, 0x6E, 0x74, 0x69, 0x6E, 0x75, 0x65, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_370[] = "DoContinue\n";
COMPILER_STRIP_GATE(0x803A2904, &lit_370);
/* 8036E084-8036E134 3689C4 00B0+00 0/0 1/1 0/0 .text TRKDoContinue */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoContinue() {
asm s32 TRKDoContinue(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoContinue.s"
}
@@ -185,117 +116,23 @@ asm void TRKDoContinue() {
/* 803A2910-803A2930 02EF70 001F+01 0/0 0/0 0/0 .rodata @402 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_402[31 + 1 /* padding */] = {
0x44,
0x6F,
0x46,
0x6C,
0x75,
0x73,
0x68,
0x43,
0x61,
0x63,
0x68,
0x65,
0x20,
0x75,
0x6E,
0x69,
0x6D,
0x70,
0x6C,
0x65,
0x6D,
0x65,
0x6E,
0x74,
0x65,
0x64,
0x21,
0x21,
0x21,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_402[] = "DoFlushCache unimplemented!!!\n";
COMPILER_STRIP_GATE(0x803A2910, &lit_402);
#pragma pop
/* 803A2930-803A2950 02EF90 001F+01 1/4 0/0 0/0 .rodata @403 */
SECTION_RODATA static u8 const lit_403[31 + 1 /* padding */] = {
0x53,
0x65,
0x6E,
0x64,
0x41,
0x43,
0x4B,
0x20,
0x3A,
0x20,
0x43,
0x61,
0x6C,
0x6C,
0x69,
0x6E,
0x67,
0x20,
0x4D,
0x65,
0x73,
0x73,
0x61,
0x67,
0x65,
0x53,
0x65,
0x6E,
0x64,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_403[] = "SendACK : Calling MessageSend\n";
COMPILER_STRIP_GATE(0x803A2930, &lit_403);
/* 803A2950-803A2968 02EFB0 0017+01 1/4 0/0 0/0 .rodata @404 */
SECTION_RODATA static u8 const lit_404[23 + 1 /* padding */] = {
0x4D,
0x65,
0x73,
0x73,
0x61,
0x67,
0x65,
0x53,
0x65,
0x6E,
0x64,
0x20,
0x65,
0x72,
0x72,
0x20,
0x3A,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_404[] = "MessageSend err : %ld\n";
COMPILER_STRIP_GATE(0x803A2950, &lit_404);
/* 8036E134-8036E3C4 368A74 0290+00 0/0 1/1 0/0 .text TRKDoWriteRegisters */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoWriteRegisters() {
asm s32 TRKDoWriteRegisters(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoWriteRegisters.s"
}
@@ -305,201 +142,35 @@ asm void TRKDoWriteRegisters() {
/* 803A2968-803A2990 02EFC8 0028+00 0/1 0/0 0/0 .rodata @462 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_462[40] = {
0x44, 0x6F, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
0x73, 0x20, 0x3A, 0x20, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x20, 0x6C, 0x65, 0x6E,
0x67, 0x74, 0x68, 0x20, 0x30, 0x78, 0x25, 0x30, 0x38, 0x78, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_462[] = "DoReadRegisters : Buffer length 0x%08x\n";
COMPILER_STRIP_GATE(0x803A2968, &lit_462);
#pragma pop
/* 803A2990-803A29C8 02EFF0 0036+02 0/1 0/0 0/0 .rodata @463 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_463[54 + 2 /* padding */] = {
0x44,
0x6F,
0x52,
0x65,
0x61,
0x64,
0x52,
0x65,
0x67,
0x69,
0x73,
0x74,
0x65,
0x72,
0x73,
0x20,
0x3A,
0x20,
0x45,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x72,
0x65,
0x61,
0x64,
0x69,
0x6E,
0x67,
0x20,
0x20,
0x64,
0x65,
0x66,
0x61,
0x75,
0x6C,
0x74,
0x20,
0x72,
0x65,
0x67,
0x73,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x0A,
0x00,
/* padding */
0x00,
0x00,
};
SECTION_RODATA static char const lit_463[] = "DoReadRegisters : Error reading default regs 0x%08x\n";
COMPILER_STRIP_GATE(0x803A2990, &lit_463);
#pragma pop
/* 803A29C8-803A29F0 02F028 0028+00 0/1 0/0 0/0 .rodata @464 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_464[40] = {
0x44, 0x6F, 0x52, 0x65, 0x61, 0x64, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x65, 0x72,
0x73, 0x20, 0x3A, 0x20, 0x45, 0x72, 0x72, 0x6F, 0x72, 0x20, 0x46, 0x50, 0x20, 0x72,
0x65, 0x67, 0x73, 0x20, 0x30, 0x78, 0x25, 0x30, 0x38, 0x78, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_464[] = "DoReadRegisters : Error FP regs 0x%08x\n";
COMPILER_STRIP_GATE(0x803A29C8, &lit_464);
#pragma pop
/* 803A29F0-803A2A20 02F050 002F+01 0/1 0/0 0/0 .rodata @465 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_465[47 + 1 /* padding */] = {
0x44,
0x6F,
0x52,
0x65,
0x61,
0x64,
0x52,
0x65,
0x67,
0x69,
0x73,
0x74,
0x65,
0x72,
0x73,
0x20,
0x3A,
0x20,
0x45,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x65,
0x78,
0x74,
0x65,
0x6E,
0x64,
0x65,
0x64,
0x31,
0x20,
0x72,
0x65,
0x67,
0x73,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_465[] = "DoReadRegisters : Error extended1 regs 0x%08x\n";
COMPILER_STRIP_GATE(0x803A29F0, &lit_465);
#pragma pop
/* 803A2A20-803A2A50 02F080 002F+01 0/1 0/0 0/0 .rodata @466 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_466[47 + 1 /* padding */] = {
0x44,
0x6F,
0x52,
0x65,
0x61,
0x64,
0x52,
0x65,
0x67,
0x69,
0x73,
0x74,
0x65,
0x72,
0x73,
0x20,
0x3A,
0x20,
0x45,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x65,
0x78,
0x74,
0x65,
0x6E,
0x64,
0x65,
0x64,
0x32,
0x20,
0x72,
0x65,
0x67,
0x73,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_466[] = "DoReadRegisters : Error extended2 regs 0x%08x\n";
COMPILER_STRIP_GATE(0x803A2A20, &lit_466);
#pragma pop
@@ -507,7 +178,7 @@ COMPILER_STRIP_GATE(0x803A2A20, &lit_466);
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoReadRegisters() {
asm s32 TRKDoReadRegisters(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoReadRegisters.s"
}
@@ -517,57 +188,7 @@ asm void TRKDoReadRegisters() {
/* 803A2A50-803A2A80 02F0B0 002D+03 0/1 0/0 0/0 .rodata @498 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_498[45 + 3 /* padding */] = {
0x57,
0x72,
0x69,
0x74,
0x65,
0x4D,
0x65,
0x6D,
0x6F,
0x72,
0x79,
0x20,
0x28,
0x30,
0x78,
0x25,
0x30,
0x32,
0x78,
0x29,
0x20,
0x3A,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x20,
0x30,
0x78,
0x25,
0x30,
0x38,
0x78,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_498[] = "WriteMemory (0x%02x) : 0x%08x 0x%08x 0x%08x\n";
COMPILER_STRIP_GATE(0x803A2A50, &lit_498);
#pragma pop
@@ -583,7 +204,7 @@ SECTION_DATA static void* lit_499[7] = {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoWriteMemory() {
asm s32 TRKDoWriteMemory(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoWriteMemory.s"
}
@@ -593,11 +214,7 @@ asm void TRKDoWriteMemory() {
/* 803A2A80-803A2AAC 02F0E0 002C+00 0/1 0/0 0/0 .rodata @535 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_535[44] = {
0x52, 0x65, 0x61, 0x64, 0x4D, 0x65, 0x6D, 0x6F, 0x72, 0x79, 0x20, 0x28, 0x30, 0x78, 0x25,
0x30, 0x32, 0x78, 0x29, 0x20, 0x3A, 0x20, 0x30, 0x78, 0x25, 0x30, 0x38, 0x78, 0x20, 0x30,
0x78, 0x25, 0x30, 0x38, 0x78, 0x20, 0x30, 0x78, 0x25, 0x30, 0x38, 0x78, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_535[] = "ReadMemory (0x%02x) : 0x%08x 0x%08x 0x%08x\n";
COMPILER_STRIP_GATE(0x803A2A80, &lit_535);
#pragma pop
@@ -613,27 +230,27 @@ SECTION_DATA static void* lit_536[7] = {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoReadMemory() {
asm s32 TRKDoReadMemory(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoReadMemory.s"
}
#pragma pop
/* 8036EB24-8036EB2C 369464 0008+00 0/0 1/1 0/0 .text TRKDoSupportMask */
bool TRKDoSupportMask() {
return false;
s32 TRKDoSupportMask(TRKBuffer*) {
return 0;
}
/* 8036EB2C-8036EB34 36946C 0008+00 0/0 1/1 0/0 .text TRKDoVersions */
bool TRKDoVersions() {
return false;
s32 TRKDoVersions(TRKBuffer*) {
return 0;
}
/* 8036EB34-8036EB8C 369474 0058+00 0/0 1/1 0/0 .text TRKDoOverride */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoOverride() {
asm s32 TRKDoOverride(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoOverride.s"
}
@@ -643,7 +260,7 @@ asm void TRKDoOverride() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoReset() {
asm s32 TRKDoReset(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoReset.s"
}
@@ -657,7 +274,7 @@ SECTION_BSS static u8 IsTRKConnected[4 + 4 /* padding */];
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoDisconnect() {
asm s32 TRKDoDisconnect(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoDisconnect.s"
}
@@ -667,7 +284,7 @@ asm void TRKDoDisconnect() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKDoConnect() {
asm s32 TRKDoConnect(TRKBuffer*) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/TRKDoConnect.s"
}
@@ -677,7 +294,7 @@ asm void TRKDoConnect() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void SetTRKConnected() {
asm void SetTRKConnected(BOOL) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/SetTRKConnected.s"
}
@@ -687,7 +304,7 @@ asm void SetTRKConnected() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void GetTRKConnected() {
asm BOOL GetTRKConnected(void) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr/GetTRKConnected.s"
}
@@ -695,25 +312,11 @@ asm void GetTRKConnected() {
/* ############################################################################################## */
/* 803A2AAC-803A2AB4 02F10C 0006+02 1/1 0/0 0/0 .rodata @573 */
SECTION_RODATA static u8 const lit_573[6 + 2 /* padding */] = {
0x25,
0x30,
0x32,
0x78,
0x20,
0x00,
/* padding */
0x00,
0x00,
};
SECTION_RODATA static char const lit_573[] = "%02x ";
COMPILER_STRIP_GATE(0x803A2AAC, &lit_573);
/* 803A2AB4-803A2AB8 02F114 0002+02 1/1 0/0 0/0 .rodata @574 */
SECTION_RODATA static u16 const lit_574[1 + 1 /* padding */] = {
0x0A00,
/* padding */
0x0000,
};
SECTION_RODATA static char const lit_574[] = "\n";
COMPILER_STRIP_GATE(0x803A2AB4, &lit_574);
/* 8036ECDC-8036ED84 36961C 00A8+00 0/0 1/1 0/0 .text OutputData */
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.c
+21
View File
@@ -0,0 +1,21 @@
/**
* mutex_TRK.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h"
/* 8036F498-8036F4A0 369DD8 0008+00 0/0 6/6 0/0 .text TRKReleaseMutex */
u8 TRKReleaseMutex() {
return 0;
}
/* 8036F4A0-8036F4A8 369DE0 0008+00 0/0 6/6 0/0 .text TRKAcquireMutex */
u8 TRKAcquireMutex() {
return 0;
}
/* 8036F4A8-8036F4B0 369DE8 0008+00 0/0 2/2 0/0 .text TRKInitializeMutex */
u8 TRKInitializeMutex() {
return 0;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.cpp
-39
View File
@@ -1,39 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/mutex_TRK
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/mutex_TRK.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" bool TRKReleaseMutex();
extern "C" bool TRKAcquireMutex();
extern "C" bool TRKInitializeMutex();
//
// External References:
//
//
// Declarations:
//
/* 8036F498-8036F4A0 369DD8 0008+00 0/0 6/6 0/0 .text TRKReleaseMutex */
bool TRKReleaseMutex() {
return false;
}
/* 8036F4A0-8036F4A8 369DE0 0008+00 0/0 6/6 0/0 .text TRKAcquireMutex */
bool TRKAcquireMutex() {
return false;
}
/* 8036F4A8-8036F4B0 369DE8 0008+00 0/0 2/2 0/0 .text TRKInitializeMutex */
bool TRKInitializeMutex() {
return false;
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/notify.c
+6 -6
View File
@@ -11,17 +11,17 @@
// Forward References:
//
extern "C" void TRKDoNotifyStopped();
void TRKDoNotifyStopped();
//
// External References:
//
extern "C" void TRKReleaseBuffer();
extern "C" void TRKGetFreeBuffer();
extern "C" void TRKRequestSend();
extern "C" void TRKTargetAddExceptionInfo();
extern "C" void TRKTargetAddStopInfo();
void TRKReleaseBuffer();
void TRKGetFreeBuffer();
void TRKRequestSend();
void TRKTargetAddExceptionInfo();
void TRKTargetAddStopInfo();
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubevent.c
+9 -9
View File
@@ -11,21 +11,21 @@
// Forward References:
//
extern "C" void TRKDestructEvent();
extern "C" void TRKConstructEvent();
extern "C" void TRKPostEvent();
extern "C" void TRKGetNextEvent();
extern "C" void TRKInitializeEventQueue();
void TRKDestructEvent();
void TRKConstructEvent();
void TRKPostEvent();
void TRKGetNextEvent();
void TRKInitializeEventQueue();
//
// External References:
//
SECTION_INIT void TRK_memcpy();
extern "C" void TRKReleaseBuffer();
extern "C" bool TRKReleaseMutex();
extern "C" bool TRKAcquireMutex();
extern "C" bool TRKInitializeMutex();
void TRKReleaseBuffer();
u8 TRKReleaseMutex();
u8 TRKAcquireMutex();
u8 TRKInitializeMutex();
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit.c
+18 -78
View File
@@ -7,31 +7,23 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKNubWelcome();
extern "C" void TRKTerminateNub();
extern "C" void TRKInitializeNub();
//
// External References:
//
extern "C" void TRKInitializeEventQueue();
extern "C" void TRKInitializeMessageBuffers();
extern "C" bool TRKTerminateSerialHandler();
extern "C" void TRKInitializeSerialHandler();
extern "C" void usr_put_initialize();
extern "C" bool TRKInitializeDispatcher();
extern "C" void TRKTargetSetInputPendingPtr();
extern "C" void TRKInitializeTarget();
extern "C" void InitializeProgramEndTrap();
extern "C" void TRK_board_display();
extern "C" void TRKInitializeIntDrivenUART();
extern "C" void MWTRACE();
extern "C" extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
void TRKInitializeEventQueue();
void TRKInitializeMessageBuffers();
u8 TRKTerminateSerialHandler();
void TRKInitializeSerialHandler();
void usr_put_initialize();
u8 TRKInitializeDispatcher();
void TRKTargetSetInputPendingPtr();
void TRKInitializeTarget();
void InitializeProgramEndTrap();
void TRK_board_display();
void TRKInitializeIntDrivenUART();
void MWTRACE();
extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
//
// Declarations:
@@ -39,44 +31,14 @@ extern "C" extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
/* ############################################################################################## */
/* 803A2688-803A26A4 02ECE8 001B+01 1/1 0/0 0/0 .rodata @133 */
SECTION_RODATA static u8 const lit_133[27 + 1 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x66,
0x6F,
0x72,
0x20,
0x47,
0x41,
0x4D,
0x45,
0x43,
0x55,
0x42,
0x45,
0x20,
0x76,
0x32,
0x2E,
0x36,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_133[] = "MetroTRK for GAMECUBE v2.6";
COMPILER_STRIP_GATE(0x803A2688, &lit_133);
/* 8036CE40-8036CE68 367780 0028+00 0/0 1/1 0/0 .text TRKNubWelcome */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKNubWelcome() {
asm void TRKNubWelcome(void) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit/TRKNubWelcome.s"
}
@@ -86,7 +48,7 @@ asm void TRKNubWelcome() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKTerminateNub() {
asm s32 TRKTerminateNub(void) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit/TRKTerminateNub.s"
}
@@ -94,29 +56,7 @@ asm void TRKTerminateNub() {
/* ############################################################################################## */
/* 803A26A4-803A26B8 02ED04 0010+04 1/1 0/0 0/0 .rodata @154 */
SECTION_RODATA static u8 const lit_154[16 + 4 /* padding */] = {
0x49,
0x6E,
0x69,
0x74,
0x69,
0x61,
0x6C,
0x69,
0x7A,
0x65,
0x20,
0x4E,
0x55,
0x42,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_154[] = "Initialize NUB\n";
COMPILER_STRIP_GATE(0x803A26A4, &lit_154);
/* 8044D8B8-8044D8C0 07A5D8 0004+04 1/1 4/4 0/0 .bss gTRKBigEndian */
@@ -127,7 +67,7 @@ SECTION_BSS u8 gTRKBigEndian[4 + 4 /* padding */];
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKInitializeNub() {
asm s32 TRKInitializeNub(void) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/nubinit/TRKInitializeNub.s"
}
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.c
+167
View File
@@ -0,0 +1,167 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/serpoll
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
u8 TRKTerminateSerialHandler();
void TRKInitializeSerialHandler();
void TRKProcessInput();
void TRKGetInput();
void TRKTestForPacket();
extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
//
// External References:
//
void TRKConstructEvent();
void TRKPostEvent();
void TRKAppendBuffer_ui8();
void TRKSetBufferPosition();
void TRKReleaseBuffer();
void TRKGetBuffer();
void TRKGetFreeBuffer();
void TRKReadUARTN();
void TRKPollUART();
void MWTRACE();
//
// Declarations:
//
/* 8036D858-8036D860 368198 0008+00 0/0 1/1 0/0 .text TRKTerminateSerialHandler */
u8 TRKTerminateSerialHandler() {
return 0;
}
/* ############################################################################################## */
/* 803A2700-803A2724 02ED60 0022+02 2/2 0/0 0/0 .rodata @121 */
SECTION_RODATA static char const lit_121[] = "TRK_Packet_Header \t %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2700, &lit_121);
/* 803A2724-803A2748 02ED84 0022+02 0/1 0/0 0/0 .rodata @122 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_122[] = "TRK_CMD_ReadMemory %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2724, &lit_122);
#pragma pop
/* 803A2748-803A276C 02EDA8 0022+02 0/1 0/0 0/0 .rodata @123 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_123[] = "TRK_CMD_WriteMemory %ld bytes\n";
COMPILER_STRIP_GATE(0x803A2748, &lit_123);
#pragma pop
/* 803A276C-803A278C 02EDCC 0020+00 0/1 0/0 0/0 .rodata @124 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_124[] = "TRK_CMD_Connect \t %ld bytes\n";
COMPILER_STRIP_GATE(0x803A276C, &lit_124);
#pragma pop
/* 803A278C-803A27AC 02EDEC 0020+00 0/1 0/0 0/0 .rodata @125 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_125[] = "TRK_CMD_ReplyAck\t %ld bytes\n";
COMPILER_STRIP_GATE(0x803A278C, &lit_125);
#pragma pop
/* 803A27AC-803A27D0 02EE0C 0021+03 0/1 0/0 0/0 .rodata @126 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_126[] = "TRK_CMD_ReadRegisters\t%ld bytes\n";
COMPILER_STRIP_GATE(0x803A27AC, &lit_126);
#pragma pop
/* 8044F270-8044F288 07BF90 0014+04 3/3 0/0 0/0 .bss gTRKFramingState */
static u8 gTRKFramingState[20 + 4 /* padding */];
/* 8036D860-8036D924 3681A0 00C4+00 0/0 1/1 0/0 .text TRKInitializeSerialHandler */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKInitializeSerialHandler() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKInitializeSerialHandler.s"
}
#pragma pop
/* 8036D924-8036D974 368264 0050+00 0/0 1/1 0/0 .text TRKProcessInput */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKProcessInput() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKProcessInput.s"
}
#pragma pop
/* 8036D974-8036D9D4 3682B4 0060+00 0/0 1/1 0/0 .text TRKGetInput */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKGetInput() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKGetInput.s"
}
#pragma pop
/* ############################################################################################## */
/* 803A27D0-803A27F4 02EE30 0024+00 0/1 0/0 0/0 .rodata @146 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_146[] = "TestForPacket : FreeBuffer is %ld\n";
COMPILER_STRIP_GATE(0x803A27D0, &lit_146);
#pragma pop
/* 803A27F4-803A2810 02EE54 001B+01 0/1 0/0 0/0 .rodata @147 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_147[] = "Reading payload %ld bytes\n";
COMPILER_STRIP_GATE(0x803A27F4, &lit_147);
#pragma pop
/* 803A2810-803A2844 02EE70 0031+03 0/1 0/0 0/0 .rodata @148 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_148[] = "TestForPacket : Invalid size of packet hdr.size\n";
COMPILER_STRIP_GATE(0x803A2810, &lit_148);
#pragma pop
/* 803A2844-803A286C 02EEA4 0028+00 0/1 0/0 0/0 .rodata @149 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_149[] = "TestForPacket : Invalid size of packet\n";
COMPILER_STRIP_GATE(0x803A2844, &lit_149);
#pragma pop
/* 803A286C-803A2890 02EECC 001D+07 0/1 0/0 0/0 .rodata @150 */
#pragma push
#pragma force_active on
SECTION_RODATA static char const lit_150[] = "TestForPacket returning %ld\n";
COMPILER_STRIP_GATE(0x803A286C, &lit_150);
#pragma pop
/* 8036D9D4-8036DB10 368314 013C+00 1/1 1/1 0/0 .text TRKTestForPacket */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKTestForPacket() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKTestForPacket.s"
}
#pragma pop
/* ############################################################################################## */
/* 804519B8-804519C0 000EB8 0004+04 0/0 2/2 0/0 .sbss gTRKInputPendingPtr */
extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
u8 gTRKInputPendingPtr[4 + 4 /* padding */];
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.cpp
-455
View File
@@ -1,455 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: MetroTRK/Portable/serpoll
//
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" bool TRKTerminateSerialHandler();
extern "C" void TRKInitializeSerialHandler();
extern "C" void TRKProcessInput();
extern "C" void TRKGetInput();
extern "C" void TRKTestForPacket();
extern "C" extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
//
// External References:
//
extern "C" void TRKConstructEvent();
extern "C" void TRKPostEvent();
extern "C" void TRKAppendBuffer_ui8();
extern "C" void TRKSetBufferPosition();
extern "C" void TRKReleaseBuffer();
extern "C" void TRKGetBuffer();
extern "C" void TRKGetFreeBuffer();
extern "C" void TRKReadUARTN();
extern "C" void TRKPollUART();
extern "C" void MWTRACE();
//
// Declarations:
//
/* 8036D858-8036D860 368198 0008+00 0/0 1/1 0/0 .text TRKTerminateSerialHandler */
bool TRKTerminateSerialHandler() {
return false;
}
/* ############################################################################################## */
/* 803A2700-803A2724 02ED60 0022+02 2/2 0/0 0/0 .rodata @121 */
SECTION_RODATA static u8 const lit_121[34 + 2 /* padding */] = {
0x54,
0x52,
0x4B,
0x5F,
0x50,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x5F,
0x48,
0x65,
0x61,
0x64,
0x65,
0x72,
0x20,
0x09,
0x20,
0x20,
0x20,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2700, &lit_121);
/* 803A2724-803A2748 02ED84 0022+02 0/1 0/0 0/0 .rodata @122 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_122[34 + 2 /* padding */] = {
0x54,
0x52,
0x4B,
0x5F,
0x43,
0x4D,
0x44,
0x5F,
0x52,
0x65,
0x61,
0x64,
0x4D,
0x65,
0x6D,
0x6F,
0x72,
0x79,
0x20,
0x20,
0x20,
0x20,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2724, &lit_122);
#pragma pop
/* 803A2748-803A276C 02EDA8 0022+02 0/1 0/0 0/0 .rodata @123 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_123[34 + 2 /* padding */] = {
0x54,
0x52,
0x4B,
0x5F,
0x43,
0x4D,
0x44,
0x5F,
0x57,
0x72,
0x69,
0x74,
0x65,
0x4D,
0x65,
0x6D,
0x6F,
0x72,
0x79,
0x20,
0x20,
0x20,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2748, &lit_123);
#pragma pop
/* 803A276C-803A278C 02EDCC 0020+00 0/1 0/0 0/0 .rodata @124 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_124[32] = {
0x54, 0x52, 0x4B, 0x5F, 0x43, 0x4D, 0x44, 0x5F, 0x43, 0x6F, 0x6E, 0x6E, 0x65, 0x63, 0x74, 0x20,
0x09, 0x20, 0x20, 0x20, 0x20, 0x25, 0x6C, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0A, 0x00,
};
COMPILER_STRIP_GATE(0x803A276C, &lit_124);
#pragma pop
/* 803A278C-803A27AC 02EDEC 0020+00 0/1 0/0 0/0 .rodata @125 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_125[32] = {
0x54, 0x52, 0x4B, 0x5F, 0x43, 0x4D, 0x44, 0x5F, 0x52, 0x65, 0x70, 0x6C, 0x79, 0x41, 0x63, 0x6B,
0x09, 0x20, 0x20, 0x20, 0x20, 0x25, 0x6C, 0x64, 0x20, 0x62, 0x79, 0x74, 0x65, 0x73, 0x0A, 0x00,
};
COMPILER_STRIP_GATE(0x803A278C, &lit_125);
#pragma pop
/* 803A27AC-803A27D0 02EE0C 0021+03 0/1 0/0 0/0 .rodata @126 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_126[33 + 3 /* padding */] = {
0x54,
0x52,
0x4B,
0x5F,
0x43,
0x4D,
0x44,
0x5F,
0x52,
0x65,
0x61,
0x64,
0x52,
0x65,
0x67,
0x69,
0x73,
0x74,
0x65,
0x72,
0x73,
0x09,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A27AC, &lit_126);
#pragma pop
/* 8044F270-8044F288 07BF90 0014+04 3/3 0/0 0/0 .bss gTRKFramingState */
static u8 gTRKFramingState[20 + 4 /* padding */];
/* 8036D860-8036D924 3681A0 00C4+00 0/0 1/1 0/0 .text TRKInitializeSerialHandler */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKInitializeSerialHandler() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKInitializeSerialHandler.s"
}
#pragma pop
/* 8036D924-8036D974 368264 0050+00 0/0 1/1 0/0 .text TRKProcessInput */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKProcessInput() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKProcessInput.s"
}
#pragma pop
/* 8036D974-8036D9D4 3682B4 0060+00 0/0 1/1 0/0 .text TRKGetInput */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKGetInput() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKGetInput.s"
}
#pragma pop
/* ############################################################################################## */
/* 803A27D0-803A27F4 02EE30 0024+00 0/1 0/0 0/0 .rodata @146 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_146[36] = {
0x54, 0x65, 0x73, 0x74, 0x46, 0x6F, 0x72, 0x50, 0x61, 0x63, 0x6B, 0x65,
0x74, 0x20, 0x3A, 0x20, 0x46, 0x72, 0x65, 0x65, 0x42, 0x75, 0x66, 0x66,
0x65, 0x72, 0x20, 0x69, 0x73, 0x20, 0x20, 0x25, 0x6C, 0x64, 0x0A, 0x00,
};
COMPILER_STRIP_GATE(0x803A27D0, &lit_146);
#pragma pop
/* 803A27F4-803A2810 02EE54 001B+01 0/1 0/0 0/0 .rodata @147 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_147[27 + 1 /* padding */] = {
0x52,
0x65,
0x61,
0x64,
0x69,
0x6E,
0x67,
0x20,
0x70,
0x61,
0x79,
0x6C,
0x6F,
0x61,
0x64,
0x20,
0x25,
0x6C,
0x64,
0x20,
0x62,
0x79,
0x74,
0x65,
0x73,
0x0A,
0x00,
/* padding */
0x00,
};
COMPILER_STRIP_GATE(0x803A27F4, &lit_147);
#pragma pop
/* 803A2810-803A2844 02EE70 0031+03 0/1 0/0 0/0 .rodata @148 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_148[49 + 3 /* padding */] = {
0x54,
0x65,
0x73,
0x74,
0x46,
0x6F,
0x72,
0x50,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x20,
0x3A,
0x20,
0x49,
0x6E,
0x76,
0x61,
0x6C,
0x69,
0x64,
0x20,
0x73,
0x69,
0x7A,
0x65,
0x20,
0x6F,
0x66,
0x20,
0x70,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x20,
0x68,
0x64,
0x72,
0x2E,
0x73,
0x69,
0x7A,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A2810, &lit_148);
#pragma pop
/* 803A2844-803A286C 02EEA4 0028+00 0/1 0/0 0/0 .rodata @149 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_149[40] = {
0x54, 0x65, 0x73, 0x74, 0x46, 0x6F, 0x72, 0x50, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x20,
0x3A, 0x20, 0x49, 0x6E, 0x76, 0x61, 0x6C, 0x69, 0x64, 0x20, 0x73, 0x69, 0x7A, 0x65,
0x20, 0x6F, 0x66, 0x20, 0x70, 0x61, 0x63, 0x6B, 0x65, 0x74, 0x0A, 0x00,
};
COMPILER_STRIP_GATE(0x803A2844, &lit_149);
#pragma pop
/* 803A286C-803A2890 02EECC 001D+07 0/1 0/0 0/0 .rodata @150 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_150[29 + 7 /* padding */] = {
0x54,
0x65,
0x73,
0x74,
0x46,
0x6F,
0x72,
0x50,
0x61,
0x63,
0x6B,
0x65,
0x74,
0x20,
0x72,
0x65,
0x74,
0x75,
0x72,
0x6E,
0x69,
0x6E,
0x67,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
};
COMPILER_STRIP_GATE(0x803A286C, &lit_150);
#pragma pop
/* 8036D9D4-8036DB10 368314 013C+00 1/1 1/1 0/0 .text TRKTestForPacket */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKTestForPacket() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/serpoll/TRKTestForPacket.s"
}
#pragma pop
/* ############################################################################################## */
/* 804519B8-804519C0 000EB8 0004+04 0/0 2/2 0/0 .sbss gTRKInputPendingPtr */
extern u8 gTRKInputPendingPtr[4 + 4 /* padding */];
u8 gTRKInputPendingPtr[4 + 4 /* padding */];
libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.cpp → libs/TRK_MINNOW_DOLPHIN/MetroTRK/Portable/support.c
+21 -140
View File
@@ -11,29 +11,29 @@
// Forward References:
//
extern "C" void HandlePositionFileSupportRequest();
extern "C" void HandleCloseFileSupportRequest();
extern "C" void HandleOpenFileSupportRequest();
extern "C" void TRKRequestSend();
extern "C" void TRKSuppAccessFile();
void HandlePositionFileSupportRequest();
void HandleCloseFileSupportRequest();
void HandleOpenFileSupportRequest();
void TRKRequestSend();
void TRKSuppAccessFile();
//
// External References:
//
SECTION_INIT void memset();
extern "C" void strlen();
extern "C" void TRKMessageSend();
extern "C" void TRKReadBuffer_ui8();
extern "C" void TRKAppendBuffer_ui8();
extern "C" void TRKSetBufferPosition();
extern "C" void TRKReleaseBuffer();
extern "C" void TRKGetBuffer();
extern "C" void TRKGetFreeBuffer();
extern "C" void TRKProcessInput();
extern "C" void TRKTestForPacket();
extern "C" void OutputData();
extern "C" void MWTRACE();
void strlen();
void TRKMessageSend();
void TRKReadBuffer_ui8();
void TRKAppendBuffer_ui8();
void TRKSetBufferPosition();
void TRKReleaseBuffer();
void TRKGetBuffer();
void TRKGetFreeBuffer();
void TRKProcessInput();
void TRKTestForPacket();
void OutputData();
void MWTRACE();
//
// Declarations:
@@ -71,146 +71,27 @@ asm void HandleOpenFileSupportRequest() {
/* ############################################################################################## */
/* 803A2AB8-803A2AD0 02F118 0015+03 1/1 0/0 0/0 .rodata @274 */
SECTION_RODATA static u8 const lit_274[21 + 3 /* padding */] = {
0x43,
0x61,
0x6C,
0x6C,
0x69,
0x6E,
0x67,
0x20,
0x4D,
0x65,
0x73,
0x73,
0x61,
0x67,
0x65,
0x53,
0x65,
0x6E,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_274[] = "Calling MessageSend\n";
COMPILER_STRIP_GATE(0x803A2AB8, &lit_274);
/* 803A2AD0-803A2AF8 02F130 0028+00 0/1 0/0 0/0 .rodata @275 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_275[40] = {
0x6D, 0x73, 0x67, 0x5F, 0x63, 0x6F, 0x6D, 0x6D, 0x61, 0x6E, 0x64, 0x20, 0x3A, 0x20,
0x30, 0x78, 0x25, 0x30, 0x32, 0x78, 0x20, 0x68, 0x64, 0x72, 0x2D, 0x3E, 0x63, 0x6D,
0x64, 0x49, 0x44, 0x20, 0x30, 0x78, 0x25, 0x30, 0x32, 0x78, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_275[] = "msg_command : 0x%02x hdr->cmdID 0x%02x\n";
COMPILER_STRIP_GATE(0x803A2AD0, &lit_275);
#pragma pop
/* 803A2AF8-803A2B0C 02F158 0014+00 0/1 0/0 0/0 .rodata @276 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_276[20] = {
0x6D, 0x73, 0x67, 0x5F, 0x65, 0x72, 0x72, 0x6F, 0x72, 0x20,
0x3A, 0x20, 0x30, 0x78, 0x25, 0x30, 0x32, 0x78, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_276[] = "msg_error : 0x%02x\n";
COMPILER_STRIP_GATE(0x803A2AF8, &lit_276);
#pragma pop
/* 803A2B0C-803A2B60 02F16C 0051+03 0/1 0/0 0/0 .rodata @277 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_277[81 + 3 /* padding */] = {
0x52,
0x65,
0x71,
0x75,
0x65,
0x73,
0x74,
0x53,
0x65,
0x6E,
0x64,
0x20,
0x3A,
0x20,
0x42,
0x61,
0x64,
0x20,
0x61,
0x63,
0x6B,
0x20,
0x6F,
0x72,
0x20,
0x6E,
0x6F,
0x6E,
0x20,
0x61,
0x63,
0x6B,
0x20,
0x72,
0x65,
0x63,
0x65,
0x69,
0x76,
0x65,
0x64,
0x20,
0x6D,
0x73,
0x67,
0x5F,
0x63,
0x6F,
0x6D,
0x6D,
0x61,
0x6E,
0x64,
0x20,
0x3A,
0x20,
0x30,
0x78,
0x25,
0x30,
0x32,
0x78,
0x20,
0x6D,
0x73,
0x67,
0x5F,
0x65,
0x72,
0x72,
0x6F,
0x72,
0x20,
0x30,
0x78,
0x25,
0x30,
0x32,
0x78,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_277[] = "RequestSend : Bad ack or non ack received msg_command : 0x%02x msg_error 0x%02x\n";
COMPILER_STRIP_GATE(0x803A2B0C, &lit_277);
#pragma pop
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/UDP_Stubs.cpp → libs/TRK_MINNOW_DOLPHIN/Os/dolphin/UDP_Stubs.c
+16 -40
View File
@@ -1,75 +1,51 @@
//
// Generated By: dol2asm
// Translation Unit: Os/dolphin/UDP_Stubs
//
/**
* UDP_Stubs.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/UDP_Stubs.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" s32 udp_cc_post_stop();
extern "C" s32 udp_cc_pre_continue();
extern "C" bool udp_cc_peek();
extern "C" bool udp_cc_write();
extern "C" bool udp_cc_read();
extern "C" s32 udp_cc_close();
extern "C" s32 udp_cc_open();
extern "C" s32 udp_cc_shutdown();
extern "C" s32 udp_cc_initialize();
//
// External References:
//
//
// Declarations:
//
/* 80372314-8037231C 36CC54 0008+00 0/0 1/1 0/0 .text udp_cc_post_stop */
s32 udp_cc_post_stop() {
s32 udp_cc_post_stop(void) {
return -1;
}
/* 8037231C-80372324 36CC5C 0008+00 0/0 1/1 0/0 .text udp_cc_pre_continue */
s32 udp_cc_pre_continue() {
s32 udp_cc_pre_continue(void) {
return -1;
}
/* 80372324-8037232C 36CC64 0008+00 0/0 1/1 0/0 .text udp_cc_peek */
bool udp_cc_peek() {
return false;
u8 udp_cc_peek(void) {
return 0;
}
/* 8037232C-80372334 36CC6C 0008+00 0/0 1/1 0/0 .text udp_cc_write */
bool udp_cc_write() {
return false;
u8 udp_cc_write(void) {
return 0;
}
/* 80372334-8037233C 36CC74 0008+00 0/0 1/1 0/0 .text udp_cc_read */
bool udp_cc_read() {
return false;
u8 udp_cc_read(void) {
return 0;
}
/* 8037233C-80372344 36CC7C 0008+00 0/0 1/1 0/0 .text udp_cc_close */
s32 udp_cc_close() {
s32 udp_cc_close(void) {
return -1;
}
/* 80372344-8037234C 36CC84 0008+00 0/0 1/1 0/0 .text udp_cc_open */
s32 udp_cc_open() {
s32 udp_cc_open(void) {
return -1;
}
/* 8037234C-80372354 36CC8C 0008+00 0/0 1/1 0/0 .text udp_cc_shutdown */
s32 udp_cc_shutdown() {
s32 udp_cc_shutdown(void) {
return -1;
}
/* 80372354-8037235C 36CC94 0008+00 0/0 1/1 0/0 .text udp_cc_initialize */
s32 udp_cc_initialize() {
s32 udp_cc_initialize(void) {
return -1;
}
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.cpp → libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk.c
+22 -32
View File
@@ -7,48 +7,38 @@
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Types:
//
struct dBgW {};
struct daBgObj_c {
/* 80459BB4 */ void regist(dBgW*);
};
//
// Forward References:
//
extern "C" void InitMetroTRK();
extern "C" void InitMetroTRK_BBA();
extern "C" void TRK__write_aram();
extern "C" void TRK__read_aram();
extern "C" void TRKInitializeTarget();
extern "C" void __TRK_copy_vectors();
extern "C" void TRKTargetTranslate();
extern "C" void EnableMetroTRKInterrupts();
void InitMetroTRK();
void InitMetroTRK_BBA();
void TRK__write_aram();
void TRK__read_aram();
void TRKInitializeTarget();
void __TRK_copy_vectors();
void TRKTargetTranslate();
void EnableMetroTRKInterrupts();
//
// External References:
//
SECTION_INIT void TRK_memcpy();
extern "C" extern u8 const __TRK_unknown_data[7988];
extern "C" void ARGetDMAStatus();
extern "C" void ARStartDMA();
extern "C" void __ARClearInterrupt();
extern "C" void __ARGetInterruptStatus();
extern "C" void TRK_flush_cache();
extern "C" void __TRK_get_MSR();
extern "C" void TRKSaveExtended1Block();
extern "C" void TRK_main();
extern "C" void EnableEXI2Interrupts();
extern "C" void InitMetroTRKCommTable();
extern "C" extern u8 gTRKState[164];
extern "C" extern u8 gTRKCPUState[1072];
extern "C" void regist__9daBgObj_cFP4dBgW();
extern u8 const __TRK_unknown_data[7988];
void ARGetDMAStatus();
void ARStartDMA();
void __ARClearInterrupt();
void __ARGetInterruptStatus();
void TRK_flush_cache();
void __TRK_get_MSR();
void TRKSaveExtended1Block();
void TRK_main();
void EnableEXI2Interrupts();
void InitMetroTRKCommTable();
extern u8 gTRKState[164];
extern u8 gTRKCPUState[1072];
void regist__9daBgObj_cFP4dBgW();
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.cpp → libs/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.c
+59 -301
View File
@@ -11,19 +11,16 @@
// Forward References:
//
extern "C" static void TRKLoadContext();
extern "C" void TRKUARTInterruptHandler();
extern "C" void InitializeProgramEndTrap();
extern "C" void TRK_board_display();
extern "C" void UnreserveEXI2Port();
extern "C" void ReserveEXI2Port();
extern "C" void TRKWriteUARTN();
extern "C" void TRKReadUARTN();
extern "C" void TRKPollUART();
extern "C" void EnableEXI2Interrupts();
extern "C" void TRKInitializeIntDrivenUART();
extern "C" void InitMetroTRKCommTable();
extern "C" static void TRKEXICallBack();
static void TRKLoadContext();
void TRKUARTInterruptHandler();
void InitializeProgramEndTrap();
void TRK_board_display();
void TRKReadUARTN();
void TRKPollUART();
void EnableEXI2Interrupts();
void TRKInitializeIntDrivenUART();
void InitMetroTRKCommTable();
static void TRKEXICallBack();
SECTION_BSS extern u8 data_8044F828[8];
//
@@ -31,43 +28,43 @@ SECTION_BSS extern u8 data_8044F828[8];
//
SECTION_INIT void TRK_memcpy();
extern "C" void OSReport();
extern "C" void PPCHalt();
extern "C" void DCFlushRange();
extern "C" void ICInvalidateRange();
extern "C" void OSEnableScheduler();
extern "C" void TRKInterruptHandler();
extern "C" s32 udp_cc_post_stop();
extern "C" s32 udp_cc_pre_continue();
extern "C" bool udp_cc_peek();
extern "C" bool udp_cc_write();
extern "C" bool udp_cc_read();
extern "C" s32 udp_cc_close();
extern "C" s32 udp_cc_open();
extern "C" s32 udp_cc_shutdown();
extern "C" s32 udp_cc_initialize();
extern "C" void ddh_cc_initinterrupts();
extern "C" void ddh_cc_peek();
extern "C" void ddh_cc_post_stop();
extern "C" void ddh_cc_pre_continue();
extern "C" void ddh_cc_write();
extern "C" void ddh_cc_read();
extern "C" bool ddh_cc_close();
extern "C" void ddh_cc_open();
extern "C" bool ddh_cc_shutdown();
extern "C" void ddh_cc_initialize();
extern "C" void gdev_cc_initinterrupts();
extern "C" void gdev_cc_peek();
extern "C" void gdev_cc_post_stop();
extern "C" void gdev_cc_pre_continue();
extern "C" void gdev_cc_write();
extern "C" void gdev_cc_read();
extern "C" bool gdev_cc_close();
extern "C" void gdev_cc_open();
extern "C" bool gdev_cc_shutdown();
extern "C" void gdev_cc_initialize();
extern "C" bool AMC_IsStub();
extern "C" bool Hu_IsStub();
void OSReport();
void PPCHalt();
void DCFlushRange();
void ICInvalidateRange();
void OSEnableScheduler();
void TRKInterruptHandler();
s32 udp_cc_post_stop();
s32 udp_cc_pre_continue();
u8 udp_cc_peek();
u8 udp_cc_write();
u8 udp_cc_read();
s32 udp_cc_close();
s32 udp_cc_open();
s32 udp_cc_shutdown();
s32 udp_cc_initialize();
void ddh_cc_initinterrupts();
void ddh_cc_peek();
void ddh_cc_post_stop();
void ddh_cc_pre_continue();
void ddh_cc_write();
void ddh_cc_read();
u8 ddh_cc_close();
void ddh_cc_open();
u8 ddh_cc_shutdown();
void ddh_cc_initialize();
void gdev_cc_initinterrupts();
void gdev_cc_peek();
void gdev_cc_post_stop();
void gdev_cc_pre_continue();
void gdev_cc_write();
void gdev_cc_read();
u8 gdev_cc_close();
void gdev_cc_open();
u8 gdev_cc_shutdown();
void gdev_cc_initialize();
u8 AMC_IsStub();
u8 Hu_IsStub();
//
// Declarations:
@@ -110,7 +107,7 @@ asm void InitializeProgramEndTrap() {
/* ############################################################################################## */
/* 803A2C0C-803A2C10 02F26C 0004+00 1/1 0/0 0/0 .rodata @165 */
SECTION_RODATA static u32 const lit_165 = 0x25730A00;
SECTION_RODATA static char const lit_165[] = "%s\n";
COMPILER_STRIP_GATE(0x803A2C0C, &lit_165);
/* 80371CD8-80371D08 36C618 0030+00 0/0 1/1 0/0 .text TRK_board_display */
@@ -155,7 +152,7 @@ asm void ReserveEXI2Port() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKWriteUARTN() {
asm s32 TRKWriteUARTN(const void*, u32) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue/TRKWriteUARTN.s"
}
@@ -209,285 +206,49 @@ asm void TRKInitializeIntDrivenUART() {
/* 803A2C10-803A2C28 02F270 0015+03 0/1 0/0 0/0 .rodata @215 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_215[21 + 3 /* padding */] = {
0x44,
0x65,
0x76,
0x6B,
0x69,
0x74,
0x20,
0x73,
0x65,
0x74,
0x20,
0x74,
0x6F,
0x20,
0x3A,
0x20,
0x25,
0x6C,
0x64,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_215[] = "Devkit set to : %ld\n";
COMPILER_STRIP_GATE(0x803A2C10, &lit_215);
#pragma pop
/* 803A2C28-803A2C40 02F288 0017+01 0/1 0/0 0/0 .rodata @216 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_216[23 + 1 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x3A,
0x20,
0x53,
0x65,
0x74,
0x20,
0x74,
0x6F,
0x20,
0x42,
0x42,
0x41,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_216[] = "MetroTRK : Set to BBA\n";
COMPILER_STRIP_GATE(0x803A2C28, &lit_216);
#pragma pop
/* 803A2C40-803A2C64 02F2A0 0021+03 0/1 0/0 0/0 .rodata @217 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_217[33 + 3 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x3A,
0x20,
0x53,
0x65,
0x74,
0x20,
0x74,
0x6F,
0x20,
0x47,
0x44,
0x45,
0x56,
0x20,
0x68,
0x61,
0x72,
0x64,
0x77,
0x61,
0x72,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_217[] = "MetroTRK : Set to GDEV hardware\n";
COMPILER_STRIP_GATE(0x803A2C40, &lit_217);
#pragma pop
/* 803A2C64-803A2C88 02F2C4 0024+00 0/1 0/0 0/0 .rodata @218 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_218[36] = {
0x4D, 0x65, 0x74, 0x72, 0x6F, 0x54, 0x52, 0x4B, 0x20, 0x3A, 0x20, 0x53,
0x65, 0x74, 0x20, 0x74, 0x6F, 0x20, 0x41, 0x4D, 0x43, 0x20, 0x44, 0x44,
0x48, 0x20, 0x68, 0x61, 0x72, 0x64, 0x77, 0x61, 0x72, 0x65, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_218[] = "MetroTRK : Set to AMC DDH hardware\n";
COMPILER_STRIP_GATE(0x803A2C64, &lit_218);
#pragma pop
/* 803A2C88-803A2CB4 02F2E8 002B+01 0/1 0/0 0/0 .rodata @219 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_219[43 + 1 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x3A,
0x20,
0x53,
0x65,
0x74,
0x20,
0x74,
0x6F,
0x20,
0x55,
0x4E,
0x4B,
0x4E,
0x4F,
0x57,
0x4E,
0x20,
0x68,
0x61,
0x72,
0x64,
0x77,
0x61,
0x72,
0x65,
0x2E,
0x20,
0x28,
0x25,
0x6C,
0x64,
0x29,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_219[] = "MetroTRK : Set to UNKNOWN hardware. (%ld)\n";
COMPILER_STRIP_GATE(0x803A2C88, &lit_219);
#pragma pop
/* 803A2CB4-803A2CE4 02F314 002F+01 0/1 0/0 0/0 .rodata @220 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_220[47 + 1 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x3A,
0x20,
0x49,
0x6E,
0x76,
0x61,
0x6C,
0x69,
0x64,
0x20,
0x68,
0x61,
0x72,
0x64,
0x77,
0x61,
0x72,
0x65,
0x20,
0x49,
0x44,
0x20,
0x70,
0x61,
0x73,
0x73,
0x65,
0x64,
0x20,
0x66,
0x72,
0x6F,
0x6D,
0x20,
0x4F,
0x53,
0x0A,
0x00,
/* padding */
0x00,
};
SECTION_RODATA static char const lit_220[] = "MetroTRK : Invalid hardware ID passed from OS\n";
COMPILER_STRIP_GATE(0x803A2CB4, &lit_220);
#pragma pop
/* 803A2CE4-803A2D10 02F344 0028+04 0/1 0/0 0/0 .rodata @221 */
#pragma push
#pragma force_active on
SECTION_RODATA static u8 const lit_221[40 + 4 /* padding */] = {
0x4D,
0x65,
0x74,
0x72,
0x6F,
0x54,
0x52,
0x4B,
0x20,
0x3A,
0x20,
0x44,
0x65,
0x66,
0x61,
0x75,
0x6C,
0x74,
0x69,
0x6E,
0x67,
0x20,
0x74,
0x6F,
0x20,
0x47,
0x44,
0x45,
0x56,
0x20,
0x48,
0x61,
0x72,
0x64,
0x77,
0x61,
0x72,
0x65,
0x0A,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
};
SECTION_RODATA static char const lit_221[] = "MetroTRK : Defaulting to GDEV Hardware\n";
COMPILER_STRIP_GATE(0x803A2CE4, &lit_221);
#pragma pop
@@ -512,12 +273,9 @@ static asm void TRKEXICallBack() {
#pragma pop
/* ############################################################################################## */
/* 8044F824-8044F828 07C544 0004+00 0/0 0/0 0/0 .bss _MetroTRK_Has_Framing */
#pragma push
#pragma force_active on
SECTION_BSS static u8 _MetroTRK_Has_Framing[4];
#pragma pop
/* 8044F828-8044F830 07C548 0008+00 0/0 2/2 0/0 .bss None */
SECTION_BSS extern u8 data_8044F828[8];
SECTION_BSS u8 data_8044F828[8];
/* 8044F824-8044F828 07C544 0004+00 0/0 0/0 0/0 .bss _MetroTRK_Has_Framing */
SECTION_BSS /* static */ u8 _MetroTRK_Has_Framing[4];
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.c
+17
View File
@@ -0,0 +1,17 @@
/**
* targcont.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h"
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
/* 8037214C-80372180 36CA8C 0034+00 0/0 2/2 0/0 .text TRKTargetContinue */
s32 TRKTargetContinue(void) {
TRKTargetSetStopped(0);
UnreserveEXI2Port();
TRKSwapAndGo();
ReserveEXI2Port();
return 0;
}
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.cpp
-37
View File
@@ -1,37 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: Os/dolphin/targcont
//
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/targcont.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKTargetContinue();
//
// External References:
//
extern "C" void TRKSwapAndGo();
extern "C" void TRKTargetSetStopped();
extern "C" void UnreserveEXI2Port();
extern "C" void ReserveEXI2Port();
//
// Declarations:
//
/* 8037214C-80372180 36CA8C 0034+00 0/0 2/2 0/0 .text TRKTargetContinue */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKTargetContinue() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/Os/dolphin/targcont/TRKTargetContinue.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.c
+19
View File
@@ -0,0 +1,19 @@
/**
* target_options.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.h"
#include "dol2asm.h"
SECTION_BSS static u8 useSerialIO;
/* 80372180-80372190 36CAC0 0010+00 0/0 2/2 0/0 .text GetUseSerialIO */
u8 GetUseSerialIO(void) {
return useSerialIO;
}
/* 80372190-8037219C 36CAD0 000C+00 0/0 1/1 0/0 .text SetUseSerialIO */
void SetUseSerialIO(u8 serialIO) {
useSerialIO = serialIO;
}
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.cpp
-45
View File
@@ -1,45 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: Os/dolphin/target_options
//
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/target_options.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void GetUseSerialIO();
extern "C" void SetUseSerialIO();
//
// External References:
//
SECTION_BSS extern u8 data_8044F828[8];
//
// Declarations:
//
/* 80372180-80372190 36CAC0 0010+00 0/0 2/2 0/0 .text GetUseSerialIO */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void GetUseSerialIO() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options/GetUseSerialIO.s"
}
#pragma pop
/* 80372190-8037219C 36CAD0 000C+00 0/0 1/1 0/0 .text SetUseSerialIO */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void SetUseSerialIO() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/Os/dolphin/target_options/SetUseSerialIO.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.c
+45
View File
@@ -0,0 +1,45 @@
/**
* usr_put.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.h"
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/msghndlr.h"
// #include "dolphin/os/OS.h"
//
// External References:
//
// void OSReport(char* fmt, ...) causes extra crclr instruction.
// look into issue later
void OSReport(char* fmt);
//
// Declarations:
//
/* 8036DB10-8036DB14 368450 0004+00 0/0 1/1 0/0 .text usr_put_initialize */
void usr_put_initialize() {}
/* 8036DB14-8036DB9C 368454 0088+00 0/0 2/2 0/0 .text usr_puts_serial */
BOOL usr_puts_serial(const char* msg) {
BOOL connect_ = FALSE;
char c;
char buf[2];
while (!connect_ && (c = *msg++) != '\0') {
BOOL connect = GetTRKConnected();
buf[0] = c;
buf[1] = '\0';
SetTRKConnected(FALSE);
OSReport(buf);
SetTRKConnected(connect);
connect_ = FALSE;
}
return connect_;
}
libs/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.cpp
-42
View File
@@ -1,42 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: Os/dolphin/usr_put
//
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void usr_put_initialize();
extern "C" void usr_puts_serial();
//
// External References:
//
extern "C" void OSReport();
extern "C" void SetTRKConnected();
extern "C" void GetTRKConnected();
//
// Declarations:
//
/* 8036DB10-8036DB14 368450 0004+00 0/0 1/1 0/0 .text usr_put_initialize */
void usr_put_initialize() {
/* empty function */
}
/* 8036DB14-8036DB9C 368454 0088+00 0/0 2/2 0/0 .text usr_puts_serial */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void usr_puts_serial() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/Os/dolphin/usr_put/usr_puts_serial.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/ppc/Export/targsupp.cpp → libs/TRK_MINNOW_DOLPHIN/ppc/Export/targsupp.c
+4 -23
View File
@@ -1,28 +1,9 @@
//
// Generated By: dol2asm
// Translation Unit: ppc/Export/targsupp
//
/**
* targsupp.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/ppc/Export/targsupp.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRKAccessFile();
extern "C" void TRKOpenFile();
extern "C" void TRKCloseFile();
extern "C" void TRKPositionFile();
//
// External References:
//
//
// Declarations:
//
/* 803711D0-803711D8 -00001 0008+00 0/0 0/0 0/0 .text TRKAccessFile */
#pragma push
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.c
+31
View File
@@ -0,0 +1,31 @@
/**
* flush_cache.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.h"
/* 8036F548-8036F580 369E88 0038+00 0/0 5/5 0/0 .text TRK_flush_cache */
asm void TRK_flush_cache(void) {
// clang-format off
nofralloc
lis r5, 0xFFFF
ori r5, r5, 0xFFF1
and r5, r5, r3
subf r3, r5, r3
add r4, r4, r3
loop:
dcbst 0, r5
dcbf 0, r5
sync
icbi 0, r5
addic r5, r5, 8
addic. r4, r4, -8
bge loop
isync
blr
// clang-format on
}
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.cpp
-32
View File
@@ -1,32 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: ppc/Generic/flush_cache
//
#include "TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void TRK_flush_cache();
//
// External References:
//
//
// Declarations:
//
/* 8036F548-8036F580 369E88 0038+00 0/0 5/5 0/0 .text TRK_flush_cache */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRK_flush_cache() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/ppc/Generic/flush_cache/TRK_flush_cache.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.cpp → libs/TRK_MINNOW_DOLPHIN/ppc/Generic/mpc_7xx_603e.c
+4 -4
View File
@@ -11,15 +11,15 @@
// Forward References:
//
extern "C" void TRKSaveExtended1Block();
extern "C" void TRKRestoreExtended1Block();
void TRKSaveExtended1Block();
void TRKRestoreExtended1Block();
//
// External References:
//
extern "C" extern u8 gTRKRestoreFlags[9 + 3 /* padding */];
extern "C" extern u8 gTRKCPUState[1072];
extern u8 gTRKRestoreFlags[9 + 3 /* padding */];
extern u8 gTRKCPUState[1072];
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.cpp → libs/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.c
+50 -54
View File
@@ -11,61 +11,59 @@
// Forward References:
//
extern "C" void __TRK_get_MSR();
extern "C" void __TRK_set_MSR();
extern "C" static void TRK_ppc_memcpy();
extern "C" void TRKInterruptHandler();
extern "C" static void TRKExceptionHandler();
extern "C" void TRKSwapAndGo();
extern "C" static void TRKInterruptHandlerEnableInterrupts();
extern "C" static void ReadFPSCR();
extern "C" static void WriteFPSCR();
extern "C" void TRKTargetAccessARAM();
extern "C" void TRKTargetSetInputPendingPtr();
extern "C" void TRKTargetStop();
extern "C" void TRKTargetSetStopped();
extern "C" void TRKTargetStopped();
extern "C" void TRKTargetSupportRequest();
extern "C" void TRKTargetGetPC();
extern "C" void TRKTargetStepOutOfRange();
extern "C" void TRKTargetSingleStep();
extern "C" void TRKTargetAddExceptionInfo();
extern "C" void TRKTargetAddStopInfo();
extern "C" void TRKTargetInterrupt();
extern "C" static void TRKPostInterruptEvent();
extern "C" void TRKTargetAccessExtended2();
extern "C" void TRKTargetAccessExtended1();
extern "C" void TRKTargetAccessFP();
extern "C" void TRKTargetAccessDefault();
extern "C" static void TRKTargetReadInstruction();
extern "C" void TRKTargetAccessMemory();
extern "C" static void TRKValidMemory32();
void __TRK_get_MSR();
void __TRK_set_MSR();
static void TRK_ppc_memcpy();
void TRKInterruptHandler();
static void TRKExceptionHandler();
static void TRKInterruptHandlerEnableInterrupts();
static void ReadFPSCR();
static void WriteFPSCR();
void TRKTargetAccessARAM();
void TRKTargetSetInputPendingPtr();
void TRKTargetStop();
void TRKTargetStopped();
void TRKTargetSupportRequest();
void TRKTargetGetPC();
void TRKTargetStepOutOfRange();
void TRKTargetSingleStep();
void TRKTargetAddExceptionInfo();
void TRKTargetAddStopInfo();
void TRKTargetInterrupt();
static void TRKPostInterruptEvent();
void TRKTargetAccessExtended2();
void TRKTargetAccessExtended1();
void TRKTargetAccessFP();
void TRKTargetAccessDefault();
static void TRKTargetReadInstruction();
void TRKTargetAccessMemory();
static void TRKValidMemory32();
//
// External References:
//
SECTION_INIT void memset();
extern "C" void TRKConstructEvent();
extern "C" void TRKPostEvent();
extern "C" void TRKReadBuffer_ui32();
extern "C" void TRKReadBuffer1_ui64();
extern "C" void TRKAppendBuffer_ui32();
extern "C" void TRKAppendBuffer_ui8();
extern "C" void TRKAppendBuffer1_ui64();
extern "C" void HandlePositionFileSupportRequest();
extern "C" void HandleCloseFileSupportRequest();
extern "C" void HandleOpenFileSupportRequest();
extern "C" void TRKSuppAccessFile();
extern "C" void TRKDoNotifyStopped();
extern "C" void TRK_flush_cache();
extern "C" void TRKSaveExtended1Block();
extern "C" void TRKRestoreExtended1Block();
extern "C" void TRK__write_aram();
extern "C" void TRK__read_aram();
extern "C" void TRKTargetTranslate();
extern "C" void TRKUARTInterruptHandler();
extern "C" void MWTRACE();
void TRKConstructEvent();
void TRKPostEvent();
void TRKReadBuffer_ui32();
void TRKReadBuffer1_ui64();
void TRKAppendBuffer_ui32();
void TRKAppendBuffer_ui8();
void TRKAppendBuffer1_ui64();
void HandlePositionFileSupportRequest();
void HandleCloseFileSupportRequest();
void HandleOpenFileSupportRequest();
void TRKSuppAccessFile();
void TRKDoNotifyStopped();
void TRK_flush_cache();
void TRKSaveExtended1Block();
void TRKRestoreExtended1Block();
void TRK__write_aram();
void TRK__read_aram();
void TRKTargetTranslate();
void TRKUARTInterruptHandler();
void MWTRACE();
//
// Declarations:
@@ -123,7 +121,7 @@ SECTION_DATA static u8 gTRKExceptionStatus[16] = {
};
/* 8044F290-8044F294 07BFB0 0002+02 1/1 0/0 0/0 .bss TRK_saved_exceptionID */
SECTION_BSS static u8 TRK_saved_exceptionID[2 + 2 /* padding */];
SECTION_BSS static s32 TRK_saved_exceptionID = 0;
/* 8044F294-8044F338 07BFB4 00A4+00 11/11 1/1 0/0 .bss gTRKState */
extern u8 gTRKState[164];
@@ -231,7 +229,7 @@ asm void TRKTargetStop() {
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void TRKTargetSetStopped() {
asm void TRKTargetSetStopped(s32) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl/TRKTargetSetStopped.s"
}
@@ -299,9 +297,7 @@ SECTION_RODATA static u8 const lit_290[40] = {
COMPILER_STRIP_GATE(0x803A2BC0, &lit_290);
/* 803A2BE8-803A2BF8 02F248 0010+00 3/3 0/0 0/0 .rodata @422 */
SECTION_RODATA static u8 const lit_422[16] = {
0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x44, 0x6F, 0x53, 0x74, 0x65, 0x70, 0x28, 0x29, 0x0A, 0x00,
};
SECTION_RODATA static char const lit_422[] = "TargetDoStep()\n";
COMPILER_STRIP_GATE(0x803A2BE8, &lit_422);
/* 803D3254-803D3268 030374 0014+00 3/3 0/0 0/0 .data gTRKStepStatus */
libs/TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.cpp → libs/TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.c
+7 -7
View File
@@ -11,19 +11,19 @@
// Forward References:
//
extern "C" void CircleBufferReadBytes();
extern "C" void CircleBufferWriteBytes();
extern "C" void CircleBufferInitialize();
extern "C" void CBGetBytesAvailableForRead();
void CircleBufferReadBytes();
void CircleBufferWriteBytes();
void CircleBufferInitialize();
void CBGetBytesAvailableForRead();
//
// External References:
//
SECTION_INIT void memcpy();
extern "C" void MWExitCriticalSection();
extern "C" void MWEnterCriticalSection();
extern "C" void MWInitializeCriticalSection();
void MWExitCriticalSection();
void MWEnterCriticalSection();
void MWInitializeCriticalSection();
//
// Declarations:
libs/TRK_MINNOW_DOLPHIN/utils/common/MWTrace.c
+9
View File
@@ -0,0 +1,9 @@
/**
* MWTrace.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
/* 80372C54-80372CA4 36D594 0050+00 0/0 22/22 0/0 .text MWTRACE */
void MWTRACE(u8, char*, ...) {}
libs/TRK_MINNOW_DOLPHIN/utils/common/MWTrace.cpp
-32
View File
@@ -1,32 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: utils/common/MWTrace
//
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void MWTRACE();
//
// External References:
//
//
// Declarations:
//
/* 80372C54-80372CA4 36D594 0050+00 0/0 22/22 0/0 .text MWTRACE */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void MWTRACE() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/utils/common/MWTrace/MWTRACE.s"
}
#pragma pop
libs/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.c
+31
View File
@@ -0,0 +1,31 @@
/**
* MWCriticalSection_gc.c
* Description:
*/
#include "TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.h"
#include "dolphin/os/OS.h"
/* 80372CA4-80372CC8 36D5E4 0024+00 0/0 2/2 0/0 .text MWExitCriticalSection */
void MWExitCriticalSection(u32* section) {
OSRestoreInterrupts(*section);
}
/* 80372CC8-80372CF8 36D608 0030+00 0/0 2/2 0/0 .text MWEnterCriticalSection */
#ifdef NONMATCHING
void MWEnterCriticalSection(u32* section) {
*section = OSDisableInterrupts();
}
#else
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void MWEnterCriticalSection(u32* section) {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc/MWEnterCriticalSection.s"
}
#pragma pop
#endif
/* 80372CF8-80372CFC 36D638 0004+00 0/0 1/1 0/0 .text MWInitializeCriticalSection */
void MWInitializeCriticalSection() {}
libs/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.cpp
-52
View File
@@ -1,52 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: utils/gc/MWCriticalSection_gc
//
#include "TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void MWExitCriticalSection();
extern "C" void MWEnterCriticalSection();
extern "C" void MWInitializeCriticalSection();
//
// External References:
//
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
//
// Declarations:
//
/* 80372CA4-80372CC8 36D5E4 0024+00 0/0 2/2 0/0 .text MWExitCriticalSection */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void MWExitCriticalSection() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc/MWExitCriticalSection.s"
}
#pragma pop
/* 80372CC8-80372CF8 36D608 0030+00 0/0 2/2 0/0 .text MWEnterCriticalSection */
#pragma push
#pragma optimization_level 0
#pragma optimizewithasm off
asm void MWEnterCriticalSection() {
nofralloc
#include "asm/TRK_MINNOW_DOLPHIN/utils/gc/MWCriticalSection_gc/MWEnterCriticalSection.s"
}
#pragma pop
/* 80372CF8-80372CFC 36D638 0004+00 0/0 1/1 0/0 .text MWInitializeCriticalSection */
void MWInitializeCriticalSection() {
/* empty function */
}
libs/amcstubs/AmcExi2Stubs.c
+38
View File
@@ -0,0 +1,38 @@
/**
* AmcExi2Stubs.c
* Description:
*/
#include "amcstubs/AmcExi2Stubs.h"
/* 80372CFC-80372D00 36D63C 0004+00 0/0 1/1 0/0 .text EXI2_Init */
void EXI2_Init(void) {}
/* 80372D00-80372D04 36D640 0004+00 0/0 1/1 0/0 .text EXI2_EnableInterrupts */
void EXI2_EnableInterrupts(void) {}
/* 80372D04-80372D0C 36D644 0008+00 0/0 2/2 0/0 .text EXI2_Poll */
u8 EXI2_Poll(void) {
return 0;
}
/* 80372D0C-80372D14 36D64C 0008+00 0/0 2/2 0/0 .text EXI2_ReadN */
u8 EXI2_ReadN(void*, u32) {
return 0;
}
/* 80372D14-80372D1C 36D654 0008+00 0/0 1/1 0/0 .text EXI2_WriteN */
u8 EXI2_WriteN(void*, u32) {
return 0;
}
/* 80372D1C-80372D20 36D65C 0004+00 0/0 1/1 0/0 .text EXI2_Reserve */
void EXI2_Reserve(void) {}
/* 80372D20-80372D24 36D660 0004+00 0/0 1/1 0/0 .text EXI2_Unreserve */
void EXI2_Unreserve(void) {}
/* 80372D24-80372D2C 36D664 0008+00 0/0 1/1 0/0 .text AMC_IsStub */
u8 AMC_IsStub(void) {
return 1;
}
libs/amcstubs/AmcExi2Stubs.cpp
-69
View File
@@ -1,69 +0,0 @@
//
// Generated By: dol2asm
// Translation Unit: AmcExi2Stubs
//
#include "amcstubs/AmcExi2Stubs.h"
#include "dol2asm.h"
#include "dolphin/types.h"
//
// Forward References:
//
extern "C" void EXI2_Init();
extern "C" void EXI2_EnableInterrupts();
extern "C" bool EXI2_Poll();
extern "C" bool EXI2_ReadN();
extern "C" bool EXI2_WriteN();
extern "C" void EXI2_Reserve();
extern "C" void EXI2_Unreserve();
extern "C" bool AMC_IsStub();
//
// External References:
//
//
// Declarations:
//
/* 80372CFC-80372D00 36D63C 0004+00 0/0 1/1 0/0 .text EXI2_Init */
void EXI2_Init() {
/* empty function */
}
/* 80372D00-80372D04 36D640 0004+00 0/0 1/1 0/0 .text EXI2_EnableInterrupts */
void EXI2_EnableInterrupts() {
/* empty function */
}
/* 80372D04-80372D0C 36D644 0008+00 0/0 2/2 0/0 .text EXI2_Poll */
bool EXI2_Poll() {
return false;
}
/* 80372D0C-80372D14 36D64C 0008+00 0/0 2/2 0/0 .text EXI2_ReadN */
bool EXI2_ReadN() {
return false;
}
/* 80372D14-80372D1C 36D654 0008+00 0/0 1/1 0/0 .text EXI2_WriteN */
bool EXI2_WriteN() {
return false;
}
/* 80372D1C-80372D20 36D65C 0004+00 0/0 1/1 0/0 .text EXI2_Reserve */
void EXI2_Reserve() {
/* empty function */
}
/* 80372D20-80372D24 36D660 0004+00 0/0 1/1 0/0 .text EXI2_Unreserve */
void EXI2_Unreserve() {
/* empty function */
}
/* 80372D24-80372D2C 36D664 0008+00 0/0 1/1 0/0 .text AMC_IsStub */
bool AMC_IsStub() {
return true;
}
libs/amcstubs/Makefile
+6 -4
View File
@@ -3,12 +3,14 @@
#
LIBAMCSTUBS_A_CPP_FILES := \
libs/amcstubs/AmcExi2Stubs.cpp \
libs/amcstubs/AmcExi2Stubs.c \
LIBAMCSTUBS_A_O_FILES := \
$(BUILD_DIR)/libs/amcstubs/AmcExi2Stubs.o \
LIBAMCSTUBS_A_CFLAGS := \
-O4,p \
-lang=c \
LIBAMCSTUBS_A_LDFLAGS := \
-nodefaults \
@@ -21,9 +23,9 @@ $(BUILD_DIR)/libamcstubs.a: $(LIBAMCSTUBS_A_O_FILES)
@echo $(LIBAMCSTUBS_A_O_FILES) > build/LIBAMCSTUBS_A_ofiles
@$(LD) -xm l $(LIBAMCSTUBS_A_LDFLAGS) -o $(BUILD_DIR)/libamcstubs.a @build/LIBAMCSTUBS_A_ofiles
$(BUILD_DIR)/libs/amcstubs/%.o: libs/amcstubs/%.cpp
$(BUILD_DIR)/libs/amcstubs/%.o: libs/amcstubs/%.c
@mkdir -p $(@D)
@echo building... $<
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).cpp
@$(CC) $(CFLAGS) $(LIBAMCSTUBS_A_CFLAGS) -c -o $@ $(basename $@).cpp
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).c
@$(CC) $(CFLAGS) $(LIBAMCSTUBS_A_CFLAGS) -c -o $@ $(basename $@).c
libs/dolphin/ai/Makefile
+6 -5
View File
@@ -3,12 +3,14 @@
#
LIBAI_A_CPP_FILES := \
libs/dolphin/ai/ai.cpp \
libs/dolphin/ai/ai.c \
LIBAI_A_O_FILES := \
$(BUILD_DIR)/libs/dolphin/ai/ai.o \
LIBAI_A_CFLAGS := \
-O4,p \
-lang=c \
LIBAI_A_LDFLAGS := \
-nodefaults \
@@ -21,9 +23,8 @@ $(BUILD_DIR)/libai.a: $(LIBAI_A_O_FILES)
@echo $(LIBAI_A_O_FILES) > build/LIBAI_A_ofiles
@$(LD) -xm l $(LIBAI_A_LDFLAGS) -o $(BUILD_DIR)/libai.a @build/LIBAI_A_ofiles
$(BUILD_DIR)/libs/dolphin/ai/%.o: libs/dolphin/ai/%.cpp
$(BUILD_DIR)/libs/dolphin/ai/%.o: libs/dolphin/ai/%.c
@mkdir -p $(@D)
@echo building... $<
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).cpp
@$(CC) $(CFLAGS) $(LIBAI_A_CFLAGS) -c -o $@ $(basename $@).cpp
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).c
@$(WINE) tools/mwcc_compiler/1.2.5/mwcceppc.exe $(CFLAGS) $(LIBAI_A_CFLAGS) -c -o $@ $(basename $@).c
libs/dolphin/ai/ai.cpp → libs/dolphin/ai/ai.c
+28 -102
View File
@@ -11,38 +11,38 @@
// Forward References:
//
extern "C" void AIRegisterDMACallback();
extern "C" void AIInitDMA();
extern "C" void AIStartDMA();
extern "C" void AIStopDMA();
extern "C" void AISetStreamPlayState();
extern "C" static void AIGetStreamPlayState();
extern "C" void AISetDSPSampleRate();
extern "C" void AIGetDSPSampleRate();
extern "C" void __AI_set_stream_sample_rate();
extern "C" static void AIGetStreamSampleRate();
extern "C" void AISetStreamVolLeft();
extern "C" static void AIGetStreamVolLeft();
extern "C" void AISetStreamVolRight();
extern "C" static void AIGetStreamVolRight();
extern "C" void AIInit();
extern "C" void __AISHandler();
extern "C" void __AIDHandler();
extern "C" void __AICallbackStackSwitch();
extern "C" void __AI_SRC_INIT();
void AIRegisterDMACallback();
void AIInitDMA();
void AIStartDMA();
void AIStopDMA();
void AISetStreamPlayState();
static void AIGetStreamPlayState();
void AISetDSPSampleRate();
void AIGetDSPSampleRate();
void __AI_set_stream_sample_rate();
static void AIGetStreamSampleRate();
void AISetStreamVolLeft();
static void AIGetStreamVolLeft();
void AISetStreamVolRight();
static void AIGetStreamVolRight();
void AIInit();
void __AISHandler();
void __AIDHandler();
void __AICallbackStackSwitch();
void __AI_SRC_INIT();
//
// External References:
//
extern "C" void OSRegisterVersion();
extern "C" void OSSetCurrentContext();
extern "C" void OSClearContext();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void __OSSetInterruptHandler();
extern "C" void __OSUnmaskInterrupts();
extern "C" void OSGetTime();
void OSRegisterVersion();
void OSSetCurrentContext();
void OSClearContext();
void OSDisableInterrupts();
void OSRestoreInterrupts();
void __OSSetInterruptHandler();
void __OSUnmaskInterrupts();
void OSGetTime();
//
// Declarations:
@@ -197,81 +197,7 @@ static asm void AIGetStreamVolRight() {
/* ############################################################################################## */
/* 803D1BA0-803D1BE8 02ECC0 0044+04 1/0 0/0 0/0 .data @1 */
SECTION_DATA static u8 lit_1[68 + 4 /* padding */] = {
0x3C,
0x3C,
0x20,
0x44,
0x6F,
0x6C,
0x70,
0x68,
0x69,
0x6E,
0x20,
0x53,
0x44,
0x4B,
0x20,
0x2D,
0x20,
0x41,
0x49,
0x09,
0x72,
0x65,
0x6C,
0x65,
0x61,
0x73,
0x65,
0x20,
0x62,
0x75,
0x69,
0x6C,
0x64,
0x3A,
0x20,
0x41,
0x70,
0x72,
0x20,
0x20,
0x35,
0x20,
0x32,
0x30,
0x30,
0x34,
0x20,
0x30,
0x34,
0x3A,
0x31,
0x35,
0x3A,
0x30,
0x32,
0x20,
0x28,
0x30,
0x78,
0x32,
0x33,
0x30,
0x31,
0x29,
0x20,
0x3E,
0x3E,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
};
SECTION_DATA static char lit_1[] = "<< Dolphin SDK - AI\trelease build: Apr 5 2004 04:15:02 (0x2301) >>";
/* 80450A40-80450A48 -00001 0004+04 1/1 0/0 0/0 .sdata __AIVersion */
SECTION_SDATA static void* __AIVersion[1 + 1 /* padding */] = {
libs/dolphin/ar/Makefile
+7 -5
View File
@@ -3,14 +3,16 @@
#
LIBAR_A_CPP_FILES := \
libs/dolphin/ar/ar.cpp \
libs/dolphin/ar/arq.cpp \
libs/dolphin/ar/ar.c \
libs/dolphin/ar/arq.c \
LIBAR_A_O_FILES := \
$(BUILD_DIR)/libs/dolphin/ar/ar.o \
$(BUILD_DIR)/libs/dolphin/ar/arq.o \
LIBAR_A_CFLAGS := \
-O4,p \
-lang=c \
LIBAR_A_LDFLAGS := \
-nodefaults \
@@ -23,9 +25,9 @@ $(BUILD_DIR)/libar.a: $(LIBAR_A_O_FILES)
@echo $(LIBAR_A_O_FILES) > build/LIBAR_A_ofiles
@$(LD) -xm l $(LIBAR_A_LDFLAGS) -o $(BUILD_DIR)/libar.a @build/LIBAR_A_ofiles
$(BUILD_DIR)/libs/dolphin/ar/%.o: libs/dolphin/ar/%.cpp
$(BUILD_DIR)/libs/dolphin/ar/%.o: libs/dolphin/ar/%.c
@mkdir -p $(@D)
@echo building... $<
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).cpp
@$(CC) $(CFLAGS) $(LIBAR_A_CFLAGS) -c -o $@ $(basename $@).cpp
@$(ICONV) -f UTF-8 -t CP932 < $< > $(basename $@).c
@$(WINE) tools/mwcc_compiler/1.2.5/mwcceppc.exe $(CFLAGS) $(LIBAR_A_CFLAGS) -c -o $@ $(basename $@).c
libs/dolphin/ar/ar.cpp → libs/dolphin/ar/ar.c
+18 -92
View File
@@ -11,29 +11,29 @@
// Forward References:
//
extern "C" void ARRegisterDMACallback();
extern "C" void ARGetDMAStatus();
extern "C" void ARStartDMA();
extern "C" void __ARHandler();
extern "C" void __ARClearInterrupt();
extern "C" void __ARGetInterruptStatus();
extern "C" void __ARChecksize();
void ARRegisterDMACallback();
void ARGetDMAStatus();
void ARStartDMA();
void __ARHandler();
void __ARClearInterrupt();
void __ARGetInterruptStatus();
void __ARChecksize();
//
// External References:
//
SECTION_INIT void memset();
extern "C" void PPCSync();
extern "C" void OSRegisterVersion();
extern "C" void DCInvalidateRange();
extern "C" void DCFlushRange();
extern "C" void OSSetCurrentContext();
extern "C" void OSClearContext();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void __OSSetInterruptHandler();
extern "C" void __OSUnmaskInterrupts();
void PPCSync();
void OSRegisterVersion();
void DCInvalidateRange();
void DCFlushRange();
void OSSetCurrentContext();
void OSClearContext();
void OSDisableInterrupts();
void OSRestoreInterrupts();
void __OSSetInterruptHandler();
void __OSUnmaskInterrupts();
//
// Declarations:
@@ -104,81 +104,7 @@ asm u32 ARAlloc(u32) {
/* ############################################################################################## */
/* 803D1BE8-803D1C30 02ED08 0044+04 1/0 0/0 0/0 .data @1 */
SECTION_DATA static u8 lit_1[68 + 4 /* padding */] = {
0x3C,
0x3C,
0x20,
0x44,
0x6F,
0x6C,
0x70,
0x68,
0x69,
0x6E,
0x20,
0x53,
0x44,
0x4B,
0x20,
0x2D,
0x20,
0x41,
0x52,
0x09,
0x72,
0x65,
0x6C,
0x65,
0x61,
0x73,
0x65,
0x20,
0x62,
0x75,
0x69,
0x6C,
0x64,
0x3A,
0x20,
0x41,
0x70,
0x72,
0x20,
0x20,
0x35,
0x20,
0x32,
0x30,
0x30,
0x34,
0x20,
0x30,
0x34,
0x3A,
0x31,
0x35,
0x3A,
0x30,
0x33,
0x20,
0x28,
0x30,
0x78,
0x32,
0x33,
0x30,
0x31,
0x29,
0x20,
0x3E,
0x3E,
0x00,
/* padding */
0x00,
0x00,
0x00,
0x00,
};
SECTION_DATA static char lit_1[] = "<< Dolphin SDK - AR\trelease build: Apr 5 2004 04:15:03 (0x2301) >>";
/* 80450A48-80450A50 -00001 0004+04 1/1 0/0 0/0 .sdata __ARVersion */
SECTION_SDATA static void* __ARVersion[1 + 1 /* padding */] = {
libs/dolphin/ar/arq.cpp → libs/dolphin/ar/arq.c
+10 -84
View File
@@ -11,20 +11,20 @@
// Forward References:
//
extern "C" void __ARQServiceQueueLo();
extern "C" void __ARQCallbackHack();
extern "C" void __ARQInterruptServiceRoutine();
extern "C" void ARQInit();
void __ARQServiceQueueLo();
void __ARQCallbackHack();
void __ARQInterruptServiceRoutine();
void ARQInit();
//
// External References:
//
extern "C" void OSRegisterVersion();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void ARRegisterDMACallback();
extern "C" void ARStartDMA();
void OSRegisterVersion();
void OSDisableInterrupts();
void OSRestoreInterrupts();
void ARRegisterDMACallback();
void ARStartDMA();
//
// Declarations:
@@ -85,81 +85,7 @@ asm void __ARQInterruptServiceRoutine() {
/* ############################################################################################## */
/* 803D1C30-803D1C78 02ED50 0045+03 1/0 0/0 0/0 .data @1 */
SECTION_DATA static u8 lit_1[69 + 3 /* padding */] = {
0x3C,
0x3C,
0x20,
0x44,
0x6F,
0x6C,
0x70,
0x68,
0x69,
0x6E,
0x20,
0x53,
0x44,
0x4B,
0x20,
0x2D,
0x20,
0x41,
0x52,
0x51,
0x09,
0x72,
0x65,
0x6C,
0x65,
0x61,
0x73,
0x65,
0x20,
0x62,
0x75,
0x69,
0x6C,
0x64,
0x3A,
0x20,
0x41,
0x70,
0x72,
0x20,
0x20,
0x35,
0x20,
0x32,
0x30,
0x30,
0x34,
0x20,
0x30,
0x34,
0x3A,
0x31,
0x35,
0x3A,
0x30,
0x34,
0x20,
0x28,
0x30,
0x78,
0x32,
0x33,
0x30,
0x31,
0x29,
0x20,
0x3E,
0x3E,
0x00,
/* padding */
0x00,
0x00,
0x00,
};
SECTION_DATA static char lit_1[] = "<< Dolphin SDK - ARQ\trelease build: Apr 5 2004 04:15:04 (0x2301) >>";
/* 80450A50-80450A58 -00001 0004+04 1/1 0/0 0/0 .sdata __ARQVersion */
SECTION_SDATA static void* __ARQVersion[1 + 1 /* padding */] = {
libs/dolphin/card/CARDBios.cpp → libs/dolphin/card/CARDBios.c
+58 -132
View File
@@ -11,63 +11,63 @@
// Forward References:
//
extern "C" void __CARDDefaultApiCallback();
extern "C" void __CARDSyncCallback();
extern "C" void __CARDExtHandler();
extern "C" void __CARDExiHandler();
extern "C" void __CARDTxHandler();
extern "C" void __CARDUnlockedHandler();
extern "C" void __CARDEnableInterrupt();
extern "C" void __CARDReadStatus();
extern "C" void __CARDReadVendorID();
extern "C" void __CARDClearStatus();
extern "C" static void TimeoutHandler();
extern "C" static void Retry();
extern "C" static void UnlockedCallback();
extern "C" void __CARDStart();
extern "C" void __CARDReadSegment();
extern "C" void __CARDWritePage();
extern "C" void __CARDEraseSector();
extern "C" void CARDInit();
extern "C" void __CARDGetFontEncode();
extern "C" void __CARDSetDiskID();
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void CARDFreeBlocks();
extern "C" void __CARDSync();
extern "C" static void OnReset();
extern "C" void CARDGetFastMode();
void __CARDDefaultApiCallback();
void __CARDSyncCallback();
void __CARDExtHandler();
void __CARDExiHandler();
void __CARDTxHandler();
void __CARDUnlockedHandler();
void __CARDEnableInterrupt();
void __CARDReadStatus();
void __CARDReadVendorID();
void __CARDClearStatus();
static void TimeoutHandler();
static void Retry();
static void UnlockedCallback();
void __CARDStart();
void __CARDReadSegment();
void __CARDWritePage();
void __CARDEraseSector();
void CARDInit();
void __CARDGetFontEncode();
void __CARDSetDiskID();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void CARDFreeBlocks();
void __CARDSync();
static void OnReset();
void CARDGetFastMode();
//
// External References:
//
extern "C" void OSRegisterVersion();
extern "C" void OSInitAlarm();
extern "C" void OSCreateAlarm();
extern "C" void OSSetAlarm();
extern "C" void OSCancelAlarm();
extern "C" void OSGetFontEncode();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void OSRegisterResetFunction();
extern "C" void OSInitThreadQueue();
extern "C" void OSSleepThread();
extern "C" void OSWakeupThread();
extern "C" void EXIImm();
extern "C" void EXIImmEx();
extern "C" void EXIDma();
extern "C" void EXISync();
extern "C" void EXISetExiCallback();
extern "C" void EXIProbe();
extern "C" void EXISelect();
extern "C" void EXIDeselect();
extern "C" void EXILock();
extern "C" void EXIUnlock();
extern "C" void DSPInit();
extern "C" void __CARDGetFatBlock();
extern "C" void __CARDGetDirBlock();
extern "C" void CARDUnmount();
void OSRegisterVersion();
void OSInitAlarm();
void OSCreateAlarm();
void OSSetAlarm();
void OSCancelAlarm();
void OSGetFontEncode();
void OSDisableInterrupts();
void OSRestoreInterrupts();
void OSRegisterResetFunction();
void OSInitThreadQueue();
void OSSleepThread();
void OSWakeupThread();
void EXIImm();
void EXIImmEx();
void EXIDma();
void EXISync();
void EXISetExiCallback();
void EXIProbe();
void EXISelect();
void EXIDeselect();
void EXILock();
void EXIUnlock();
void DSPInit();
void __CARDGetFatBlock();
void __CARDGetDirBlock();
void CARDUnmount();
//
// Declarations:
@@ -78,6 +78,11 @@ void __CARDDefaultApiCallback() {
/* empty function */
}
/* ############################################################################################## */
/* 8044CDE0-8044CE00 079B00 0020+00 0/1 3/3 0/0 .bss __CARDDiskNone */
extern u8 __CARDDiskNone[32];
u8 __CARDDiskNone[32];
/* ############################################################################################## */
/* 8044CBC0-8044CDE0 0798E0 0220+00 16/16 27/27 0/0 .bss __CARDBlock */
extern u8 __CARDBlock[544];
@@ -245,81 +250,7 @@ asm void __CARDEraseSector() {
/* ############################################################################################## */
/* 803D1E38-803D1E80 02EF58 0046+02 1/0 0/0 0/0 .data @1 */
SECTION_DATA static u8 lit_1[70 + 2 /* padding */] = {
0x3C,
0x3C,
0x20,
0x44,
0x6F,
0x6C,
0x70,
0x68,
0x69,
0x6E,
0x20,
0x53,
0x44,
0x4B,
0x20,
0x2D,
0x20,
0x43,
0x41,
0x52,
0x44,
0x09,
0x72,
0x65,
0x6C,
0x65,
0x61,
0x73,
0x65,
0x20,
0x62,
0x75,
0x69,
0x6C,
0x64,
0x3A,
0x20,
0x41,
0x70,
0x72,
0x20,
0x20,
0x35,
0x20,
0x32,
0x30,
0x30,
0x34,
0x20,
0x30,
0x34,
0x3A,
0x31,
0x35,
0x3A,
0x33,
0x35,
0x20,
0x28,
0x30,
0x78,
0x32,
0x33,
0x30,
0x31,
0x29,
0x20,
0x3E,
0x3E,
0x00,
/* padding */
0x00,
0x00,
};
SECTION_DATA static char lit_1[] = "<< Dolphin SDK - CARD\trelease build: Apr 5 2004 04:15:35 (0x2301) >>";
/* 803D1E80-803D1EA0 -00001 0010+10 1/1 0/0 0/0 .data ResetFunctionInfo */
SECTION_DATA static void* ResetFunctionInfo[4 + 4 /* padding */] = {
@@ -366,11 +297,6 @@ asm void __CARDGetFontEncode() {
}
#pragma pop
/* ############################################################################################## */
/* 8044CDE0-8044CE00 079B00 0020+00 0/1 3/3 0/0 .bss __CARDDiskNone */
extern u8 __CARDDiskNone[32];
u8 __CARDDiskNone[32];
/* 80353B7C-80353BB4 34E4BC 0038+00 1/1 0/0 0/0 .text __CARDSetDiskID */
#pragma push
#pragma optimization_level 0
libs/dolphin/card/CARDBlock.cpp → libs/dolphin/card/CARDBlock.c
+11 -11
View File
@@ -11,23 +11,23 @@
// Forward References:
//
extern "C" void __CARDGetFatBlock();
extern "C" static void WriteCallback();
extern "C" static void EraseCallback();
extern "C" void __CARDAllocBlock();
extern "C" void __CARDUpdateFatBlock();
void __CARDGetFatBlock();
static void WriteCallback();
static void EraseCallback();
void __CARDAllocBlock();
void __CARDUpdateFatBlock();
//
// External References:
//
SECTION_INIT void memcpy();
extern "C" void DCStoreRange();
extern "C" void __CARDEraseSector();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDWrite();
extern "C" void __CARDCheckSum();
extern "C" extern u8 __CARDBlock[544];
void DCStoreRange();
void __CARDEraseSector();
void __CARDPutControlBlock();
void __CARDWrite();
void __CARDCheckSum();
extern u8 __CARDBlock[544];
//
// Declarations:
libs/dolphin/card/CARDCheck.cpp → libs/dolphin/card/CARDCheck.c
+20 -20
View File
@@ -11,13 +11,13 @@
// Forward References:
//
extern "C" void __CARDCheckSum();
extern "C" static void VerifyID();
extern "C" static void VerifyDir();
extern "C" static void VerifyFAT();
extern "C" void __CARDVerify();
extern "C" static void CARDCheckExAsync();
extern "C" void CARDCheck();
void __CARDCheckSum();
static void VerifyID();
static void VerifyDir();
static void VerifyFAT();
void __CARDVerify();
static void CARDCheckExAsync();
void CARDCheck();
//
// External References:
@@ -25,19 +25,19 @@ extern "C" void CARDCheck();
SECTION_INIT void memset();
SECTION_INIT void memcpy();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void __OSLockSramEx();
extern "C" void __OSUnlockSramEx();
extern "C" void __CARDSyncCallback();
extern "C" void __CARDGetFontEncode();
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDSync();
extern "C" void __CARDUpdateFatBlock();
extern "C" void __CARDUpdateDir();
extern "C" void __shr2i();
extern "C" extern u8 __CARDBlock[544];
void OSDisableInterrupts();
void OSRestoreInterrupts();
void __OSLockSramEx();
void __OSUnlockSramEx();
void __CARDSyncCallback();
void __CARDGetFontEncode();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void __CARDSync();
void __CARDUpdateFatBlock();
void __CARDUpdateDir();
void __shr2i();
extern u8 __CARDBlock[544];
//
// Declarations:
libs/dolphin/card/CARDCreate.cpp → libs/dolphin/card/CARDCreate.c
+19 -19
View File
@@ -11,31 +11,31 @@
// Forward References:
//
extern "C" static void CreateCallbackFat();
extern "C" static void CARDCreateAsync();
extern "C" void CARDCreate();
static void CreateCallbackFat();
static void CARDCreateAsync();
void CARDCreate();
//
// External References:
//
SECTION_INIT void memcpy();
extern "C" void OSGetTime();
extern "C" void __CARDDefaultApiCallback();
extern "C" void __CARDSyncCallback();
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDSync();
extern "C" void __CARDGetFatBlock();
extern "C" void __CARDAllocBlock();
extern "C" void __CARDGetDirBlock();
extern "C" void __CARDUpdateDir();
extern "C" void __CARDCompareFileName();
extern "C" void __div2i();
extern "C" void memcmp();
extern "C" void strncpy();
extern "C" void strlen();
extern "C" extern u8 __CARDBlock[544];
void OSGetTime();
void __CARDDefaultApiCallback();
void __CARDSyncCallback();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void __CARDSync();
void __CARDGetFatBlock();
void __CARDAllocBlock();
void __CARDGetDirBlock();
void __CARDUpdateDir();
void __CARDCompareFileName();
void __div2i();
void memcmp();
void strncpy();
void strlen();
extern u8 __CARDBlock[544];
//
// Declarations:
libs/dolphin/card/CARDDir.cpp → libs/dolphin/card/CARDDir.c
+10 -10
View File
@@ -11,22 +11,22 @@
// Forward References:
//
extern "C" void __CARDGetDirBlock();
extern "C" static void WriteCallback();
extern "C" static void EraseCallback();
extern "C" void __CARDUpdateDir();
void __CARDGetDirBlock();
static void WriteCallback();
static void EraseCallback();
void __CARDUpdateDir();
//
// External References:
//
SECTION_INIT void memcpy();
extern "C" void DCStoreRange();
extern "C" void __CARDEraseSector();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDWrite();
extern "C" void __CARDCheckSum();
extern "C" extern u8 __CARDBlock[544];
void DCStoreRange();
void __CARDEraseSector();
void __CARDPutControlBlock();
void __CARDWrite();
void __CARDCheckSum();
extern u8 __CARDBlock[544];
//
// Declarations:
libs/dolphin/card/CARDFormat.cpp → libs/dolphin/card/CARDFormat.c
+20 -20
View File
@@ -11,9 +11,9 @@
// Forward References:
//
extern "C" static void FormatCallback();
extern "C" void __CARDFormatRegionAsync();
extern "C" void CARDFormat();
static void FormatCallback();
void __CARDFormatRegionAsync();
void CARDFormat();
//
// External References:
@@ -21,23 +21,23 @@ extern "C" void CARDFormat();
SECTION_INIT void memset();
SECTION_INIT void memcpy();
extern "C" void DCStoreRange();
extern "C" void __OSLockSram();
extern "C" void __OSLockSramEx();
extern "C" void __OSUnlockSram();
extern "C" void __OSUnlockSramEx();
extern "C" void OSGetTime();
extern "C" void __CARDDefaultApiCallback();
extern "C" void __CARDSyncCallback();
extern "C" void __CARDEraseSector();
extern "C" void __CARDGetFontEncode();
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDSync();
extern "C" void __CARDWrite();
extern "C" void __CARDCheckSum();
extern "C" void __shr2i();
extern "C" extern u8 __CARDBlock[544];
void DCStoreRange();
void __OSLockSram();
void __OSLockSramEx();
void __OSUnlockSram();
void __OSUnlockSramEx();
void OSGetTime();
void __CARDDefaultApiCallback();
void __CARDSyncCallback();
void __CARDEraseSector();
void __CARDGetFontEncode();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void __CARDSync();
void __CARDWrite();
void __CARDCheckSum();
void __shr2i();
extern u8 __CARDBlock[544];
//
// Declarations:
libs/dolphin/card/CARDMount.cpp → libs/dolphin/card/CARDMount.c
+42 -42
View File
@@ -11,53 +11,53 @@
// Forward References:
//
extern "C" static void IsCard();
extern "C" void CARDProbe();
extern "C" void CARDProbeEx();
extern "C" static void DoMount();
extern "C" void __CARDMountCallback();
extern "C" static void CARDMountAsync();
extern "C" void CARDMount();
extern "C" static void DoUnmount();
extern "C" void CARDUnmount();
static void IsCard();
void CARDProbe();
void CARDProbeEx();
static void DoMount();
void __CARDMountCallback();
static void CARDMountAsync();
void CARDMount();
static void DoUnmount();
void CARDUnmount();
//
// External References:
//
extern "C" void OSCancelAlarm();
extern "C" void DCInvalidateRange();
extern "C" void OSDisableInterrupts();
extern "C" void OSRestoreInterrupts();
extern "C" void __OSLockSramEx();
extern "C" void __OSUnlockSramEx();
extern "C" void EXISetExiCallback();
extern "C" void EXIProbe();
extern "C" void EXIProbeEx();
extern "C" void EXIAttach();
extern "C" void EXIDetach();
extern "C" void EXILock();
extern "C" void EXIUnlock();
extern "C" void EXIGetState();
extern "C" void EXIGetID();
extern "C" void __CARDDefaultApiCallback();
extern "C" void __CARDSyncCallback();
extern "C" void __CARDExtHandler();
extern "C" void __CARDExiHandler();
extern "C" void __CARDUnlockedHandler();
extern "C" void __CARDEnableInterrupt();
extern "C" void __CARDReadStatus();
extern "C" void __CARDReadVendorID();
extern "C" void __CARDClearStatus();
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDSync();
extern "C" void CARDGetFastMode();
extern "C" void __CARDUnlock();
extern "C" void __CARDRead();
extern "C" void __CARDVerify();
extern "C" extern u8 __CARDBlock[544];
extern "C" extern u8 struct_80450A70[8];
void OSCancelAlarm();
void DCInvalidateRange();
void OSDisableInterrupts();
void OSRestoreInterrupts();
void __OSLockSramEx();
void __OSUnlockSramEx();
void EXISetExiCallback();
void EXIProbe();
void EXIProbeEx();
void EXIAttach();
void EXIDetach();
void EXILock();
void EXIUnlock();
void EXIGetState();
void EXIGetID();
void __CARDDefaultApiCallback();
void __CARDSyncCallback();
void __CARDExtHandler();
void __CARDExiHandler();
void __CARDUnlockedHandler();
void __CARDEnableInterrupt();
void __CARDReadStatus();
void __CARDReadVendorID();
void __CARDClearStatus();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void __CARDSync();
void CARDGetFastMode();
void __CARDUnlock();
void __CARDRead();
void __CARDVerify();
extern u8 __CARDBlock[544];
extern u8 struct_80450A70[8];
//
// Declarations:
libs/dolphin/card/CARDNet.cpp → libs/dolphin/card/CARDNet.c
+4 -4
View File
@@ -11,15 +11,15 @@
// Forward References:
//
extern "C" void CARDGetSerialNo();
extern "C" extern u8 struct_80450A70[8];
void CARDGetSerialNo();
extern u8 struct_80450A70[8];
//
// External References:
//
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
void __CARDGetControlBlock();
void __CARDPutControlBlock();
//
// Declarations:
libs/dolphin/card/CARDOpen.cpp → libs/dolphin/card/CARDOpen.c
+12 -12
View File
@@ -11,23 +11,23 @@
// Forward References:
//
extern "C" void __CARDCompareFileName();
extern "C" void __CARDAccess();
extern "C" void __CARDIsWritable();
extern "C" void __CARDIsReadable();
extern "C" void CARDOpen();
extern "C" void CARDClose();
void __CARDCompareFileName();
void __CARDAccess();
void __CARDIsWritable();
void __CARDIsReadable();
void CARDOpen();
void CARDClose();
//
// External References:
//
extern "C" void __CARDGetControlBlock();
extern "C" void __CARDPutControlBlock();
extern "C" void __CARDGetDirBlock();
extern "C" void memcmp();
extern "C" extern u8 __CARDDiskNone[32];
extern "C" extern u8 struct_80450A70[8];
void __CARDGetControlBlock();
void __CARDPutControlBlock();
void __CARDGetDirBlock();
void memcmp();
extern u8 __CARDDiskNone[32];
extern u8 struct_80450A70[8];
//
// Declarations:
libs/dolphin/card/CARDRdwr.cpp → libs/dolphin/card/CARDRdwr.c
+8 -8
View File
@@ -11,19 +11,19 @@
// Forward References:
//
extern "C" static void BlockReadCallback();
extern "C" void __CARDRead();
extern "C" static void BlockWriteCallback();
extern "C" void __CARDWrite();
static void BlockReadCallback();
void __CARDRead();
static void BlockWriteCallback();
void __CARDWrite();
//
// External References:
//
extern "C" void __CARDReadSegment();
extern "C" void __CARDWritePage();
extern "C" void __CARDPutControlBlock();
extern "C" extern u8 __CARDBlock[544];
void __CARDReadSegment();
void __CARDWritePage();
void __CARDPutControlBlock();
extern u8 __CARDBlock[544];
//
// Declarations:

Some files were not shown because too many files have changed in this diff Show More