diff -r 000000000000 -r 96e5fb8b040d kerneltest/e32test/cppexceptions/t_romtable.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/cppexceptions/t_romtable.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -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
+
+
+
+
+
+
+