Symaptic: os/kernelhwsrv/kernel/eka/include/exec

     1 //

     2 // Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).All rights reserved.

     3 //

     4 // GENERATED FILE - DO NOT EDIT

     5 //

     7 /**

     8  * @file

     9  * @internalComponent

    10  */

    12 class Exec

    13 	{

    14 public:

    15 	static void WaitForAnyRequest();

    16 	static RAllocator* Heap();

    17 	static RAllocator* HeapSwitch(RAllocator*);

    18 	static TTrapHandler* PushTrapFrame(TTrap*);

    19 	static TTrap* PopTrapFrame();

    20 	static CActiveScheduler* ActiveScheduler();

    21 	static void SetActiveScheduler(CActiveScheduler*);

    22 	static TTimerLockSpec LockPeriod();

    23 	static TTrapHandler* TrapHandler();

    24 	static TTrapHandler* SetTrapHandler(TTrapHandler*);

    25 	static TUint32 DebugMask();

    26 	static TUint32 DebugMaskIndex(TUint);

    27 	static void SetDebugMask(TUint32);

    28 	static TUint32 FastCounter();

    29 	static TUint32 NTickCount();

    30 	static void SetReentryPoint(TLinAddr);

    31 	static TUint32 KernelConfigFlags();

    32 	static TInt UTCOffset();

    33 	static TInt GetGlobalUserData(TInt);

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

    35 	static TUint8* ChunkBase(TInt);

    36 	static TInt ChunkSize(TInt);

    37 	static TInt ChunkMaxSize(TInt);

    38 	static TUint HandleAttributes(TInt);

    39 	static TUint TickCount();

    40 	static void LogicalDeviceGetCaps(TInt, TDes8&);

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

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

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

    44 	static TUint32 MathRandom();

    45 	static void IMB_Range(TAny*, TUint);

    46 	static TInt ResetMachine(TMachineStartupType);

    47 	static TLibraryFunction LibraryLookup(TInt, TInt);

    48 	static void LibraryFileName(TInt, TDes8&);

    49 	static void MutexWait(TInt);

    50 	static void MutexSignal(TInt);

    51 	static TInt ProcessId(TInt);

    52 	static void DllFileName(TInt, TDes8&);

    53 	static void ProcessResume(TInt);

    54 	static void ProcessFileName(TInt, TDes8&);

    55 	static void ProcessCommandLine(TInt, TDes8&);

    56 	static TExitType ProcessExitType(TInt);

    57 	static TInt ProcessExitReason(TInt);

    58 	static void ProcessExitCategory(TInt, TDes8&);

    59 	static TProcessPriority ProcessPriority(TInt);

    60 	static TInt ProcessSetPriority(TInt, TProcessPriority);

    61 	static TUint ProcessFlags(TInt);

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

    63 	static TInt SemaphoreWait(TInt, TInt);

    64 	static void SemaphoreSignal1(TInt);

    65 	static void SemaphoreSignalN(TInt, TInt);

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

    67 	static void ServerCancel(TInt);

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

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

    70 	static TInt ThreadId(TInt);

    71 	static TInt SessionShare(TInt&, TInt);

    72 	static void ThreadResume(TInt);

    73 	static void ThreadSuspend(TInt);

    74 	static TThreadPriority ThreadPriority(TInt);

    75 	static void ThreadSetPriority(TInt, TThreadPriority);

    76 	static TProcessPriority ThreadProcessPriority(TInt);

    77 	static void ThreadSetProcessPriority(TInt, TProcessPriority);

    78 	static TUint ThreadFlags(TInt);

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

    80 	static TInt ThreadRequestCount(TInt);

    81 	static TExitType ThreadExitType(TInt);

    82 	static TInt ThreadExitReason(TInt);

    83 	static void ThreadExitCategory(TInt, TDes8&);

    84 	static void TimerCancel(TInt);

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

    86 	static void TimerAt(TInt, TRequestStatus&, TUint32, TUint32);

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

    88 	static TInt ChangeNotifierLogon(TInt, TRequestStatus&);

    89 	static TInt ChangeNotifierLogoff(TInt);

    90 	static void RequestSignal(TInt);

    91 	static void HandleName(TInt, TDes8&);

    92 	static void HandleFullName(TInt, TDes8&);

    93 	static void HandleInfo(TInt, THandleInfo*);

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

    95 	static void After(TInt, TRequestStatus&);

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

    97 	static void MessageComplete(TInt, TInt);

    98 	static void MessageCompleteWithHandle(TInt, TInt);

    99 	static void TransferSession(TInt, TInt);

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

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

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

   103 	static TInt SetMachineConfiguration(const TDesC8&);

   104 	static void CaptureEventHook();

   105 	static void ReleaseEventHook();

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

   107 	static void RequestEventCancel();

   108 	static TInt AddEvent(const TRawEvent&);

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

   110 	static TAny* DllTls(TInt, TInt);

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

   112 	static void WsRegisterThread();

   113 	static void FsRegisterThread();

   114 	static TInt ProcessCommandLineLength(TInt);

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

   116 	static TInt UserInactivityTime();

   117 	static void ResetInactivityTime();

   118 	static void DebugPrint(TAny*, TInt);

   119 	static TInt BreakPoint();

   120 	static TInt ProfileStart(TInt);

   121 	static TInt ProfileEnd(TInt);

   122 	static TExceptionHandler ExceptionHandler(TInt);

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

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

   125 	static TInt RaiseException(TInt, TExcType);

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

   127 	static TInt ProcessGetMemoryInfo(TInt, TModuleMemoryInfo&);

   128 	static TInt LibraryGetMemoryInfo(TInt, TModuleMemoryInfo&);

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

   130 	static TInt SetMemoryThresholds(TInt, TInt);

   131 	static void LibraryType(TInt, TUidType&);

   132 	static void ProcessType(TInt, TUidType&);

   133 	static TInt ChunkBottom(TInt);

   134 	static TInt ChunkTop(TInt);

   135 	static void ThreadContext(TInt, TDes8&);

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

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

   138 	static TInt HandleClose(TInt);

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

   140 	static TInt ChunkAdjust(TInt, TInt, TInt, TInt);

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

   142 	static TInt HandleDuplicate(TInt, TOwnerType, TInt&);

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

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

   145 	static TInt ThreadOpenById(TUint, TOwnerType);

   146 	static TInt ProcessOpenById(TUint, TOwnerType);

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

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

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

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

   151 	static void DllFreeTls(TInt);

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

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

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

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

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

   157 	static TInt ThreadProcess(TInt);

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

   159 	static TInt ServerCreateWithOptions(const TDesC8*, TInt, TInt, TInt);

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

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

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

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

   164 	static TInt TimerCreate();

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

   166 	static void AfterHighRes(TInt, TRequestStatus&);

   167 	static TInt ChangeNotifierCreate(TOwnerType);

   168 	static TInt UndertakerCreate(TOwnerType);

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

   170 	static TInt UndertakerLogonCancel(TInt);

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

   172 	static TInt ThreadGetCpuTime(TInt, EXEC_INT64&);

   173 	static TInt LastThreadHandle();

   174 	static void ThreadRendezvous(TInt);

   175 	static void ProcessRendezvous(TInt);

   176 	static TInt MessageGetDesLength(TInt, TInt);

   177 	static TInt MessageGetDesMaxLength(TInt, TInt);

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

   179 	static TInt MessageClient(TInt, TOwnerType);

   180 	static TInt MessageSetProcessPriority(TInt, TProcessPriority);

   181 	static void MessageConstructFromPtr(TInt, TAny*);

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

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

   184 	static void ProcessSecurityInfo(TInt, SSecurityInfo&);

   185 	static void ThreadSecurityInfo(TInt, SSecurityInfo&);

   186 	static void MessageSecurityInfo(TInt, SSecurityInfo&);

   187 	static void CreatorSecurityInfo(SSecurityInfo&);

   188 	static void DisabledCapabilities(SCapabilitySet&);

   189 	static TInt ChunkSetRestrictions(TInt, TUint);

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

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

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

   193 	static void MsgQueueNotifySpaceAvailable(TInt, TRequestStatus&);

   194 	static void MsgQueueCancelSpaceAvailable(TInt);

   195 	static void MsgQueueNotifyDataAvailable(TInt, TRequestStatus&);

   196 	static void MsgQueueCancelDataAvailable(TInt);

   197 	static TInt MsgQueueSize(TInt);

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

   199 	static TInt PropertyDelete(TUint, TUint);

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

   201 	static void PropertySubscribe(TInt, TRequestStatus*);

   202 	static void PropertyCancel(TInt);

   203 	static TInt PropertyGetI(TInt, TInt*);

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

   205 	static TInt PropertySetI(TInt, TInt);

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

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

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

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

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

   211 	static TInt PowerEnableWakeupEvents(TPowerState);

   212 	static void PowerDisableWakeupEvents();

   213 	static void PowerRequestWakeupEventNotification(TRequestStatus*);

   214 	static void PowerCancelWakeupEventNotification();

   215 	static TInt PowerDown();

   216 	static TInt ProcessSetHandleParameter(TInt, TInt, TInt);

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

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

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

   220 	static TInt ProcessDataParameterLength(TInt);

   221 	static TUint MessageClientProcessFlags(TInt);

   222 	static TInt ThreadStackInfo(TInt, TThreadStackInfo&);

   223 	static RAllocator* ThreadGetHeap(TInt);

   224 	static TInt ThreadAsProcess(TInt, TInt);

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

   226 	static TInt CondVarWait(TInt, TInt, TInt);

   227 	static void CondVarSignal(TInt);

   228 	static void CondVarBroadcast(TInt);

   229 	static TInt PlatSecDiagnostic(TPlatSecDiagnostic*);

   230 	static TLinAddr ExceptionDescriptor(TLinAddr);

   231 	static void ThreadRequestSignal(TInt);

   232 	static TBool MutexIsHeld(TInt);

   233 	static TTrapHandler* LeaveStart();

   234 	static void LeaveEnd();

   235 	static void SetDebugMaskIndex(TUint32, TUint);

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

   237 	static void NotifyChanges(TUint);

   238 	static TInt SetGlobalUserData(TInt, TInt);

   239 	static TInt SessionSecurityInfo(TInt, SSecurityInfo&);

   240 	static const TRequestStatus* MessageClientStatus(TInt);

   241 	static TInt SetFloatingPointMode(TFloatingPointMode, TFloatingPointRoundingMode);

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

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

   244 	static TBool UTraceOut(TUint32, TUint32, const BTrace::SExecExtension&, TInt);

   245 	static TAny* ProcessExeExportData();

   246 	IMPORT_C static TInt SetWin32RuntimeHook(TAny*);

   247 	static TInt GetBTraceId(TInt);

   248 	static void NotifyOnIdle(TRequestStatus*);

   249 	static void CancelMiscNotifier(TRequestStatus*);

   250 	static void NotifyObjectDestruction(TInt, TRequestStatus*);

   251 	static void RegisterTrustedChunk(TInt);

   252 	static TBool UserThreadExiting(TInt);

   253 	static TBool ChunkIsPaged(TInt);

   254 	static TBool ProcessDefaultDataPaged(TInt);

   255 	static TUint MessageClientThreadFlags(TInt);

   256 	static TInt ShPoolCreate(const TShPoolInfo&, TUint);

   257 	static TInt ShPoolAlloc(TInt, TUint, SShBufBaseAndSize&);

   258 	static void ShPoolGetInfo(TInt, TShPoolInfo&);

   259 	static TUint ShPoolFreeCount(TInt);

   260 	static TInt ShPoolNotification(TInt, TShPoolNotifyType, TUint, TRequestStatus&);

   261 	static TInt ShPoolNotificationCancel(TInt, TShPoolNotifyType, TRequestStatus&);

   262 	static TInt ShPoolBufferWindow(TInt, TInt, TBool);

   263 	static TInt ShBufMap(TInt, TBool, SShBufBaseAndSize&);

   264 	static TInt ShBufUnMap(TInt);

   265 	static TInt ShBufBaseAndSize(TInt, SShBufBaseAndSize&);

   266 	};

   268 #ifdef __GEN_USER_EXEC_CODE__

   269 __EXECDECL__ void Exec::WaitForAnyRequest()

   270 	{

   271 	FAST_EXEC0(EFastExecWaitForAnyRequest);

   272 	}

   274 __EXECDECL__ RAllocator* Exec::Heap()

   275 	{

   276 	FAST_EXEC0(EFastExecHeap);

   277 	}

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

   280 	{

   281 	FAST_EXEC1(EFastExecHeapSwitch);

   282 	}

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

   285 	{

   286 	FAST_EXEC1(EFastExecPushTrapFrame);

   287 	}

   289 __EXECDECL__ TTrap* Exec::PopTrapFrame()

   290 	{

   291 	FAST_EXEC0(EFastExecPopTrapFrame);

   292 	}

   294 __EXECDECL__ CActiveScheduler* Exec::ActiveScheduler()

   295 	{

   296 	FAST_EXEC0(EFastExecActiveScheduler);

   297 	}

   299 __EXECDECL__ void Exec::SetActiveScheduler(CActiveScheduler*)

   300 	{

   301 	FAST_EXEC1(EFastExecSetActiveScheduler);

   302 	}

   304 __EXECDECL__ TTimerLockSpec Exec::LockPeriod()

   305 	{

   306 	FAST_EXEC0(EFastExecLockPeriod);

   307 	}

   309 __EXECDECL__ TTrapHandler* Exec::TrapHandler()

   310 	{

   311 	FAST_EXEC0(EFastExecTrapHandler);

   312 	}

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

   315 	{

   316 	FAST_EXEC1(EFastExecSetTrapHandler);

   317 	}

   319 __EXECDECL__ TUint32 Exec::DebugMask()

   320 	{

   321 	FAST_EXEC0(EFastExecDebugMask);

   322 	}

   324 __EXECDECL__ TUint32 Exec::DebugMaskIndex(TUint)

   325 	{

   326 	FAST_EXEC1(EFastExecDebugMaskIndex);

   327 	}

   329 __EXECDECL__ void Exec::SetDebugMask(TUint32)

   330 	{

   331 	FAST_EXEC1(EFastExecSetDebugMask);

   332 	}

   334 __EXECDECL__ TUint32 Exec::FastCounter()

   335 	{

   336 	FAST_EXEC0(EFastExecFastCounter);

   337 	}

   339 __EXECDECL__ TUint32 Exec::NTickCount()

   340 	{

   341 	FAST_EXEC0(EFastExecNTickCount);

   342 	}

   344 EXPORT_C __EXECDECL__ void UserSvr::LockRamDrive()

   345 	{

   346 	FAST_EXEC0(EFastExecLockRamDrive);

   347 	}

   349 EXPORT_C __EXECDECL__ void UserSvr::UnlockRamDrive()

   350 	{

   351 	FAST_EXEC0(EFastExecUnlockRamDrive);

   352 	}

   354 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomHeaderAddress()

   355 	{

   356 	FAST_EXEC0(EFastExecRomHeaderAddress);

   357 	}

   359 EXPORT_C __EXECDECL__ TLinAddr UserSvr::RomRootDirectoryAddress()

   360 	{

   361 	FAST_EXEC0(EFastExecRomRootDirectoryAddress);

   362 	}

   364 __EXECDECL__ void Exec::SetReentryPoint(TLinAddr)

   365 	{

   366 	FAST_EXEC1(EFastExecSetReentryPoint);

   367 	}

   369 __EXECDECL__ TUint32 Exec::KernelConfigFlags()

   370 	{

   371 	FAST_EXEC0(EFastExecKernelConfigFlags);

   372 	}

   374 __EXECDECL__ TInt Exec::UTCOffset()

   375 	{

   376 	FAST_EXEC0(EFastExecUTCOffset);

   377 	}

   379 __EXECDECL__ TInt Exec::GetGlobalUserData(TInt)

   380 	{

   381 	FAST_EXEC1(EFastExecGetGlobalUserData);

   382 	}

   384 EXPORT_C __EXECDECL__ TBool BTrace::CheckFilter(TUint32)

   385 	{

   386 	FAST_EXEC1(EFastExecCheckFilter);

   387 	}

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

   390 	{

   391 	SLOW_EXEC3(EExecObjectNext);

   392 	}

   394 __EXECDECL__ TUint8* Exec::ChunkBase(TInt)

   395 	{

   396 	SLOW_EXEC1(EExecChunkBase);

   397 	}

   399 __EXECDECL__ TInt Exec::ChunkSize(TInt)

   400 	{

   401 	SLOW_EXEC1(EExecChunkSize);

   402 	}

   404 __EXECDECL__ TInt Exec::ChunkMaxSize(TInt)

   405 	{

   406 	SLOW_EXEC1(EExecChunkMaxSize);

   407 	}

   409 __EXECDECL__ TUint Exec::HandleAttributes(TInt)

   410 	{

   411 	SLOW_EXEC1(EExecHandleAttributes);

   412 	}

   414 __EXECDECL__ TUint Exec::TickCount()

   415 	{

   416 	SLOW_EXEC0(EExecTickCount);

   417 	}

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

   420 	{

   421 	SLOW_EXEC2(EExecLogicalDeviceGetCaps);

   422 	}

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

   425 	{

   426 	SLOW_EXEC2(EExecLogicalDeviceQueryVersionSupported);

   427 	}

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

   430 	{

   431 	SLOW_EXEC4(EExecLogicalDeviceIsAvailable);

   432 	}

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

   435 	{

   436 	SLOW_EXEC2(EExecLocaleExports);

   437 	}

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

   440 	{

   441 	SLOW_EXEC4(EExecChannelRequest);

   442 	}

   444 __EXECDECL__ TUint32 Exec::MathRandom()

   445 	{

   446 	SLOW_EXEC0(EExecMathRandom);

   447 	}

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

   450 	{

   451 	SLOW_EXEC2(EExecIMBRange);

   452 	}

   454 __EXECDECL__ TInt Exec::ResetMachine(TMachineStartupType)

   455 	{

   456 	SLOW_EXEC1(EExecResetMachine);

   457 	}

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

   460 	{

   461 	SLOW_EXEC2(EExecLibraryLookup);

   462 	}

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

   465 	{

   466 	SLOW_EXEC2(EExecLibraryFileName);

   467 	}

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

   470 	{

   471 	SLOW_EXEC2(EExecExecuteInSupervisorMode);

   472 	}

   474 __EXECDECL__ void Exec::MutexWait(TInt)

   475 	{

   476 	SLOW_EXEC1(EExecMutexWait);

   477 	}

   479 __EXECDECL__ void Exec::MutexSignal(TInt)

   480 	{

   481 	SLOW_EXEC1(EExecMutexSignal);

   482 	}

   484 __EXECDECL__ TInt Exec::ProcessId(TInt)

   485 	{

   486 	SLOW_EXEC1(EExecProcessId);

   487 	}

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

   490 	{

   491 	SLOW_EXEC2(EExecDllFileName);

   492 	}

   494 __EXECDECL__ void Exec::ProcessResume(TInt)

   495 	{

   496 	SLOW_EXEC1(EExecProcessResume);

   497 	}

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

   500 	{

   501 	SLOW_EXEC2(EExecProcessFileName);

   502 	}

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

   505 	{

   506 	SLOW_EXEC2(EExecProcessCommandLine);

   507 	}

   509 __EXECDECL__ TExitType Exec::ProcessExitType(TInt)

   510 	{

   511 	SLOW_EXEC1(EExecProcessExitType);

   512 	}

   514 __EXECDECL__ TInt Exec::ProcessExitReason(TInt)

   515 	{

   516 	SLOW_EXEC1(EExecProcessExitReason);

   517 	}

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

   520 	{

   521 	SLOW_EXEC2(EExecProcessExitCategory);

   522 	}

   524 __EXECDECL__ TProcessPriority Exec::ProcessPriority(TInt)

   525 	{

   526 	SLOW_EXEC1(EExecProcessPriority);

   527 	}

   529 __EXECDECL__ TInt Exec::ProcessSetPriority(TInt, TProcessPriority)

   530 	{

   531 	SLOW_EXEC2(EExecProcessSetPriority);

   532 	}

   534 __EXECDECL__ TUint Exec::ProcessFlags(TInt)

   535 	{

   536 	SLOW_EXEC1(EExecProcessFlags);

   537 	}

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

   540 	{

   541 	SLOW_EXEC3(EExecProcessSetFlags);

   542 	}

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

   545 	{

   546 	SLOW_EXEC2(EExecSemaphoreWait);

   547 	}

   549 __EXECDECL__ void Exec::SemaphoreSignal1(TInt)

   550 	{

   551 	SLOW_EXEC1(EExecSemaphoreSignal1);

   552 	}

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

   555 	{

   556 	SLOW_EXEC2(EExecSemaphoreSignalN);

   557 	}

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

   560 	{

   561 	SLOW_EXEC3(EExecServerReceive);

   562 	}

   564 __EXECDECL__ void Exec::ServerCancel(TInt)

   565 	{

   566 	SLOW_EXEC1(EExecServerCancel);

   567 	}

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

   570 	{

   571 	SLOW_EXEC2(EExecSetSessionPtr);

   572 	}

   574 __EXECDECL__ TInt Exec::ThreadId(TInt)

   575 	{

   576 	SLOW_EXEC1(EExecThreadId);

   577 	}

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

   580 	{

   581 	SLOW_EXEC2(EExecSessionShare);

   582 	}

   584 __EXECDECL__ void Exec::ThreadResume(TInt)

   585 	{

   586 	SLOW_EXEC1(EExecThreadResume);

   587 	}

   589 __EXECDECL__ void Exec::ThreadSuspend(TInt)

   590 	{

   591 	SLOW_EXEC1(EExecThreadSuspend);

   592 	}

   594 __EXECDECL__ TThreadPriority Exec::ThreadPriority(TInt)

   595 	{

   596 	SLOW_EXEC1(EExecThreadPriority);

   597 	}

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

   600 	{

   601 	SLOW_EXEC2(EExecThreadSetPriority);

   602 	}

   604 __EXECDECL__ TProcessPriority Exec::ThreadProcessPriority(TInt)

   605 	{

   606 	SLOW_EXEC1(EExecThreadProcessPriority);

   607 	}

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

   610 	{

   611 	SLOW_EXEC2(EExecThreadSetProcessPriority);

   612 	}

   614 __EXECDECL__ TUint Exec::ThreadFlags(TInt)

   615 	{

   616 	SLOW_EXEC1(EExecThreadFlags);

   617 	}

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

   620 	{

   621 	SLOW_EXEC3(EExecThreadSetFlags);

   622 	}

   624 __EXECDECL__ TInt Exec::ThreadRequestCount(TInt)

   625 	{

   626 	SLOW_EXEC1(EExecThreadRequestCount);

   627 	}

   629 __EXECDECL__ TExitType Exec::ThreadExitType(TInt)

   630 	{

   631 	SLOW_EXEC1(EExecThreadExitType);

   632 	}

   634 __EXECDECL__ TInt Exec::ThreadExitReason(TInt)

   635 	{

   636 	SLOW_EXEC1(EExecThreadExitReason);

   637 	}

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

   640 	{

   641 	SLOW_EXEC2(EExecThreadExitCategory);

   642 	}

   644 __EXECDECL__ void Exec::TimerCancel(TInt)

   645 	{

   646 	SLOW_EXEC1(EExecTimerCancel);

   647 	}

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

   650 	{

   651 	SLOW_EXEC3(EExecTimerAfter);

   652 	}

   654 __EXECDECL__ void Exec::TimerAt(TInt, TRequestStatus&, TUint32, TUint32)

   655 	{

   656 	SLOW_EXEC4(EExecTimerAt);

   657 	}

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

   660 	{

   661 	SLOW_EXEC3(EExecTimerLock);

   662 	}

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

   665 	{

   666 	SLOW_EXEC2(EExecChangeNotifierLogon);

   667 	}

   669 __EXECDECL__ TInt Exec::ChangeNotifierLogoff(TInt)

   670 	{

   671 	SLOW_EXEC1(EExecChangeNotifierLogoff);

   672 	}

   674 __EXECDECL__ void Exec::RequestSignal(TInt)

   675 	{

   676 	SLOW_EXEC1(EExecRequestSignal);

   677 	}

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

   680 	{

   681 	SLOW_EXEC2(EExecHandleName);

   682 	}

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

   685 	{

   686 	SLOW_EXEC2(EExecHandleFullName);

   687 	}

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

   690 	{

   691 	SLOW_EXEC2(EExecHandleInfo);

   692 	}

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

   695 	{

   696 	SLOW_EXEC3(EExecHandleCount);

   697 	}

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

   700 	{

   701 	SLOW_EXEC2(EExecAfter);

   702 	}

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

   705 	{

   706 	SLOW_EXEC2(EExecAt);

   707 	}

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

   710 	{

   711 	SLOW_EXEC2(EExecMessageComplete);

   712 	}

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

   715 	{

   716 	SLOW_EXEC2(EExecMessageCompleteWithHandle);

   717 	}

   719 __EXECDECL__ void Exec::TransferSession(TInt, TInt)

   720 	{

   721 	SLOW_EXEC2(EExecTransferSession);

   722 	}

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

   725 	{

   726 	SLOW_EXEC2(EExecTimeNow);

   727 	}

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

   730 	{

   731 	SLOW_EXEC2(EExecTimeNowSecure);

   732 	}

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

   735 	{

   736 	SLOW_EXEC4(EExecSetUTCTimeAndOffset);

   737 	}

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

   740 	{

   741 	SLOW_EXEC1(EExecSetMachineConfiguration);

   742 	}

   744 __EXECDECL__ void Exec::CaptureEventHook()

   745 	{

   746 	SLOW_EXEC0(EExecCaptureEventHook);

   747 	}

   749 __EXECDECL__ void Exec::ReleaseEventHook()

   750 	{

   751 	SLOW_EXEC0(EExecReleaseEventHook);

   752 	}

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

   755 	{

   756 	SLOW_EXEC2(EExecRequestEvent);

   757 	}

   759 __EXECDECL__ void Exec::RequestEventCancel()

   760 	{

   761 	SLOW_EXEC0(EExecRequestEventCancel);

   762 	}

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

   765 	{

   766 	SLOW_EXEC1(EExecAddEvent);

   767 	}

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

   770 	{

   771 	SLOW_EXEC2(EExecDllTls);

   772 	}

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

   775 	{

   776 	SLOW_EXEC4(EExecHalFunction);

   777 	}

   779 __EXECDECL__ void Exec::WsRegisterThread()

   780 	{

   781 	SLOW_EXEC0(EExecWsRegisterThread);

   782 	}

   784 __EXECDECL__ void Exec::FsRegisterThread()

   785 	{

   786 	SLOW_EXEC0(EExecFsRegisterThread);

   787 	}

   789 __EXECDECL__ TInt Exec::ProcessCommandLineLength(TInt)

   790 	{

   791 	SLOW_EXEC1(EExecProcessCommandLineLength);

   792 	}

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

   795 	{

   796 	SLOW_EXEC3(EExecTimerInactivity);

   797 	}

   799 __EXECDECL__ TInt Exec::UserInactivityTime()

   800 	{

   801 	SLOW_EXEC0(EExecUserInactivityTime);

   802 	}

   804 __EXECDECL__ void Exec::ResetInactivityTime()

   805 	{

   806 	SLOW_EXEC0(EExecResetInactivityTime);

   807 	}

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

   810 	{

   811 	SLOW_EXEC2(EExecDebugPrint);

   812 	}

   814 __EXECDECL__ TInt Exec::BreakPoint()

   815 	{

   816 	SLOW_EXEC0(EExecBreakPoint);

   817 	}

   819 __EXECDECL__ TInt Exec::ProfileStart(TInt)

   820 	{

   821 	SLOW_EXEC1(EExecProfileStart);

   822 	}

   824 __EXECDECL__ TInt Exec::ProfileEnd(TInt)

   825 	{

   826 	SLOW_EXEC1(EExecProfileEnd);

   827 	}

   829 __EXECDECL__ TExceptionHandler Exec::ExceptionHandler(TInt)

   830 	{

   831 	SLOW_EXEC1(EExecExceptionHandler);

   832 	}

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

   835 	{

   836 	SLOW_EXEC3(EExecSetExceptionHandler);

   837 	}

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

   840 	{

   841 	SLOW_EXEC3(EExecModifyExceptionMask);

   842 	}

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

   845 	{

   846 	SLOW_EXEC2(EExecRaiseException);

   847 	}

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

   850 	{

   851 	SLOW_EXEC3(EExecIsExceptionHandled);

   852 	}

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

   855 	{

   856 	SLOW_EXEC2(EExecProcessGetMemoryInfo);

   857 	}

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

   860 	{

   861 	SLOW_EXEC2(EExecLibraryGetMemoryInfo);

   862 	}

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

   865 	{

   866 	SLOW_EXEC2(EExecMachineConfiguration);

   867 	}

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

   870 	{

   871 	SLOW_EXEC2(EExecSetMemoryThresholds);

   872 	}

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

   875 	{

   876 	SLOW_EXEC2(EExecLibraryType);

   877 	}

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

   880 	{

   881 	SLOW_EXEC2(EExecProcessType);

   882 	}

   884 __EXECDECL__ TInt Exec::ChunkBottom(TInt)

   885 	{

   886 	SLOW_EXEC1(EExecChunkBottom);

   887 	}

   889 __EXECDECL__ TInt Exec::ChunkTop(TInt)

   890 	{

   891 	SLOW_EXEC1(EExecChunkTop);

   892 	}

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

   895 	{

   896 	SLOW_EXEC2(EExecThreadContext);

   897 	}

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

   900 	{

   901 	SLOW_EXEC3(EExecThreadCreate);

   902 	}

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

   905 	{

   906 	SLOW_EXEC2(EExecFindHandleOpen);

   907 	}

   909 __EXECDECL__ TInt Exec::HandleClose(TInt)

   910 	{

   911 	SLOW_EXEC1(EExecHandleClose);

   912 	}

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

   915 	{

   916 	SLOW_EXEC3(EExecChunkCreate);

   917 	}

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

   920 	{

   921 	SLOW_EXEC4(EExecChunkAdjust);

   922 	}

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

   925 	{

   926 	SLOW_EXEC3(EExecOpenObject);

   927 	}

   929 __EXECDECL__ TInt Exec::HandleDuplicate(TInt, TOwnerType, TInt&)

   930 	{

   931 	SLOW_EXEC3(EExecHandleDuplicate);

   932 	}

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

   935 	{

   936 	SLOW_EXEC2(EExecMutexCreate);

   937 	}

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

   940 	{

   941 	SLOW_EXEC3(EExecSemaphoreCreate);

   942 	}

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

   945 	{

   946 	SLOW_EXEC2(EExecThreadOpenById);

   947 	}

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

   950 	{

   951 	SLOW_EXEC2(EExecProcessOpenById);

   952 	}

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

   955 	{

   956 	SLOW_EXEC4(EExecThreadKill);

   957 	}

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

   960 	{

   961 	SLOW_EXEC3(EExecThreadLogon);

   962 	}

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

   965 	{

   966 	SLOW_EXEC3(EExecThreadLogonCancel);

   967 	}

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

   970 	{

   971 	SLOW_EXEC3(EExecDllSetTls);

   972 	}

   974 __EXECDECL__ void Exec::DllFreeTls(TInt)

   975 	{

   976 	SLOW_EXEC1(EExecDllFreeTls);

   977 	}

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

   980 	{

   981 	SLOW_EXEC2(EExecThreadRename);

   982 	}

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

   985 	{

   986 	SLOW_EXEC2(EExecProcessRename);

   987 	}

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

   990 	{

   991 	SLOW_EXEC4(EExecProcessKill);

   992 	}

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

   995 	{

   996 	SLOW_EXEC3(EExecProcessLogon);

   997 	}

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

  1000 	{

  1001 	SLOW_EXEC3(EExecProcessLogonCancel);

  1002 	}

  1004 __EXECDECL__ TInt Exec::ThreadProcess(TInt)

  1005 	{

  1006 	SLOW_EXEC1(EExecThreadProcess);

  1007 	}

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

  1010 	{

  1011 	SLOW_EXEC2(EExecServerCreate);

  1012 	}

  1014 __EXECDECL__ TInt Exec::ServerCreateWithOptions(const TDesC8*, TInt, TInt, TInt)

  1015 	{

  1016 	SLOW_EXEC4(EExecServerCreateWithOptions);

  1017 	}

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

  1020 	{

  1021 	SLOW_EXEC4(EExecSessionCreate);

  1022 	}

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

  1025 	{

  1026 	SLOW_EXEC4(EExecSessionCreateFromHandle);

  1027 	}

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

  1030 	{

  1031 	SLOW_EXEC2(EExecDeviceLoad);

  1032 	}

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

  1035 	{

  1036 	SLOW_EXEC2(EExecDeviceFree);

  1037 	}

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

  1040 	{

  1041 	SLOW_EXEC3(EExecChannelCreate);

  1042 	}

  1044 __EXECDECL__ TInt Exec::TimerCreate()

  1045 	{

  1046 	SLOW_EXEC0(EExecTimerCreate);

  1047 	}

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

  1050 	{

  1051 	SLOW_EXEC3(EExecTimerHighRes);

  1052 	}

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

  1055 	{

  1056 	SLOW_EXEC2(EExecAfterHighRes);

  1057 	}

  1059 __EXECDECL__ TInt Exec::ChangeNotifierCreate(TOwnerType)

  1060 	{

  1061 	SLOW_EXEC1(EExecChangeNotifierCreate);

  1062 	}

  1064 __EXECDECL__ TInt Exec::UndertakerCreate(TOwnerType)

  1065 	{

  1066 	SLOW_EXEC1(EExecUndertakerCreate);

  1067 	}

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

  1070 	{

  1071 	SLOW_EXEC3(EExecUndertakerLogon);

  1072 	}

  1074 __EXECDECL__ TInt Exec::UndertakerLogonCancel(TInt)

  1075 	{

  1076 	SLOW_EXEC1(EExecUndertakerLogonCancel);

  1077 	}

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

  1080 	{

  1081 	SLOW_EXEC3(EExecKernelHeapDebug);

  1082 	}

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

  1085 	{

  1086 	SLOW_EXEC2(EExecThreadGetCpuTime);

  1087 	}

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

  1090 	{

  1091 	SLOW_EXEC1(EExecCodeSegCreate);

  1092 	}

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

  1095 	{

  1096 	SLOW_EXEC1(EExecCodeSegLoaded);

  1097 	}

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

  1100 	{

  1101 	SLOW_EXEC1(EExecLibraryCreate);

  1102 	}

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

  1105 	{

  1106 	SLOW_EXEC2(EExecCodeSegOpen);

  1107 	}

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

  1110 	{

  1111 	SLOW_EXEC1(EExecCodeSegClose);

  1112 	}

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

  1115 	{

  1116 	SLOW_EXEC2(EExecCodeSegNext);

  1117 	}

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

  1120 	{

  1121 	SLOW_EXEC2(EExecCodeSegInfo);

  1122 	}

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

  1125 	{

  1126 	SLOW_EXEC2(EExecCodeSegAddDependency);

  1127 	}

  1129 EXPORT_C __EXECDECL__ void E32Loader::CodeSegDeferDeletes()

  1130 	{

  1131 	SLOW_EXEC0(EExecCodeSegDeferDeletes);

  1132 	}

  1134 EXPORT_C __EXECDECL__ void E32Loader::CodeSegEndDeferDeletes()

  1135 	{

  1136 	SLOW_EXEC0(EExecCodeSegEndDeferDeletes);

  1137 	}

  1139 EXPORT_C __EXECDECL__ TInt E32Loader::ProcessCreate(TProcessCreateInfo&, const TDesC8*)

  1140 	{

  1141 	SLOW_EXEC2(EExecProcessCreate);

  1142 	}

  1144 EXPORT_C __EXECDECL__ TInt E32Loader::ProcessLoaded(TProcessCreateInfo&)

  1145 	{

  1146 	SLOW_EXEC1(EExecProcessLoaded);

  1147 	}

  1149 EXPORT_C __EXECDECL__ TInt E32Loader::CheckClientState(TInt)

  1150 	{

  1151 	SLOW_EXEC1(EExecCheckLoaderClientState);

  1152 	}

  1154 EXPORT_C __EXECDECL__ TAny* E32Loader::ThreadProcessCodeSeg(TInt)

  1155 	{

  1156 	SLOW_EXEC1(EExecThreadProcessCodeSeg);

  1157 	}

  1159 EXPORT_C __EXECDECL__ void E32Loader::ReadExportDir(TAny*, TLinAddr*)

  1160 	{

  1161 	SLOW_EXEC2(EExecCodeSegReadExportDir);

  1162 	}

  1164 __EXECDECL__ TInt E32Loader::WaitDllLock()

  1165 	{

  1166 	SLOW_EXEC0(EExecWaitDllLock);

  1167 	}

  1169 __EXECDECL__ TInt E32Loader::ReleaseDllLock()

  1170 	{

  1171 	SLOW_EXEC0(EExecReleaseDllLock);

  1172 	}

  1174 __EXECDECL__ TInt E32Loader::LibraryAttach(TInt, TInt&, TLinAddr*)

  1175 	{

  1176 	SLOW_EXEC3(EExecLibraryAttach);

  1177 	}

  1179 __EXECDECL__ TInt E32Loader::LibraryAttached(TInt)

  1180 	{

  1181 	SLOW_EXEC1(EExecLibraryAttached);

  1182 	}

  1184 __EXECDECL__ TInt E32Loader::StaticCallList(TInt&, TLinAddr*)

  1185 	{

  1186 	SLOW_EXEC2(EExecStaticCallList);

  1187 	}

  1189 __EXECDECL__ TInt E32Loader::LibraryDetach(TInt&, TLinAddr*)

  1190 	{

  1191 	SLOW_EXEC2(EExecLibraryDetach);

  1192 	}

  1194 __EXECDECL__ TInt E32Loader::LibraryDetached()

  1195 	{

  1196 	SLOW_EXEC0(EExecLibraryDetached);

  1197 	}

  1199 __EXECDECL__ TInt Exec::LastThreadHandle()

  1200 	{

  1201 	SLOW_EXEC0(EExecLastThreadHandle);

  1202 	}

  1204 __EXECDECL__ void Exec::ThreadRendezvous(TInt)

  1205 	{

  1206 	SLOW_EXEC1(EExecThreadRendezvous);

  1207 	}

  1209 __EXECDECL__ void Exec::ProcessRendezvous(TInt)

  1210 	{

  1211 	SLOW_EXEC1(EExecProcessRendezvous);

  1212 	}

  1214 __EXECDECL__ TInt Exec::MessageGetDesLength(TInt, TInt)

  1215 	{

  1216 	SLOW_EXEC2(EExecMessageGetDesLength);

  1217 	}

  1219 __EXECDECL__ TInt Exec::MessageGetDesMaxLength(TInt, TInt)

  1220 	{

  1221 	SLOW_EXEC2(EExecMessageGetDesMaxLength);

  1222 	}

  1224 __EXECDECL__ TInt Exec::MessageClient(TInt, TOwnerType)

  1225 	{

  1226 	SLOW_EXEC2(EExecMessageClient);

  1227 	}

  1229 __EXECDECL__ TInt Exec::MessageSetProcessPriority(TInt, TProcessPriority)

  1230 	{

  1231 	SLOW_EXEC2(EExecMessageSetProcessPriority);

  1232 	}

  1234 __EXECDECL__ void Exec::MessageConstructFromPtr(TInt, TAny*)

  1235 	{

  1236 	SLOW_EXEC2(EExecMessageConstructFromPtr);

  1237 	}

  1239 __EXECDECL__ void Exec::MessageKill(TInt, TExitType, TInt, const TDesC8*)

  1240 	{

  1241 	SLOW_EXEC4(EExecMessageKill);

  1242 	}

  1244 __EXECDECL__ TInt Exec::MessageOpenObject(TInt, TObjectType, TInt, TOwnerType)

  1245 	{

  1246 	SLOW_EXEC4(EExecMessageOpenObject);

  1247 	}

  1249 __EXECDECL__ void Exec::ProcessSecurityInfo(TInt, SSecurityInfo&)

  1250 	{

  1251 	SLOW_EXEC2(EExecProcessSecurityInfo);

  1252 	}

  1254 __EXECDECL__ void Exec::ThreadSecurityInfo(TInt, SSecurityInfo&)

  1255 	{

  1256 	SLOW_EXEC2(EExecThreadSecurityInfo);

  1257 	}

  1259 __EXECDECL__ void Exec::MessageSecurityInfo(TInt, SSecurityInfo&)

  1260 	{

  1261 	SLOW_EXEC2(EExecMessageSecurityInfo);

  1262 	}

  1264 __EXECDECL__ void Exec::CreatorSecurityInfo(SSecurityInfo&)

  1265 	{

  1266 	SLOW_EXEC1(EExecCreatorSecurityInfo);

  1267 	}

  1269 __EXECDECL__ void Exec::DisabledCapabilities(SCapabilitySet&)

  1270 	{

  1271 	SLOW_EXEC1(EExecDisabledCapabilities);

  1272 	}

  1274 __EXECDECL__ TInt Exec::ChunkSetRestrictions(TInt, TUint)

  1275 	{

  1276 	SLOW_EXEC2(EExecChunkSetRestrictions);

  1277 	}

  1279 __EXECDECL__ TInt Exec::MsgQueueCreate(const TDesC8*, TInt, TInt, TOwnerType)

  1280 	{

  1281 	SLOW_EXEC4(EExecMsgQueueCreate);

  1282 	}

  1284 __EXECDECL__ TInt Exec::MsgQueueSend(TInt, const TAny*, TInt)

  1285 	{

  1286 	SLOW_EXEC3(EExecMsgQueueSend);

  1287 	}

  1289 __EXECDECL__ TInt Exec::MsgQueueReceive(TInt, TAny*, TInt)

  1290 	{

  1291 	SLOW_EXEC3(EExecMsgQueueReceive);

  1292 	}

  1294 __EXECDECL__ void Exec::MsgQueueNotifySpaceAvailable(TInt, TRequestStatus&)

  1295 	{

  1296 	SLOW_EXEC2(EExecMsgQueueNotifySpaceAvailable);

  1297 	}

  1299 __EXECDECL__ void Exec::MsgQueueCancelSpaceAvailable(TInt)

  1300 	{

  1301 	SLOW_EXEC1(EExecMsgQueueCancelSpaceAvailable);

  1302 	}

  1304 __EXECDECL__ void Exec::MsgQueueNotifyDataAvailable(TInt, TRequestStatus&)

  1305 	{

  1306 	SLOW_EXEC2(EExecMsgQueueNotifyDataAvailable);

  1307 	}

  1309 __EXECDECL__ void Exec::MsgQueueCancelDataAvailable(TInt)

  1310 	{

  1311 	SLOW_EXEC1(EExecMsgQueueCancelDataAvailable);

  1312 	}

  1314 __EXECDECL__ TInt Exec::MsgQueueSize(TInt)

  1315 	{

  1316 	SLOW_EXEC1(EExecMsgQueueSize);

  1317 	}

  1319 __EXECDECL__ TInt Exec::PropertyDefine(TUint, TUint, TPropertyInfo*)

  1320 	{

  1321 	SLOW_EXEC3(EExecPropertyDefine);

  1322 	}

  1324 __EXECDECL__ TInt Exec::PropertyDelete(TUint, TUint)

  1325 	{

  1326 	SLOW_EXEC2(EExecPropertyDelete);

  1327 	}

  1329 __EXECDECL__ TInt Exec::PropertyAttach(TUint, TUint, TOwnerType)

  1330 	{

  1331 	SLOW_EXEC3(EExecPropertyAttach);

  1332 	}

  1334 __EXECDECL__ void Exec::PropertySubscribe(TInt, TRequestStatus*)

  1335 	{

  1336 	SLOW_EXEC2(EExecPropertySubscribe);

  1337 	}

  1339 __EXECDECL__ void Exec::PropertyCancel(TInt)

  1340 	{

  1341 	SLOW_EXEC1(EExecPropertyCancel);

  1342 	}

  1344 __EXECDECL__ TInt Exec::PropertyGetI(TInt, TInt*)

  1345 	{

  1346 	SLOW_EXEC2(EExecPropertyGetI);

  1347 	}

  1349 __EXECDECL__ TInt Exec::PropertyGetB(TInt, TUint8*, TInt)

  1350 	{

  1351 	SLOW_EXEC3(EExecPropertyGetB);

  1352 	}

  1354 __EXECDECL__ TInt Exec::PropertySetI(TInt, TInt)

  1355 	{

  1356 	SLOW_EXEC2(EExecPropertySetI);

  1357 	}

  1359 __EXECDECL__ TInt Exec::PropertySetB(TInt, const TUint8*, TInt)

  1360 	{

  1361 	SLOW_EXEC3(EExecPropertySetB);

  1362 	}

  1364 __EXECDECL__ TInt Exec::PropertyFindGetI(TUint, TUint, TInt*)

  1365 	{

  1366 	SLOW_EXEC3(EExecPropertyFindGetI);

  1367 	}

  1369 __EXECDECL__ TInt Exec::PropertyFindGetB(TUint, TUint, TUint8*, TInt)

  1370 	{

  1371 	SLOW_EXEC4(EExecPropertyFindGetB);

  1372 	}

  1374 __EXECDECL__ TInt Exec::PropertyFindSetI(TUint, TUint, TInt)

  1375 	{

  1376 	SLOW_EXEC3(EExecPropertyFindSetI);

  1377 	}

  1379 __EXECDECL__ TInt Exec::PropertyFindSetB(TUint, TUint, TUint8*, TInt)

  1380 	{

  1381 	SLOW_EXEC4(EExecPropertyFindSetB);

  1382 	}

  1384 __EXECDECL__ TInt Exec::PowerEnableWakeupEvents(TPowerState)

  1385 	{

  1386 	SLOW_EXEC1(EExecPowerEnableWakeupEvents);

  1387 	}

  1389 __EXECDECL__ void Exec::PowerDisableWakeupEvents()

  1390 	{

  1391 	SLOW_EXEC0(EExecPowerDisableWakeupEvents);

  1392 	}

  1394 __EXECDECL__ void Exec::PowerRequestWakeupEventNotification(TRequestStatus*)

  1395 	{

  1396 	SLOW_EXEC1(EExecPowerRequestWakeupEventNotification);

  1397 	}

  1399 __EXECDECL__ void Exec::PowerCancelWakeupEventNotification()

  1400 	{

  1401 	SLOW_EXEC0(EExecPowerCancelWakeupEventNotification);

  1402 	}

  1404 __EXECDECL__ TInt Exec::PowerDown()

  1405 	{

  1406 	SLOW_EXEC0(EExecPowerDown);

  1407 	}

  1409 __EXECDECL__ TInt Exec::ProcessSetHandleParameter(TInt, TInt, TInt)

  1410 	{

  1411 	SLOW_EXEC3(EExecProcessSetHandleParameter);

  1412 	}

  1414 __EXECDECL__ TInt Exec::ProcessSetDataParameter(TInt, TInt, const TUint8*, TInt)

  1415 	{

  1416 	SLOW_EXEC4(EExecProcessSetDataParameter);

  1417 	}

  1419 __EXECDECL__ TInt Exec::ProcessGetHandleParameter(TInt, TObjectType, TOwnerType)

  1420 	{

  1421 	SLOW_EXEC3(EExecProcessGetHandleParameter);

  1422 	}

  1424 __EXECDECL__ TInt Exec::ProcessGetDataParameter(TInt, TUint8*, TInt)

  1425 	{

  1426 	SLOW_EXEC3(EExecProcessGetDataParameter);

  1427 	}

  1429 __EXECDECL__ TInt Exec::ProcessDataParameterLength(TInt)

  1430 	{

  1431 	SLOW_EXEC1(EExecProcessDataParameterLength);

  1432 	}

  1434 __EXECDECL__ TUint Exec::MessageClientProcessFlags(TInt)

  1435 	{

  1436 	SLOW_EXEC1(EExecMessageClientProcessFlags);

  1437 	}

  1439 __EXECDECL__ TInt Exec::ThreadStackInfo(TInt, TThreadStackInfo&)

  1440 	{

  1441 	SLOW_EXEC2(EExecThreadStackInfo);

  1442 	}

  1444 __EXECDECL__ RAllocator* Exec::ThreadGetHeap(TInt)

  1445 	{

  1446 	SLOW_EXEC1(EExecThreadGetHeap);

  1447 	}

  1449 __EXECDECL__ TInt Exec::ThreadAsProcess(TInt, TInt)

  1450 	{

  1451 	SLOW_EXEC2(EExecThreadAsProcess);

  1452 	}

  1454 __EXECDECL__ TInt Exec::CondVarCreate(const TDesC8*, TOwnerType)

  1455 	{

  1456 	SLOW_EXEC2(EExecCondVarCreate);

  1457 	}

  1459 __EXECDECL__ TInt Exec::CondVarWait(TInt, TInt, TInt)

  1460 	{

  1461 	SLOW_EXEC3(EExecCondVarWait);

  1462 	}

  1464 __EXECDECL__ void Exec::CondVarSignal(TInt)

  1465 	{

  1466 	SLOW_EXEC1(EExecCondVarSignal);

  1467 	}

  1469 __EXECDECL__ void Exec::CondVarBroadcast(TInt)

  1470 	{

  1471 	SLOW_EXEC1(EExecCondVarBroadcast);

  1472 	}

  1474 __EXECDECL__ TInt Exec::PlatSecDiagnostic(TPlatSecDiagnostic*)

  1475 	{

  1476 	SLOW_EXEC1(EExecPlatSecDiagnostic);

  1477 	}

  1479 __EXECDECL__ TLinAddr Exec::ExceptionDescriptor(TLinAddr)

  1480 	{

  1481 	SLOW_EXEC1(EExecExceptionDescriptor);

  1482 	}

  1484 __EXECDECL__ void Exec::ThreadRequestSignal(TInt)

  1485 	{

  1486 	SLOW_EXEC1(EExecThreadRequestSignal);

  1487 	}

  1489 __EXECDECL__ TBool Exec::MutexIsHeld(TInt)

  1490 	{

  1491 	SLOW_EXEC1(EExecMutexIsHeld);

  1492 	}

  1494 __EXECDECL__ TTrapHandler* Exec::LeaveStart()

  1495 	{

  1496 	SLOW_EXEC0(EExecLeaveStart);

  1497 	}

  1499 __EXECDECL__ void Exec::LeaveEnd()

  1500 	{

  1501 	SLOW_EXEC0(EExecLeaveEnd);

  1502 	}

  1504 __EXECDECL__ void Exec::SetDebugMaskIndex(TUint32, TUint)

  1505 	{

  1506 	SLOW_EXEC2(EExecSetDebugMaskIndex);

  1507 	}

  1509 __EXECDECL__ TInt Exec::GetModuleNameFromAddress(TAny*, TDes8&)

  1510 	{

  1511 	SLOW_EXEC2(EExecGetModuleNameFromAddress);

  1512 	}

  1514 __EXECDECL__ void Exec::NotifyChanges(TUint)

  1515 	{

  1516 	SLOW_EXEC1(EExecNotifyChanges);

  1517 	}

  1519 __EXECDECL__ TInt Exec::SetGlobalUserData(TInt, TInt)

  1520 	{

  1521 	SLOW_EXEC2(EExecSetGlobalUserData);

  1522 	}

  1524 __EXECDECL__ TInt Exec::SessionSecurityInfo(TInt, SSecurityInfo&)

  1525 	{

  1526 	SLOW_EXEC2(EExecSessionSecurityInfo);

  1527 	}

  1529 __EXECDECL__ const TRequestStatus* Exec::MessageClientStatus(TInt)

  1530 	{

  1531 	SLOW_EXEC1(EExecMessageClientStatus);

  1532 	}

  1534 __EXECDECL__ TInt Exec::SetFloatingPointMode(TFloatingPointMode, TFloatingPointRoundingMode)

  1535 	{

  1536 	SLOW_EXEC2(EExecSetFloatingPointMode);

  1537 	}

  1539 EXPORT_C __EXECDECL__ TBool BTrace::CheckFilter2(TUint32, TUint32)

  1540 	{

  1541 	SLOW_EXEC2(EExecCheckFilter2);

  1542 	}

  1544 __EXECDECL__ TAny* Exec::ProcessExeExportData()

  1545 	{

  1546 	SLOW_EXEC0(EExecProcessExeExportData);

  1547 	}

  1549 EXPORT_C __EXECDECL__ TInt E32Loader::NotifyIfCodeSegDestroyed(TRequestStatus&)

  1550 	{

  1551 	SLOW_EXEC1(EExecNotifyIfCodeSegDestroyed);

  1552 	}

  1554 EXPORT_C __EXECDECL__ TInt E32Loader::GetDestroyedCodeSegInfo(TCodeSegLoaderCookie&)

  1555 	{

  1556 	SLOW_EXEC1(EExecGetDestroyedCodeSegInfo);

  1557 	}

  1559 EXPORT_C __EXECDECL__ TInt Exec::SetWin32RuntimeHook(TAny*)

  1560 	{

  1561 	SLOW_EXEC1(EExecSetWin32RuntimeHook);

  1562 	}

  1564 __EXECDECL__ TInt Exec::GetBTraceId(TInt)

  1565 	{

  1566 	SLOW_EXEC1(EExecGetBTraceId);

  1567 	}

  1569 __EXECDECL__ void Exec::NotifyOnIdle(TRequestStatus*)

  1570 	{

  1571 	SLOW_EXEC1(EExecNotifyOnIdle);

  1572 	}

  1574 __EXECDECL__ void Exec::CancelMiscNotifier(TRequestStatus*)

  1575 	{

  1576 	SLOW_EXEC1(EExecCancelMiscNotifier);

  1577 	}

  1579 __EXECDECL__ void Exec::NotifyObjectDestruction(TInt, TRequestStatus*)

  1580 	{

  1581 	SLOW_EXEC2(EExecNotifyObjectDestruction);

  1582 	}

  1584 __EXECDECL__ void Exec::RegisterTrustedChunk(TInt)

  1585 	{

  1586 	SLOW_EXEC1(EExecRegisterTrustedChunk);

  1587 	}

  1589 __EXECDECL__ TBool Exec::UserThreadExiting(TInt)

  1590 	{

  1591 	SLOW_EXEC1(EExecUserThreadExiting);

  1592 	}

  1594 __EXECDECL__ TBool Exec::ChunkIsPaged(TInt)

  1595 	{

  1596 	SLOW_EXEC1(EExecChunkIsPaged);

  1597 	}

  1599 __EXECDECL__ TBool Exec::ProcessDefaultDataPaged(TInt)

  1600 	{

  1601 	SLOW_EXEC1(EExecProcessDefaultDataPaged);

  1602 	}

  1604 __EXECDECL__ TUint Exec::MessageClientThreadFlags(TInt)

  1605 	{

  1606 	SLOW_EXEC1(EExecMessageClientThreadFlags);

  1607 	}

  1609 __EXECDECL__ TInt Exec::ShPoolCreate(const TShPoolInfo&, TUint)

  1610 	{

  1611 	SLOW_EXEC2(EExecShPoolCreate);

  1612 	}

  1614 __EXECDECL__ TInt Exec::ShPoolAlloc(TInt, TUint, SShBufBaseAndSize&)

  1615 	{

  1616 	SLOW_EXEC3(EExecShPoolAlloc);

  1617 	}

  1619 __EXECDECL__ void Exec::ShPoolGetInfo(TInt, TShPoolInfo&)

  1620 	{

  1621 	SLOW_EXEC2(EExecShPoolGetInfo);

  1622 	}

  1624 __EXECDECL__ TUint Exec::ShPoolFreeCount(TInt)

  1625 	{

  1626 	SLOW_EXEC1(EExecShPoolFreeCount);

  1627 	}

  1629 __EXECDECL__ TInt Exec::ShPoolNotification(TInt, TShPoolNotifyType, TUint, TRequestStatus&)

  1630 	{

  1631 	SLOW_EXEC4(EExecShPoolNotification);

  1632 	}

  1634 __EXECDECL__ TInt Exec::ShPoolNotificationCancel(TInt, TShPoolNotifyType, TRequestStatus&)

  1635 	{

  1636 	SLOW_EXEC3(EExecShPoolNotificationCancel);

  1637 	}

  1639 __EXECDECL__ TInt Exec::ShPoolBufferWindow(TInt, TInt, TBool)

  1640 	{

  1641 	SLOW_EXEC3(EExecShPoolBufferWindow);

  1642 	}

  1644 __EXECDECL__ TInt Exec::ShBufMap(TInt, TBool, SShBufBaseAndSize&)

  1645 	{

  1646 	SLOW_EXEC3(EExecShBufMap);

  1647 	}

  1649 __EXECDECL__ TInt Exec::ShBufUnMap(TInt)

  1650 	{

  1651 	SLOW_EXEC1(EExecShBufUnMap);

  1652 	}

  1654 __EXECDECL__ TInt Exec::ShBufBaseAndSize(TInt, SShBufBaseAndSize&)

  1655 	{

  1656 	SLOW_EXEC2(EExecShBufBaseAndSize);

  1657 	}

  1659 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--