1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18  @internalComponent

    19 */

    20 

    21 class Exec

    22 	{

    23 public:

    24 	static void WaitForAnyRequest();

    25 	static RAllocator* Heap();

    26 	static RAllocator* HeapSwitch(RAllocator*);

    27 	static TTrapHandler* PushTrapFrame(TTrap*);

    28 	static TTrap* PopTrapFrame();

    29 	static CActiveScheduler* ActiveScheduler();

    30 	static void SetActiveScheduler(CActiveScheduler*);

    31 	static TTimerLockSpec LockPeriod();

    32 	static TTrapHandler* TrapHandler();

    33 	static TTrapHandler* SetTrapHandler(TTrapHandler*);

    34 	static TInt LockedInc(TInt&);

    35 	static TInt LockedDec(TInt&);

    36 	static TUint32 DebugMask();

    37 	static TUint32 DebugMaskIndex(TUint);

    38 	static void SetDebugMask(TUint32);

    39 	static TUint32 FastCounter();

    40 	static TUint32 NTickCount();

    41 	static TInt SafeInc(TInt&);

    42 	static TInt SafeDec(TInt&);

    43 	static void SetReentryPoint(TLinAddr);

    44 	static TUint32 KernelConfigFlags();

    45 	static TInt UTCOffset();

    46 	static TInt GetGlobalUserData(TInt);

    47 	static TInt ObjectNext(TObjectType, TBuf8<KMaxFullName>&, TFindHandle&);

    48 	static TUint8* ChunkBase(TInt);

    49 	static TInt ChunkSize(TInt);

    50 	static TInt ChunkMaxSize(TInt);

    51 	static TUint HandleAttributes(TInt);

    52 	static TUint TickCount();

    53 	static void LogicalDeviceGetCaps(TInt, TDes8&);

    54 	static TBool LogicalDeviceQueryVersionSupported(TInt, const TVersion&);

    55 	static TBool LogicalDeviceIsAvailable(TInt, TInt, const TDesC8*, const TDesC8*);

    56 	static TInt ChannelRequest(TInt, TInt, TAny*, TAny*);

    57 	static TUint32 MathRandom();

    58 	static void IMB_Range(TAny*, TUint);

    59 	static TInt ResetMachine(TMachineStartupType);

    60 	static TLibraryFunction LibraryLookup(TInt, TInt);

    61 	static void LibraryFileName(TInt, TDes8&);

    62 	static void MutexWait(TInt);

    63 	static void MutexSignal(TInt);

    64 	static TInt ProcessId(TInt);

    65 	static void DllFileName(TInt, TDes8&);

    66 	static void ProcessResume(TInt);

    67 	static void ProcessFileName(TInt, TDes8&);

    68 	static void ProcessCommandLine(TInt, TDes8&);

    69 	static TExitType ProcessExitType(TInt);

    70 	static TInt ProcessExitReason(TInt);

    71 	static void ProcessExitCategory(TInt, TDes8&);

    72 	static TProcessPriority ProcessPriority(TInt);

    73 	static void ProcessSetPriority(TInt, TProcessPriority);

    74 	static TUint ProcessFlags(TInt);

    75 	static void ProcessSetFlags(TInt, TUint, TUint);

    76 	static TInt SemaphoreWait(TInt, TInt);

    77 	static void SemaphoreSignal1(TInt);

    78 	static void SemaphoreSignalN(TInt, TInt);

    79 	static void ServerReceive(TInt, TRequestStatus&, TAny*);

    80 	static void ServerCancel(TInt);

    81 	static void SetSessionPtr(TInt, const TAny*);

    82 	static TInt SessionSend(TInt, TInt, TAny*, TRequestStatus*);

    83 	static TInt ThreadId(TInt);

    84 	static TInt SessionShare(TInt&, TInt);

    85 	static void ThreadResume(TInt);

    86 	static void ThreadSuspend(TInt);

    87 	static TThreadPriority ThreadPriority(TInt);

    88 	static void ThreadSetPriority(TInt, TThreadPriority);

    89 	static TProcessPriority ThreadProcessPriority(TInt);

    90 	static void ThreadSetProcessPriority(TInt, TProcessPriority);

    91 	static TUint ThreadFlags(TInt);

    92 	static void ThreadSetFlags(TInt, TUint, TUint);

    93 	static TInt ThreadRequestCount(TInt);

    94 	static TExitType ThreadExitType(TInt);

    95 	static TInt ThreadExitReason(TInt);

    96 	static void ThreadExitCategory(TInt, TDes8&);

    97 	static void TimerCancel(TInt);

    98 	static void TimerAfter(TInt, TRequestStatus&, TInt);

    99 	static void TimerAt(TInt, TRequestStatus&, const EXEC_TIME&);

   100 	static void TimerLock(TInt, TRequestStatus&, TTimerLockSpec);

   101 	static TInt ChangeNotifierLogon(TInt, TRequestStatus&);

   102 	static TInt ChangeNotifierLogoff(TInt);

   103 	static void RequestSignal(TInt);

   104 	static void HandleName(TInt, TDes8&);

   105 	static void HandleFullName(TInt, TDes8&);

   106 	static void HandleInfo(TInt, THandleInfo*);

   107 	static void HandleCount(TInt, TInt&, TInt&);

   108 	static void After(TInt, TRequestStatus&);

   109 	static void At(const EXEC_TIME&, TRequestStatus&);

   110 	static void MessageComplete(TInt, TInt);

   111 	static void MessageCompleteWithHandle(TInt, TInt);

   112 	static TInt TimeNow(EXEC_TIME&, TInt&);

   113 	static TInt TimeNowSecure(EXEC_TIME&, TInt&);

   114 	static TInt SetUTCTimeAndOffset(const EXEC_TIME&, TInt, TUint, TUint);

   115 	static TInt SetMachineConfiguration(const TDesC8&);

   116 	static void CaptureEventHook();

   117 	static void ReleaseEventHook();

   118 	static void RequestEvent(TRawEventBuf&, TRequestStatus&);

   119 	static void RequestEventCancel();

   120 	static TInt AddEvent(const TRawEvent&);

   121 	static TInt SessionSendSync(TInt, TInt, TAny*, TRequestStatus*);

   122 	static TAny* DllTls(TInt, TInt);

   123 	static TInt HalFunction(TInt, TInt, TAny*, TAny*);

   124 	static void WsRegisterThread();

   125 	static void FsRegisterThread();

   126 	static TInt ProcessCommandLineLength(TInt);

   127 	static void TimerInactivity(TInt, TRequestStatus&, TInt);

   128 	static TInt UserInactivityTime();

   129 	static void ResetInactivityTime();

   130 	static void DebugPrint(TAny*, TInt);

   131 	static TInt BreakPoint();

   132 	static TInt ProfileStart(TInt);

   133 	static TInt ProfileEnd(TInt);

   134 	static TExceptionHandler ExceptionHandler(TInt);

   135 	static TInt SetExceptionHandler(TInt, TExceptionHandler, TUint32);

   136 	static void ModifyExceptionMask(TInt, TUint32, TUint32);

   137 	static TInt RaiseException(TInt, TExcType);

   138 	static TInt IsExceptionHandled(TInt, TExcType, TBool);

   139 	static TInt ProcessGetMemoryInfo(TInt, TModuleMemoryInfo&);

   140 	static TInt LibraryGetMemoryInfo(TInt, TModuleMemoryInfo&);

   141 	static TInt MachineConfiguration(TDes8&, TInt&);

   142 	static TInt SetMemoryThresholds(TInt, TInt);

   143 	static void LibraryType(TInt, TUidType&);

   144 	static void ProcessType(TInt, TUidType&);

   145 	static TInt ChunkBottom(TInt);

   146 	static TInt ChunkTop(TInt);

   147 	static void ThreadContext(TInt, TDes8&);

   148 	static TInt ThreadCreate(const TDesC8&, TOwnerType, SThreadCreateInfo8&);

   149 	static TInt FindHandleOpen(TOwnerType, const TFindHandle&);

   150 	static TInt HandleClose(TInt);

   151 	static TInt ChunkCreate(TOwnerType, const TDesC8*, TChunkCreate&);

   152 	static TInt ChunkAdjust(TInt, TInt, TInt, TInt);

   153 	static TInt OpenObject(TObjectType, const TDesC8&, TOwnerType);

   154 	static TInt HandleDuplicate(TInt, TOwnerType, TInt);

   155 	static TInt MutexCreate(const TDesC8*, TOwnerType);

   156 	static TInt SemaphoreCreate(const TDesC8*, TInt, TOwnerType);

   157 	static TInt ThreadOpenById(TUint, TOwnerType);

   158 	static TInt ProcessOpenById(TUint, TOwnerType);

   159 	static void ThreadKill(TInt, TExitType, TInt, const TDesC8*);

   160 	static void ThreadLogon(TInt, TRequestStatus*, TBool);

   161 	static TInt ThreadLogonCancel(TInt, TRequestStatus*, TBool);

   162 	static TInt DllSetTls(TInt, TInt, TAny*);

   163 	static void DllFreeTls(TInt);

   164 	static TInt ThreadRename(TInt, const TDesC8&);

   165 	static TInt ProcessRename(TInt, const TDesC8&);

   166 	static void ProcessKill(TInt, TExitType, TInt, const TDesC8*);

   167 	static void ProcessLogon(TInt, TRequestStatus*, TBool);

   168 	static TInt ProcessLogonCancel(TInt, TRequestStatus*, TBool);

   169 	static TInt ThreadProcess(TInt);

   170 	static TInt ServerCreate(const TDesC8*, TInt);

   171 	static TInt SessionCreate(const TDesC8&, TInt, const TSecurityPolicy*, TInt);

   172 	static TInt SessionCreateFromHandle(TInt, TInt, const TSecurityPolicy*, TInt);

   173 	static TInt DeviceFree(const TDesC8&, TInt);

   174 	static TInt ChannelCreate(const TDesC8&, TChannelCreateInfo8&, TInt);

   175 	static TInt TimerCreate();

   176 	static void TimerHighRes(TInt, TRequestStatus&, TInt);

   177 	static void AfterHighRes(TInt, TRequestStatus&);

   178 	static TInt ChangeNotifierCreate(TOwnerType);

   179 	static TInt UndertakerCreate(TOwnerType);

   180 	static TInt UndertakerLogon(TInt, TRequestStatus&, TInt&);

   181 	static TInt UndertakerLogonCancel(TInt);

   182 	static void KernelHeapDebug(TInt, TInt, TAny*);

   183 	static TInt ThreadGetCpuTime(TInt, EXEC_INT64&);

   184 	static TInt LastThreadHandle();

   185 	static void ThreadRendezvous(TInt);

   186 	static void ProcessRendezvous(TInt);

   187 	static TInt MessageGetDesLength(TInt, TInt);

   188 	static TInt MessageGetDesMaxLength(TInt, TInt);

   189 	static TInt MessageIpcCopy(TInt, TInt, SIpcCopyInfo&, TInt);

   190 	static TInt MessageClient(TInt, TOwnerType);

   191 	static TInt MessageSetProcessPriority(TInt, TProcessPriority);

   192 	static void MessageConstructFromPtr(TInt, TAny*);

   193 	static void MessageKill(TInt, TExitType, TInt, const TDesC8*);

   194 	static TInt MessageOpenObject(TInt, TObjectType, TInt, TOwnerType);

   195 	static void ProcessSecurityInfo(TInt, SSecurityInfo&);

   196 	static void ThreadSecurityInfo(TInt, SSecurityInfo&);

   197 	static void MessageSecurityInfo(TInt, SSecurityInfo&);

   198 	static void CreatorSecurityInfo(SSecurityInfo&);

   199 	static void DisabledCapabilities(SCapabilitySet&);

   200 	static TInt ChunkSetRestrictions(TInt, TUint);

   201 	static TInt MsgQueueCreate(const TDesC8*, TInt, TInt, TOwnerType);

   202 	static TInt MsgQueueSend(TInt, const TAny*, TInt);

   203 	static TInt MsgQueueReceive(TInt, TAny*, TInt);

   204 	static void MsgQueueNotifySpaceAvailable(TInt, TRequestStatus&);

   205 	static void MsgQueueCancelSpaceAvailable(TInt);

   206 	static void MsgQueueNotifyDataAvailable(TInt, TRequestStatus&);

   207 	static void MsgQueueCancelDataAvailable(TInt);

   208 	static TInt MsgQueueSize(TInt);

   209 	static TInt PropertyDefine(TUint, TUint, TPropertyInfo*);

   210 	static TInt PropertyDelete(TUint, TUint);

   211 	static TInt PropertyAttach(TUint, TUint, TOwnerType);

   212 	static void PropertySubscribe(TInt, TRequestStatus*);

   213 	static void PropertyCancel(TInt);

   214 	static TInt PropertyGetI(TInt, TInt*);

   215 	static TInt PropertyGetB(TInt, TUint8*, TInt);

   216 	static TInt PropertySetI(TInt, TInt);

   217 	static TInt PropertySetB(TInt, const TUint8*, TInt);

   218 	static TInt PropertyFindGetI(TUint, TUint, TInt*);

   219 	static TInt PropertyFindGetB(TUint, TUint, TUint8*, TInt);

   220 	static TInt PropertyFindSetI(TUint, TUint, TInt);

   221 	static TInt PropertyFindSetB(TUint, TUint, TUint8*, TInt);

   222 	static TInt PowerEnableWakeupEvents(TPowerState);

   223 	static void PowerDisableWakeupEvents();

   224 	static void PowerRequestWakeupEventNotification(TRequestStatus*);

   225 	static void PowerCancelWakeupEventNotification();

   226 	static TInt PowerDown();

   227 	static TInt ProcessSetHandleParameter(TInt, TInt, TInt);

   228 	static TInt ProcessSetDataParameter(TInt, TInt, const TUint8*, TInt);

   229 	static TInt ProcessGetHandleParameter(TInt, TObjectType, TOwnerType);

   230 	static TInt ProcessGetDataParameter(TInt, TUint8*, TInt);

   231 	static TInt ProcessDataParameterLength(TInt);

   232 	static TUint MessageClientProcessFlags(TInt);

   233 	static TInt ThreadStackInfo(TInt, TThreadStackInfo&);

   234 	static RAllocator* ThreadGetHeap(TInt);

   235 	static TInt ThreadAsProcess(TInt, TInt);

   236 	static TInt CondVarCreate(const TDesC8*, TOwnerType);

   237 	static TInt CondVarWait(TInt, TInt, TInt);

   238 	static void CondVarSignal(TInt);

   239 	static void CondVarBroadcast(TInt);

   240 	static TInt PlatSecDiagnostic(TPlatSecDiagnostic*);

   241 	static TLinAddr ExceptionDescriptor(TLinAddr);

   242 	static void ThreadRequestSignal(TInt);

   243 	static TBool MutexIsHeld(TInt);

   244 	static TTrapHandler* LeaveStart();

   245 	static void LeaveEnd();

   246 	static void SetDebugMaskIndex(TUint32, TUint);

   247 	static TInt GetModuleNameFromAddress(TAny*, TDes8&);

   248 	static void NotifyChanges(TUint);

   249 	static TInt SetGlobalUserData(TInt, TInt);

   250 	static TInt SessionSecurityInfo(TInt, SSecurityInfo&);

   251 	static const TRequestStatus* MessageClientStatus(TInt);

   252 	static TInt SetFloatingPointMode(TFloatingPointMode, TFloatingPointRoundingMode);

   253 	static TBool BTraceOut(TUint32, TUint32, const BTrace::SExecExtension&, TInt);

   254 	static TBool BTraceOutBig(TUint32, TUint32, const BTrace::SExecExtension&, TInt);

   255 	static TAny* ProcessExeExportData();

   256 	IMPORT_C static TInt SetWin32RuntimeHook(TAny*);

   257 	static TInt GetBTraceId(TInt);

   258 	static void NotifyOnIdle(TRequestStatus*);

   259 	static void CancelMiscNotifier(TRequestStatus*);

   260 	static void NotifyObjectDestruction(TInt, TRequestStatus*);

   261 	static void RegisterTrustedChunk(TInt);

   262 	static TBool UserThreadExiting(TInt);

   263 	};

   264 

   265 #ifdef __GEN_USER_EXEC_CODE__

   266 __EXECDECL__ void Exec::WaitForAnyRequest()

   267 	{

   268 	FAST_EXEC0(EFastExecWaitForAnyRequest);

   269 	}

   270 

   271 __EXECDECL__ RAllocator* Exec::Heap()

   272 	{

   273 	FAST_EXEC0(EFastExecHeap);

   274 	}

   275 

   276 __EXECDECL__ RAllocator* Exec::HeapSwitch(RAllocator*)

   277 	{

   278 	FAST_EXEC1(EFastExecHeapSwitch);

   279 	}

   280 

   281 __EXECDECL__ TTrapHandler* Exec::PushTrapFrame(TTrap*)

   282 	{

   283 	FAST_EXEC1(EFastExecPushTrapFrame);

   284 	}

   285 

   286 __EXECDECL__ TTrap* Exec::PopTrapFrame()

   287 	{

   288 	FAST_EXEC0(EFastExecPopTrapFrame);

   289 	}

   290 

   291 __EXECDECL__ CActiveScheduler* Exec::ActiveScheduler()

   292 	{

   293 	FAST_EXEC0(EFastExecActiveScheduler);

   294 	}

   295 

   296 __EXECDECL__ void Exec::SetActiveScheduler(CActiveScheduler*)

   297 	{

   298 	FAST_EXEC1(EFastExecSetActiveScheduler);

   299 	}

   300 

   301 __EXECDECL__ TTimerLockSpec Exec::LockPeriod()

   302 	{

   303 	FAST_EXEC0(EFastExecLockPeriod);

   304 	}

   305 

   306 __EXECDECL__ TTrapHandler* Exec::TrapHandler()

   307 	{

   308 	FAST_EXEC0(EFastExecTrapHandler);

   309 	}

   310 

   311 __EXECDECL__ TTrapHandler* Exec::SetTrapHandler(TTrapHandler*)

   312 	{

   313 	FAST_EXEC1(EFastExecSetTrapHandler);

   314 	}

   315 

   316 __EXECDECL__ TInt Exec::LockedInc(TInt&)

   317 	{

   318 	FAST_EXEC1(EFastExecLockedInc);

   319 	}

   320 

   321 __EXECDECL__ TInt Exec::LockedDec(TInt&)

   322 	{

   323 	FAST_EXEC1(EFastExecLockedDec);

   324 	}

   325 

   326 __EXECDECL__ TUint32 Exec::DebugMask()

   327 	{

   328 	FAST_EXEC0(EFastExecDebugMask);

   329 	}

   330 

   331 __EXECDECL__ TUint32 Exec::DebugMaskIndex(TUint)

   332 	{

   333 	FAST_EXEC1(EFastExecDebugMaskIndex);

   334 	}

   335 

   336 __EXECDECL__ void Exec::SetDebugMask(TUint32)

   337 	{

   338 	FAST_EXEC1(EFastExecSetDebugMask);

   339 	}

   340 

   341 __EXECDECL__ TUint32 Exec::FastCounter()

   342 	{

   343 	FAST_EXEC0(EFastExecFastCounter);

   344 	}

   345 

   346 __EXECDECL__ TUint32 Exec::NTickCount()

   347 	{

   348 	FAST_EXEC0(EFastExecNTickCount);

   349 	}

   350 

   351 EXPORT_C __EXECDECL__ void UserSvr::LockRamDrive()

   352 	{

   353 	FAST_EXEC0(EFastExecLockRamDrive);

   354 	}

   355 

   356 EXPORT_C __EXECDECL__ void UserSvr::UnlockRamDrive()

   357 	{

   358 	FAST_EXEC0(EFastExecUnlockRamDrive);

   359 	}

   360 

   361 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomHeaderAddress()

   362 	{

   363 	FAST_EXEC0(EFastExecRomHeaderAddress);

   364 	}

   365 

   366 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomRootDirectoryAddress()

   367 	{

   368 	FAST_EXEC0(EFastExecRomRootDirectoryAddress);

   369 	}

   370 

   371 __EXECDECL__ TInt Exec::SafeInc(TInt&)

   372 	{

   373 	FAST_EXEC1(EFastExecSafeInc);

   374 	}

   375 

   376 __EXECDECL__ TInt Exec::SafeDec(TInt&)

   377 	{

   378 	FAST_EXEC1(EFastExecSafeDec);

   379 	}

   380 

   381 __EXECDECL__ void Exec::SetReentryPoint(TLinAddr)

   382 	{

   383 	FAST_EXEC1(EFastExecSetReentryPoint);

   384 	}

   385 

   386 __EXECDECL__ TUint32 Exec::KernelConfigFlags()

   387 	{

   388 	FAST_EXEC0(EFastExecKernelConfigFlags);

   389 	}

   390 

   391 __EXECDECL__ TInt Exec::UTCOffset()

   392 	{

   393 	FAST_EXEC0(EFastExecUTCOffset);

   394 	}

   395 

   396 __EXECDECL__ TInt Exec::GetGlobalUserData(TInt)

   397 	{

   398 	FAST_EXEC1(EFastExecGetGlobalUserData);

   399 	}

   400 

   401 EXPORT_C __EXECDECL__ TBool BTrace::CheckFilter(TUint32)

   402 	{

   403 	FAST_EXEC1(EFastExecCheckFilter);

   404 	}

   405 

   406 __EXECDECL__ TInt Exec::ObjectNext(TObjectType, TBuf8<KMaxFullName>&, TFindHandle&)

   407 	{

   408 	SLOW_EXEC3(EExecObjectNext);

   409 	}

   410 

   411 __EXECDECL__ TUint8* Exec::ChunkBase(TInt)

   412 	{

   413 	SLOW_EXEC1(EExecChunkBase);

   414 	}

   415 

   416 __EXECDECL__ TInt Exec::ChunkSize(TInt)

   417 	{

   418 	SLOW_EXEC1(EExecChunkSize);

   419 	}

   420 

   421 __EXECDECL__ TInt Exec::ChunkMaxSize(TInt)

   422 	{

   423 	SLOW_EXEC1(EExecChunkMaxSize);

   424 	}

   425 

   426 __EXECDECL__ TUint Exec::HandleAttributes(TInt)

   427 	{

   428 	SLOW_EXEC1(EExecHandleAttributes);

   429 	}

   430 

   431 __EXECDECL__ TUint Exec::TickCount()

   432 	{

   433 	SLOW_EXEC0(EExecTickCount);

   434 	}

   435 

   436 __EXECDECL__ void Exec::LogicalDeviceGetCaps(TInt, TDes8&)

   437 	{

   438 	SLOW_EXEC2(EExecLogicalDeviceGetCaps);

   439 	}

   440 

   441 __EXECDECL__ TBool Exec::LogicalDeviceQueryVersionSupported(TInt, const TVersion&)

   442 	{

   443 	SLOW_EXEC2(EExecLogicalDeviceQueryVersionSupported);

   444 	}

   445 

   446 __EXECDECL__ TBool Exec::LogicalDeviceIsAvailable(TInt, TInt, const TDesC8*, const TDesC8*)

   447 	{

   448 	SLOW_EXEC4(EExecLogicalDeviceIsAvailable);

   449 	}

   450 

   451 EXPORT_C __EXECDECL__ TInt E32Loader::LocaleExports(TAny*, TLibraryFunction*)

   452 	{

   453 	SLOW_EXEC2(EExecLocaleExports);

   454 	}

   455 

   456 __EXECDECL__ TInt Exec::ChannelRequest(TInt, TInt, TAny*, TAny*)

   457 	{

   458 	SLOW_EXEC4(EExecChannelRequest);

   459 	}

   460 

   461 __EXECDECL__ TUint32 Exec::MathRandom()

   462 	{

   463 	SLOW_EXEC0(EExecMathRandom);

   464 	}

   465 

   466 __EXECDECL__ void Exec::IMB_Range(TAny*, TUint)

   467 	{

   468 	SLOW_EXEC2(EExecIMBRange);

   469 	}

   470 

   471 __EXECDECL__ TInt Exec::ResetMachine(TMachineStartupType)

   472 	{

   473 	SLOW_EXEC1(EExecResetMachine);

   474 	}

   475 

   476 __EXECDECL__ TLibraryFunction Exec::LibraryLookup(TInt, TInt)

   477 	{

   478 	SLOW_EXEC2(EExecLibraryLookup);

   479 	}

   480 

   481 __EXECDECL__ void Exec::LibraryFileName(TInt, TDes8&)

   482 	{

   483 	SLOW_EXEC2(EExecLibraryFileName);

   484 	}

   485 

   486 EXPORT_C __EXECDECL__ TInt UserSvr::ExecuteInSupervisorMode(TSupervisorFunction, TAny*)

   487 	{

   488 	SLOW_EXEC2(EExecExecuteInSupervisorMode);

   489 	}

   490 

   491 __EXECDECL__ void Exec::MutexWait(TInt)

   492 	{

   493 	SLOW_EXEC1(EExecMutexWait);

   494 	}

   495 

   496 __EXECDECL__ void Exec::MutexSignal(TInt)

   497 	{

   498 	SLOW_EXEC1(EExecMutexSignal);

   499 	}

   500 

   501 __EXECDECL__ TInt Exec::ProcessId(TInt)

   502 	{

   503 	SLOW_EXEC1(EExecProcessId);

   504 	}

   505 

   506 __EXECDECL__ void Exec::DllFileName(TInt, TDes8&)

   507 	{

   508 	SLOW_EXEC2(EExecDllFileName);

   509 	}

   510 

   511 __EXECDECL__ void Exec::ProcessResume(TInt)

   512 	{

   513 	SLOW_EXEC1(EExecProcessResume);

   514 	}

   515 

   516 __EXECDECL__ void Exec::ProcessFileName(TInt, TDes8&)

   517 	{

   518 	SLOW_EXEC2(EExecProcessFileName);

   519 	}

   520 

   521 __EXECDECL__ void Exec::ProcessCommandLine(TInt, TDes8&)

   522 	{

   523 	SLOW_EXEC2(EExecProcessCommandLine);

   524 	}

   525 

   526 __EXECDECL__ TExitType Exec::ProcessExitType(TInt)

   527 	{

   528 	SLOW_EXEC1(EExecProcessExitType);

   529 	}

   530 

   531 __EXECDECL__ TInt Exec::ProcessExitReason(TInt)

   532 	{

   533 	SLOW_EXEC1(EExecProcessExitReason);

   534 	}

   535 

   536 __EXECDECL__ void Exec::ProcessExitCategory(TInt, TDes8&)

   537 	{

   538 	SLOW_EXEC2(EExecProcessExitCategory);

   539 	}

   540 

   541 __EXECDECL__ TProcessPriority Exec::ProcessPriority(TInt)

   542 	{

   543 	SLOW_EXEC1(EExecProcessPriority);

   544 	}

   545 

   546 __EXECDECL__ void Exec::ProcessSetPriority(TInt, TProcessPriority)

   547 	{

   548 	SLOW_EXEC2(EExecProcessSetPriority);

   549 	}

   550 

   551 __EXECDECL__ TUint Exec::ProcessFlags(TInt)

   552 	{

   553 	SLOW_EXEC1(EExecProcessFlags);

   554 	}

   555 

   556 __EXECDECL__ void Exec::ProcessSetFlags(TInt, TUint, TUint)

   557 	{

   558 	SLOW_EXEC3(EExecProcessSetFlags);

   559 	}

   560 

   561 __EXECDECL__ TInt Exec::SemaphoreWait(TInt, TInt)

   562 	{

   563 	SLOW_EXEC2(EExecSemaphoreWait);

   564 	}

   565 

   566 __EXECDECL__ void Exec::SemaphoreSignal1(TInt)

   567 	{

   568 	SLOW_EXEC1(EExecSemaphoreSignal1);

   569 	}

   570 

   571 __EXECDECL__ void Exec::SemaphoreSignalN(TInt, TInt)

   572 	{

   573 	SLOW_EXEC2(EExecSemaphoreSignalN);

   574 	}

   575 

   576 __EXECDECL__ void Exec::ServerReceive(TInt, TRequestStatus&, TAny*)

   577 	{

   578 	SLOW_EXEC3(EExecServerReceive);

   579 	}

   580 

   581 __EXECDECL__ void Exec::ServerCancel(TInt)

   582 	{

   583 	SLOW_EXEC1(EExecServerCancel);

   584 	}

   585 

   586 __EXECDECL__ void Exec::SetSessionPtr(TInt, const TAny*)

   587 	{

   588 	SLOW_EXEC2(EExecSetSessionPtr);

   589 	}

   590 

   591 __EXECDECL__ TInt Exec::ThreadId(TInt)

   592 	{

   593 	SLOW_EXEC1(EExecThreadId);

   594 	}

   595 

   596 __EXECDECL__ TInt Exec::SessionShare(TInt&, TInt)

   597 	{

   598 	SLOW_EXEC2(EExecSessionShare);

   599 	}

   600 

   601 __EXECDECL__ void Exec::ThreadResume(TInt)

   602 	{

   603 	SLOW_EXEC1(EExecThreadResume);

   604 	}

   605 

   606 __EXECDECL__ void Exec::ThreadSuspend(TInt)

   607 	{

   608 	SLOW_EXEC1(EExecThreadSuspend);

   609 	}

   610 

   611 __EXECDECL__ TThreadPriority Exec::ThreadPriority(TInt)

   612 	{

   613 	SLOW_EXEC1(EExecThreadPriority);

   614 	}

   615 

   616 __EXECDECL__ void Exec::ThreadSetPriority(TInt, TThreadPriority)

   617 	{

   618 	SLOW_EXEC2(EExecThreadSetPriority);

   619 	}

   620 

   621 __EXECDECL__ TProcessPriority Exec::ThreadProcessPriority(TInt)

   622 	{

   623 	SLOW_EXEC1(EExecThreadProcessPriority);

   624 	}

   625 

   626 __EXECDECL__ void Exec::ThreadSetProcessPriority(TInt, TProcessPriority)

   627 	{

   628 	SLOW_EXEC2(EExecThreadSetProcessPriority);

   629 	}

   630 

   631 __EXECDECL__ TUint Exec::ThreadFlags(TInt)

   632 	{

   633 	SLOW_EXEC1(EExecThreadFlags);

   634 	}

   635 

   636 __EXECDECL__ void Exec::ThreadSetFlags(TInt, TUint, TUint)

   637 	{

   638 	SLOW_EXEC3(EExecThreadSetFlags);

   639 	}

   640 

   641 __EXECDECL__ TInt Exec::ThreadRequestCount(TInt)

   642 	{

   643 	SLOW_EXEC1(EExecThreadRequestCount);

   644 	}

   645 

   646 __EXECDECL__ TExitType Exec::ThreadExitType(TInt)

   647 	{

   648 	SLOW_EXEC1(EExecThreadExitType);

   649 	}

   650 

   651 __EXECDECL__ TInt Exec::ThreadExitReason(TInt)

   652 	{

   653 	SLOW_EXEC1(EExecThreadExitReason);

   654 	}

   655 

   656 __EXECDECL__ void Exec::ThreadExitCategory(TInt, TDes8&)

   657 	{

   658 	SLOW_EXEC2(EExecThreadExitCategory);

   659 	}

   660 

   661 __EXECDECL__ void Exec::TimerCancel(TInt)

   662 	{

   663 	SLOW_EXEC1(EExecTimerCancel);

   664 	}

   665 

   666 __EXECDECL__ void Exec::TimerAfter(TInt, TRequestStatus&, TInt)

   667 	{

   668 	SLOW_EXEC3(EExecTimerAfter);

   669 	}

   670 

   671 __EXECDECL__ void Exec::TimerAt(TInt, TRequestStatus&, const EXEC_TIME&)

   672 	{

   673 	SLOW_EXEC3(EExecTimerAt);

   674 	}

   675 

   676 __EXECDECL__ void Exec::TimerLock(TInt, TRequestStatus&, TTimerLockSpec)

   677 	{

   678 	SLOW_EXEC3(EExecTimerLock);

   679 	}

   680 

   681 __EXECDECL__ TInt Exec::ChangeNotifierLogon(TInt, TRequestStatus&)

   682 	{

   683 	SLOW_EXEC2(EExecChangeNotifierLogon);

   684 	}

   685 

   686 __EXECDECL__ TInt Exec::ChangeNotifierLogoff(TInt)

   687 	{

   688 	SLOW_EXEC1(EExecChangeNotifierLogoff);

   689 	}

   690 

   691 __EXECDECL__ void Exec::RequestSignal(TInt)

   692 	{

   693 	SLOW_EXEC1(EExecRequestSignal);

   694 	}

   695 

   696 __EXECDECL__ void Exec::HandleName(TInt, TDes8&)

   697 	{

   698 	SLOW_EXEC2(EExecHandleName);

   699 	}

   700 

   701 __EXECDECL__ void Exec::HandleFullName(TInt, TDes8&)

   702 	{

   703 	SLOW_EXEC2(EExecHandleFullName);

   704 	}

   705 

   706 __EXECDECL__ void Exec::HandleInfo(TInt, THandleInfo*)

   707 	{

   708 	SLOW_EXEC2(EExecHandleInfo);

   709 	}

   710 

   711 __EXECDECL__ void Exec::HandleCount(TInt, TInt&, TInt&)

   712 	{

   713 	SLOW_EXEC3(EExecHandleCount);

   714 	}

   715 

   716 __EXECDECL__ void Exec::After(TInt, TRequestStatus&)

   717 	{

   718 	SLOW_EXEC2(EExecAfter);

   719 	}

   720 

   721 __EXECDECL__ void Exec::At(const EXEC_TIME&, TRequestStatus&)

   722 	{

   723 	SLOW_EXEC2(EExecAt);

   724 	}

   725 

   726 __EXECDECL__ void Exec::MessageComplete(TInt, TInt)

   727 	{

   728 	SLOW_EXEC2(EExecMessageComplete);

   729 	}

   730 

   731 __EXECDECL__ void Exec::MessageCompleteWithHandle(TInt, TInt)

   732 	{

   733 	SLOW_EXEC2(EExecMessageCompleteWithHandle);

   734 	}

   735 

   736 __EXECDECL__ TInt Exec::TimeNow(EXEC_TIME&, TInt&)

   737 	{

   738 	SLOW_EXEC2(EExecTimeNow);

   739 	}

   740 

   741 __EXECDECL__ TInt Exec::TimeNowSecure(EXEC_TIME&, TInt&)

   742 	{

   743 	SLOW_EXEC2(EExecTimeNowSecure);

   744 	}

   745 

   746 __EXECDECL__ TInt Exec::SetUTCTimeAndOffset(const EXEC_TIME&, TInt, TUint, TUint)

   747 	{

   748 	SLOW_EXEC4(EExecSetUTCTimeAndOffset);

   749 	}

   750 

   751 __EXECDECL__ TInt Exec::SetMachineConfiguration(const TDesC8&)

   752 	{

   753 	SLOW_EXEC1(EExecSetMachineConfiguration);

   754 	}

   755 

   756 __EXECDECL__ void Exec::CaptureEventHook()

   757 	{

   758 	SLOW_EXEC0(EExecCaptureEventHook);

   759 	}

   760 

   761 __EXECDECL__ void Exec::ReleaseEventHook()

   762 	{

   763 	SLOW_EXEC0(EExecReleaseEventHook);

   764 	}

   765 

   766 __EXECDECL__ void Exec::RequestEvent(TRawEventBuf&, TRequestStatus&)

   767 	{

   768 	SLOW_EXEC2(EExecRequestEvent);

   769 	}

   770 

   771 __EXECDECL__ void Exec::RequestEventCancel()

   772 	{

   773 	SLOW_EXEC0(EExecRequestEventCancel);

   774 	}

   775 

   776 __EXECDECL__ TInt Exec::AddEvent(const TRawEvent&)

   777 	{

   778 	SLOW_EXEC1(EExecAddEvent);

   779 	}

   780 

   781 __EXECDECL__ TAny* Exec::DllTls(TInt, TInt)

   782 	{

   783 	SLOW_EXEC2(EExecDllTls);

   784 	}

   785 

   786 __EXECDECL__ TInt Exec::HalFunction(TInt, TInt, TAny*, TAny*)

   787 	{

   788 	SLOW_EXEC4(EExecHalFunction);

   789 	}

   790 

   791 __EXECDECL__ void Exec::WsRegisterThread()

   792 	{

   793 	SLOW_EXEC0(EExecWsRegisterThread);

   794 	}

   795 

   796 __EXECDECL__ void Exec::FsRegisterThread()

   797 	{

   798 	SLOW_EXEC0(EExecFsRegisterThread);

   799 	}

   800 

   801 __EXECDECL__ TInt Exec::ProcessCommandLineLength(TInt)

   802 	{

   803 	SLOW_EXEC1(EExecProcessCommandLineLength);

   804 	}

   805 

   806 __EXECDECL__ void Exec::TimerInactivity(TInt, TRequestStatus&, TInt)

   807 	{

   808 	SLOW_EXEC3(EExecTimerInactivity);

   809 	}

   810 

   811 __EXECDECL__ TInt Exec::UserInactivityTime()

   812 	{

   813 	SLOW_EXEC0(EExecUserInactivityTime);

   814 	}

   815 

   816 __EXECDECL__ void Exec::ResetInactivityTime()

   817 	{

   818 	SLOW_EXEC0(EExecResetInactivityTime);

   819 	}

   820 

   821 __EXECDECL__ void Exec::DebugPrint(TAny*, TInt)

   822 	{

   823 	SLOW_EXEC2(EExecDebugPrint);

   824 	}

   825 

   826 __EXECDECL__ TInt Exec::BreakPoint()

   827 	{

   828 	SLOW_EXEC0(EExecBreakPoint);

   829 	}

   830 

   831 __EXECDECL__ TInt Exec::ProfileStart(TInt)

   832 	{

   833 	SLOW_EXEC1(EExecProfileStart);

   834 	}

   835 

   836 __EXECDECL__ TInt Exec::ProfileEnd(TInt)

   837 	{

   838 	SLOW_EXEC1(EExecProfileEnd);

   839 	}

   840 

   841 __EXECDECL__ TExceptionHandler Exec::ExceptionHandler(TInt)

   842 	{

   843 	SLOW_EXEC1(EExecExceptionHandler);

   844 	}

   845 

   846 __EXECDECL__ TInt Exec::SetExceptionHandler(TInt, TExceptionHandler, TUint32)

   847 	{

   848 	SLOW_EXEC3(EExecSetExceptionHandler);

   849 	}

   850 

   851 __EXECDECL__ void Exec::ModifyExceptionMask(TInt, TUint32, TUint32)

   852 	{

   853 	SLOW_EXEC3(EExecModifyExceptionMask);

   854 	}

   855 

   856 __EXECDECL__ TInt Exec::RaiseException(TInt, TExcType)

   857 	{

   858 	SLOW_EXEC2(EExecRaiseException);

   859 	}

   860 

   861 __EXECDECL__ TInt Exec::IsExceptionHandled(TInt, TExcType, TBool)

   862 	{

   863 	SLOW_EXEC3(EExecIsExceptionHandled);

   864 	}

   865 

   866 __EXECDECL__ TInt Exec::ProcessGetMemoryInfo(TInt, TModuleMemoryInfo&)

   867 	{

   868 	SLOW_EXEC2(EExecProcessGetMemoryInfo);

   869 	}

   870 

   871 __EXECDECL__ TInt Exec::LibraryGetMemoryInfo(TInt, TModuleMemoryInfo&)

   872 	{

   873 	SLOW_EXEC2(EExecLibraryGetMemoryInfo);

   874 	}

   875 

   876 __EXECDECL__ TInt Exec::MachineConfiguration(TDes8&, TInt&)

   877 	{

   878 	SLOW_EXEC2(EExecMachineConfiguration);

   879 	}

   880 

   881 __EXECDECL__ TInt Exec::SetMemoryThresholds(TInt, TInt)

   882 	{

   883 	SLOW_EXEC2(EExecSetMemoryThresholds);

   884 	}

   885 

   886 __EXECDECL__ void Exec::LibraryType(TInt, TUidType&)

   887 	{

   888 	SLOW_EXEC2(EExecLibraryType);

   889 	}

   890 

   891 __EXECDECL__ void Exec::ProcessType(TInt, TUidType&)

   892 	{

   893 	SLOW_EXEC2(EExecProcessType);

   894 	}

   895 

   896 __EXECDECL__ TInt Exec::ChunkBottom(TInt)

   897 	{

   898 	SLOW_EXEC1(EExecChunkBottom);

   899 	}

   900 

   901 __EXECDECL__ TInt Exec::ChunkTop(TInt)

   902 	{

   903 	SLOW_EXEC1(EExecChunkTop);

   904 	}

   905 

   906 __EXECDECL__ void Exec::ThreadContext(TInt, TDes8&)

   907 	{

   908 	SLOW_EXEC2(EExecThreadContext);

   909 	}

   910 

   911 __EXECDECL__ TInt Exec::ThreadCreate(const TDesC8&, TOwnerType, SThreadCreateInfo8&)

   912 	{

   913 	SLOW_EXEC3(EExecThreadCreate);

   914 	}

   915 

   916 __EXECDECL__ TInt Exec::FindHandleOpen(TOwnerType, const TFindHandle&)

   917 	{

   918 	SLOW_EXEC2(EExecFindHandleOpen);

   919 	}

   920 

   921 __EXECDECL__ TInt Exec::HandleClose(TInt)

   922 	{

   923 	SLOW_EXEC1(EExecHandleClose);

   924 	}

   925 

   926 __EXECDECL__ TInt Exec::ChunkCreate(TOwnerType, const TDesC8*, TChunkCreate&)

   927 	{

   928 	SLOW_EXEC3(EExecChunkCreate);

   929 	}

   930 

   931 __EXECDECL__ TInt Exec::ChunkAdjust(TInt, TInt, TInt, TInt)

   932 	{

   933 	SLOW_EXEC4(EExecChunkAdjust);

   934 	}

   935 

   936 __EXECDECL__ TInt Exec::OpenObject(TObjectType, const TDesC8&, TOwnerType)

   937 	{

   938 	SLOW_EXEC3(EExecOpenObject);

   939 	}

   940 

   941 __EXECDECL__ TInt Exec::HandleDuplicate(TInt, TOwnerType, TInt)

   942 	{

   943 	SLOW_EXEC3(EExecHandleDuplicate);

   944 	}

   945 

   946 __EXECDECL__ TInt Exec::MutexCreate(const TDesC8*, TOwnerType)

   947 	{

   948 	SLOW_EXEC2(EExecMutexCreate);

   949 	}

   950 

   951 __EXECDECL__ TInt Exec::SemaphoreCreate(const TDesC8*, TInt, TOwnerType)

   952 	{

   953 	SLOW_EXEC3(EExecSemaphoreCreate);

   954 	}

   955 

   956 __EXECDECL__ TInt Exec::ThreadOpenById(TUint, TOwnerType)

   957 	{

   958 	SLOW_EXEC2(EExecThreadOpenById);

   959 	}

   960 

   961 __EXECDECL__ TInt Exec::ProcessOpenById(TUint, TOwnerType)

   962 	{

   963 	SLOW_EXEC2(EExecProcessOpenById);

   964 	}

   965 

   966 __EXECDECL__ void Exec::ThreadKill(TInt, TExitType, TInt, const TDesC8*)

   967 	{

   968 	SLOW_EXEC4(EExecThreadKill);

   969 	}

   970 

   971 __EXECDECL__ void Exec::ThreadLogon(TInt, TRequestStatus*, TBool)

   972 	{

   973 	SLOW_EXEC3(EExecThreadLogon);

   974 	}

   975 

   976 __EXECDECL__ TInt Exec::ThreadLogonCancel(TInt, TRequestStatus*, TBool)

   977 	{

   978 	SLOW_EXEC3(EExecThreadLogonCancel);

   979 	}

   980 

   981 __EXECDECL__ TInt Exec::DllSetTls(TInt, TInt, TAny*)

   982 	{

   983 	SLOW_EXEC3(EExecDllSetTls);

   984 	}

   985 

   986 __EXECDECL__ void Exec::DllFreeTls(TInt)

   987 	{

   988 	SLOW_EXEC1(EExecDllFreeTls);

   989 	}

   990 

   991 __EXECDECL__ TInt Exec::ThreadRename(TInt, const TDesC8&)

   992 	{

   993 	SLOW_EXEC2(EExecThreadRename);

   994 	}

   995 

   996 __EXECDECL__ TInt Exec::ProcessRename(TInt, const TDesC8&)

   997 	{

   998 	SLOW_EXEC2(EExecProcessRename);

   999 	}

  1000 

  1001 __EXECDECL__ void Exec::ProcessKill(TInt, TExitType, TInt, const TDesC8*)

  1002 	{

  1003 	SLOW_EXEC4(EExecProcessKill);

  1004 	}

  1005 

  1006 __EXECDECL__ void Exec::ProcessLogon(TInt, TRequestStatus*, TBool)

  1007 	{

  1008 	SLOW_EXEC3(EExecProcessLogon);

  1009 	}

  1010 

  1011 __EXECDECL__ TInt Exec::ProcessLogonCancel(TInt, TRequestStatus*, TBool)

  1012 	{

  1013 	SLOW_EXEC3(EExecProcessLogonCancel);

  1014 	}

  1015 

  1016 __EXECDECL__ TInt Exec::ThreadProcess(TInt)

  1017 	{

  1018 	SLOW_EXEC1(EExecThreadProcess);

  1019 	}

  1020 

  1021 __EXECDECL__ TInt Exec::ServerCreate(const TDesC8*, TInt)

  1022 	{

  1023 	SLOW_EXEC2(EExecServerCreate);

  1024 	}

  1025 

  1026 __EXECDECL__ TInt Exec::SessionCreate(const TDesC8&, TInt, const TSecurityPolicy*, TInt)

  1027 	{

  1028 	SLOW_EXEC4(EExecSessionCreate);

  1029 	}

  1030 

  1031 __EXECDECL__ TInt Exec::SessionCreateFromHandle(TInt, TInt, const TSecurityPolicy*, TInt)

  1032 	{

  1033 	SLOW_EXEC4(EExecSessionCreateFromHandle);

  1034 	}

  1035 

  1036 EXPORT_C __EXECDECL__ TInt E32Loader::DeviceLoad(TAny*, TInt)

  1037 	{

  1038 	SLOW_EXEC2(EExecDeviceLoad);

  1039 	}

  1040 

  1041 __EXECDECL__ TInt Exec::DeviceFree(const TDesC8&, TInt)

  1042 	{

  1043 	SLOW_EXEC2(EExecDeviceFree);

  1044 	}

  1045 

  1046 __EXECDECL__ TInt Exec::ChannelCreate(const TDesC8&, TChannelCreateInfo8&, TInt)

  1047 	{

  1048 	SLOW_EXEC3(EExecChannelCreate);

  1049 	}

  1050 

  1051 __EXECDECL__ TInt Exec::TimerCreate()

  1052 	{

  1053 	SLOW_EXEC0(EExecTimerCreate);

  1054 	}

  1055 

  1056 __EXECDECL__ void Exec::TimerHighRes(TInt, TRequestStatus&, TInt)

  1057 	{

  1058 	SLOW_EXEC3(EExecTimerHighRes);

  1059 	}

  1060 

  1061 __EXECDECL__ void Exec::AfterHighRes(TInt, TRequestStatus&)

  1062 	{

  1063 	SLOW_EXEC2(EExecAfterHighRes);

  1064 	}

  1065 

  1066 __EXECDECL__ TInt Exec::ChangeNotifierCreate(TOwnerType)

  1067 	{

  1068 	SLOW_EXEC1(EExecChangeNotifierCreate);

  1069 	}

  1070 

  1071 __EXECDECL__ TInt Exec::UndertakerCreate(TOwnerType)

  1072 	{

  1073 	SLOW_EXEC1(EExecUndertakerCreate);

  1074 	}

  1075 

  1076 __EXECDECL__ TInt Exec::UndertakerLogon(TInt, TRequestStatus&, TInt&)

  1077 	{

  1078 	SLOW_EXEC3(EExecUndertakerLogon);

  1079 	}

  1080 

  1081 __EXECDECL__ TInt Exec::UndertakerLogonCancel(TInt)

  1082 	{

  1083 	SLOW_EXEC1(EExecUndertakerLogonCancel);

  1084 	}

  1085 

  1086 __EXECDECL__ void Exec::KernelHeapDebug(TInt, TInt, TAny*)

  1087 	{

  1088 	SLOW_EXEC3(EExecKernelHeapDebug);

  1089 	}

  1090 

  1091 __EXECDECL__ TInt Exec::ThreadGetCpuTime(TInt, EXEC_INT64&)

  1092 	{

  1093 	SLOW_EXEC2(EExecThreadGetCpuTime);

  1094 	}

  1095 

  1096 EXPORT_C __EXECDECL__ TInt E32Loader::CodeSegCreate(TCodeSegCreateInfo&)

  1097 	{

  1098 	SLOW_EXEC1(EExecCodeSegCreate);

  1099 	}

  1100 

  1101 EXPORT_C __EXECDECL__ TInt E32Loader::CodeSegLoaded(TCodeSegCreateInfo&)

  1102 	{

  1103 	SLOW_EXEC1(EExecCodeSegLoaded);

  1104 	}

  1105 

  1106 EXPORT_C __EXECDECL__ TInt E32Loader::LibraryCreate(TLibraryCreateInfo&)

  1107 	{

  1108 	SLOW_EXEC1(EExecLibraryCreate);

  1109 	}

  1110 

  1111 EXPORT_C __EXECDECL__ TInt E32Loader::CodeSegOpen(TAny*, TInt)

  1112 	{

  1113 	SLOW_EXEC2(EExecCodeSegOpen);

  1114 	}

  1115 

  1116 EXPORT_C __EXECDECL__ void E32Loader::CodeSegClose(TAny*)

  1117 	{

  1118 	SLOW_EXEC1(EExecCodeSegClose);

  1119 	}

  1120 

  1121 EXPORT_C __EXECDECL__ void E32Loader::CodeSegNext(TAny*&, const TFindCodeSeg&)

  1122 	{

  1123 	SLOW_EXEC2(EExecCodeSegNext);

  1124 	}

  1125 

  1126 EXPORT_C __EXECDECL__ void E32Loader::CodeSegInfo(TAny*, TCodeSegCreateInfo&)

  1127 	{

  1128 	SLOW_EXEC2(EExecCodeSegInfo);

  1129 	}

  1130 

  1131 EXPORT_C __EXECDECL__ TInt E32Loader::CodeSegAddDependency(TAny*, TAny*)

  1132 	{

  1133 	SLOW_EXEC2(EExecCodeSegAddDependency);

  1134 	}