--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/cppexceptions/t_romtable.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,376 @@
+// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\cppexceptions\t_romtable.cpp
+// Overview:
+// Check accessibility and integrity of ROM exception search table.
+// API Information:
+// TRomHeader, TRomExceptionSearchTable, TExceptionDescriptor
+// Details:
+// - Get the ROM exception search table, verify results are as expected.
+// - Check that the correct exception descriptor is returned by
+// GetExceptionDescriptor().
+// - Check that the correct index table entry can be found.
+// - Initialize the unwinder cache of a UCB with an exception descriptor
+// and check we get the right result.
+// - Throw and catch a variety of exceptions and verify results are as expected.
+// Platforms/Drives/Compatibility:
+// Hardware (Automatic).
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+//
+//
+
+/* Environment: */
+#include "unwind_env.h"
+/* Language-independent unwinder declarations: */
+#include "unwinder.h"
+
+#include "symbian_support.h"
+
+#include <f32file.h>
+#include <e32test.h>
+#include <e32rom.h>
+#include <cpudefs.h>
+
+GLDEF_D RTest test(_L("T_ROMTABLE"));
+
+TRomHeader * pTheRomHeader;
+char * GetExceptionDescriptor(void);
+extern "C" {
+ IMPORT_C TRomExceptionSearchTable * GetROMExceptionSearchTable(void);
+ IMPORT_C TExceptionDescriptor * SearchEST(uint32_t addr, TRomExceptionSearchTable * aESTp);
+ TExceptionDescriptor * GetRAMLoadedExceptionDescriptor(uint32_t addr);
+ IMPORT_C const __EIT_entry *SearchEITV1(uint32_t return_address_offset, const __EIT_entry *base, unsigned int nelems);
+ IMPORT_C __EIT_entry* SearchEITV2(uint32_t return_address, const __EIT_entry* base, unsigned int nelems);
+ TExceptionDescriptor * ReLoadExceptionDescriptor(uint32_t addr, _Unwind_Control_Block * ucbp);
+ IMPORT_C void InitialiseSymbianSpecificUnwinderCache(uint32_t addr, _Unwind_Control_Block * ucbp);
+
+ void *__cxa_allocate_exception(size_t size);
+ IMPORT_C __cxa_eh_globals * __cxa_get_globals();
+
+#ifdef _DEBUG
+ IMPORT_C void DebugPrintf(const char * aFmt, ...);
+#endif
+}
+
+int catcher(int x);
+int catcher2(int x);
+int catcher3(int x);
+int catcher4(int x);
+int catcher5(int x);
+void TestUncaught(void);
+const __EIT_entry * DumbGetEITV1(TUint32 offset, const __EIT_entry * base, TUint32 n);
+__EIT_entry * DumbGetEITV2(TUint32 addr, __EIT_entry * base, TUint32 n);
+
+GLDEF_C TInt E32Main()
+ {
+ test.Start(_L("Check accessibility and integrity of ROM exception search table"));
+
+ TRomExceptionSearchTable * pEST = GetROMExceptionSearchTable();
+ test.Printf(_L("ROM EST @ %08x\n"), pEST);
+ test(pEST != 0);
+
+ test.Printf(_L("ROM EST contains %d entries\n"), pEST->iNumEntries);
+
+ for (int i=0; i<pEST->iNumEntries; i++)
+ {
+ TRomImageHeader * pE = (TRomImageHeader *)pEST->iEntries[i];
+ TRomImageHeader * pH = pE -1;
+ TUint xd = pH->iExceptionDescriptor;
+ if ((xd&1)==0 || xd==0xffffffffu)
+ continue;
+ xd &= ~1;
+ TExceptionDescriptor * pED = (TExceptionDescriptor *) ((char *)pE + xd);
+ char * aExIdxBase = (char *)pED->iExIdxBase;
+ char * aExIdxLimit = (char *)pED->iExIdxLimit;
+ char * aROBase = (char *) pED->iROSegmentBase;
+ char * aROLimit = (char *)pED->iROSegmentLimit;
+
+ test.Printf(_L("%d\n"),i);
+
+ test(aExIdxBase <= aExIdxLimit);
+
+ test(aROBase <= aROLimit);
+
+ test(aROBase <= aExIdxBase);
+ test(aExIdxLimit <= aROLimit);
+ }
+ test.Printf(_L("\n"));
+
+#ifdef __SUPPORT_CPP_EXCEPTIONS__
+ // Check we get the right Exception Descriptor
+ char * myExcpDesc = GetExceptionDescriptor();
+ uint32_t addr = (uint32_t)GetExceptionDescriptor;
+
+ test.Printf(_L("Checking &GetExceptionDescriptor [%08x] in EST range: %08x - %08x\n"),
+ addr, pEST->iEntries[0], GET_EST_FENCEPOST(pEST));
+ test(addr >= pEST->iEntries[0] && addr < GET_EST_FENCEPOST(pEST));
+ TExceptionDescriptor * aExcpDescP = SearchEST(addr, pEST);
+ test.Printf(_L("Found entry %08x in EST\n"), aExcpDescP);
+ test(aExcpDescP != NULL);
+ test.Printf(_L("Check myExcpDesc[%08x] == aExcpDescP[%08x]\n"), myExcpDesc, aExcpDescP);
+ test(myExcpDesc==(char*)aExcpDescP);
+
+ // Now check we can find the right entry in the index table.
+ __EIT_entry * aExIdxBase1 = (__EIT_entry *)aExcpDescP->iExIdxBase;
+ __EIT_entry * aExIdxLimit1 = (__EIT_entry *)aExcpDescP->iExIdxLimit;
+ unsigned int nelems = aExIdxLimit1 - aExIdxBase1;
+ uint32_t aROBase1 = (uint32_t)aExcpDescP->iROSegmentBase;
+ int ehabiv2 = aROBase1 & 1;
+ aROBase1 = aROBase1 & EHABI_MASK;
+ uint32_t aRetOffest = addr - aROBase1;
+ test.Printf(_L("EHABI_V2= %d: Looking up %08x with base %08x in ExIdx @ %08x with %d entries\n"),
+ ehabiv2, addr, aROBase1, aExIdxBase1, nelems);
+ if (ehabiv2) {
+ __EIT_entry * aResult = SearchEITV2(addr, aExIdxBase1, nelems);
+ __EIT_entry * aResult1 = DumbGetEITV2(addr, aExIdxBase1, nelems);
+ test.Printf(_L("Check result %08x == %08x\n"), aResult, aResult1);
+ test(aResult == aResult1);
+ } else {
+ const __EIT_entry * aResult = SearchEITV1(aRetOffest, aExIdxBase1, nelems);
+ const __EIT_entry * aResult1 = DumbGetEITV1(aRetOffest, aExIdxBase1, nelems);
+ test.Printf(_L("Check result %08x == %08x\n"), aResult, aResult1);
+ test(aResult == aResult1);
+ }
+#ifdef _DEBUG
+ DebugPrintf("Exception diagnostic print support is working if you can see this!!\n\r");
+#else
+ test.Printf(_L("Exception diagnostic print support only available in UDEB builds - not tested\n"));
+#endif
+
+ //check we've got some eh_globals
+ __cxa_eh_globals *g = __cxa_get_globals();
+ test.Printf(_L("Exception Handling globals for this thread allocated @ %08x\n"), g);
+ test(g != NULL);
+ test.Printf(_L("Emergency Buffer @ %08x\n"), g->emergency_buffer);
+
+ // now initialize a the unwinder cache of a ucbp with an exception descriptor
+ // and check we get the right result.
+ test.Printf(_L("Allocate an empty exception object\n"));
+ __cxa_exception *ep = ((__cxa_exception *)__cxa_allocate_exception(0)) - 1;
+ test.Printf(_L("Empty Exception Object @ %08x UCB @ %08x\n"), ep, &ep->ucb);
+ test.Printf(_L("Initialize the UCB with the EST and the current exception descriptor\n"));
+ InitialiseSymbianSpecificUnwinderCache(addr, &ep->ucb);
+ test.Printf(_L("Check the EST in the UCB [%08x] == %08x and the Exception Desc [%08x] == %08x\n"),
+ GET_ROM_EST(&ep->ucb), pEST, GET_EXCEPTION_DESCRIPTOR(&ep->ucb), myExcpDesc);
+ test(GET_ROM_EST(&ep->ucb)==pEST);
+ test((char*)GET_EXCEPTION_DESCRIPTOR(&ep->ucb)== myExcpDesc);
+
+ test.Printf(_L("Throwing first exception.\n"));
+ int r = catcher(2);
+ test.Printf(_L("Returned %d expected 2\n"), r);
+ test(r==2);
+
+ test.Printf(_L("Not throwing first exception.\n"));
+ r = catcher(0);
+ test.Printf(_L("Returned %d expected -1\n"), r);
+ test(r==-1);
+
+ test.Printf(_L("Throwing second exception.\n"));
+ r = catcher2(3);
+ test.Printf(_L("Returned %d expected 3\n"), r);
+ test(r==3);
+
+ test.Printf(_L("Not throwing second exception.\n"));
+ r = catcher2(0);
+ test.Printf(_L("Returned %d expected -1\n"), r);
+ test(r==-1);
+
+ test.Printf(_L("Throwing third exception.\n"));
+ r = catcher3(4);
+ test.Printf(_L("Returned %d expected 4\n"), r);
+ test(r==4);
+
+ test.Printf(_L("Not throwing third exception.\n"));
+ r = catcher3(0);
+ test.Printf(_L("Returned %d expected -1\n"), r);
+ test(r==-1);
+
+ test.Printf(_L("Throwing fourth exception.\n"));
+ r = catcher4(5);
+ test.Printf(_L("Returned %d expected 5\n"), r);
+ test(r==5);
+
+ test.Printf(_L("Not throwing fourth exception.\n"));
+ r = catcher4(0);
+ test.Printf(_L("Returned %d expected -1\n"), r);
+ test(r==-1);
+
+ test.Printf(_L("Throwing fifth exception.\n"));
+ r = catcher5(6);
+ test.Printf(_L("Returned %d expected 6\n"), r);
+ test(r==6);
+
+ test.Printf(_L("Not throwing fifth exception.\n"));
+ r = catcher5(0);
+ test.Printf(_L("Returned %d expected -1\n"), r);
+ test(r==-1);
+
+ test.Printf(_L("Testing std::uncaught_exception.\n"));
+ TestUncaught();
+#endif
+
+ test.End();
+ test.Close();
+ return 0;
+ }
+
+#ifdef __ARMCC__
+// We rely on this immediately following E32main. DONT MOVE IT
+__asm char * GetExceptionDescriptor(void) {
+ extern |Symbian$$CPP$$Exception$$Descriptor|
+ ldr r0, theExceptionDesc
+
+#ifdef __SUPPORT_THUMB_INTERWORKING
+ bx lr
+#else
+ mov pc, lr
+#endif
+
+theExceptionDesc dcd |Symbian$$CPP$$Exception$$Descriptor|
+}
+#endif
+
+const __EIT_entry * DumbGetEITV1(TUint32 offset, const __EIT_entry * base, TUint32 n) {
+ if (n && offset < base[0].fnoffset) return 0;
+ for (int i=0; i<n; i++) {
+ // check for last entry
+ if (i == n-1 && base[i].fnoffset <= offset) return &base[i];
+ if (base[i].fnoffset <= offset && offset < base[i+1].fnoffset) return &base[i];
+ }
+ return 0;
+}
+
+static uint32_t __ARM_resolve_prel31(void *p)
+{
+ return (uint32_t)((((*(int32_t *)p) << 1) >> 1) + (int32_t)p);
+}
+
+__EIT_entry * DumbGetEITV2(TUint32 addr, __EIT_entry * base, TUint32 n) {
+ if (n && (addr < __ARM_resolve_prel31(&base[0].fnoffset)))
+ return 0;
+ for (int i=0; i<n; i++) {
+ // check for last entry
+ if (i == n-1 && __ARM_resolve_prel31(&base[i].fnoffset) <= addr)
+ return &base[i];
+ if ((__ARM_resolve_prel31(&base[i].fnoffset) <= addr) &&
+ (addr < __ARM_resolve_prel31(&base[i+1].fnoffset)))
+ return &base[i];
+ }
+ return 0;
+}
+
+#ifdef __SUPPORT_CPP_EXCEPTIONS__
+
+class MyFirstException {
+public:
+ MyFirstException(int x) { iVal = x; };
+ virtual ~MyFirstException();
+ int iVal;
+};
+
+MyFirstException::~MyFirstException(){}
+
+int thrower (int x) {
+ if (x != 0) throw MyFirstException(x);
+ return -1;
+}
+
+int catcher(int x) {
+ try {
+ return thrower(x);
+ }
+ catch(MyFirstException& e)
+ {
+ return e.iVal;
+ }
+}
+
+
+#include "second_excp.h"
+
+
+int catcher2(int x) {
+ try {
+ return thrower2(x);
+ }
+ catch(MySecondException& e)
+ {
+ return e.iVal;
+ }
+}
+
+int catcher3(int x) {
+ try {
+ return thrower3(x);
+ }
+ catch(MyThirdException& e)
+ {
+ return e.iVal;
+ }
+}
+
+int catcher4(int x) {
+ try {
+ return thrower4(x);
+ }
+ catch(MyFourthException& e)
+ {
+ return e.iVal;
+ }
+}
+
+int catcher5(int x) {
+ try {
+ return thrower5(x);
+ }
+ catch(MyFifthException& e)
+ {
+ return e.iVal;
+ }
+}
+
+void TestUncaught(void) {
+ TInt x = 0;
+ try {
+ UncaughtTester aTester(x);
+ test.Printf(_L("Check throw case\n"));
+ thrower(0);
+ }
+ catch(MyFirstException& e)
+ {
+ test.Printf(_L("~Check x == 0\n"));
+ test(x == 0);
+ }
+ try {
+ UncaughtTester aTester(x);
+ test.Printf(_L("Check no throw case\n"));
+ }
+ catch(MyFirstException& e)
+ {
+ test.Printf(_L("Whoops!!!\n"));
+ }
+ test(x==1);
+}
+
+
+#endif
+
+
+
+
+
+
+