/*********************************************************************************//*! * \file T1_scopeInterface.h * * \brief T1.scope interface declarations and macros * * \par Visibility * External * * \author nick * * \version 3.3.0.1 r55938 * * \copyright GLIWA GmbH embedded systems, Weilheim i.OB. All rights reserved *************************************************************************************/ #ifndef T1_SCOPE_INTERFACE_H_ #define T1_SCOPE_INTERFACE_H_ (1) /*----------------------------------------------------------------------------------*/ /*--- header includes --------------------------------------------------------------*/ /*----------------------------------------------------------------------------------*/ #include "T1_baseInterface.h" /*----------------------------------------------------------------------------------*/ /*--- macros used by type definitions ----------------------------------------------*/ /*----------------------------------------------------------------------------------*/ #define T1_NOF_HANDLERS (19u) #define T1_VS_ACT_IDX (0) #define T1_VS_START_IDX (1) #define T1_VS_STOP_IDX (2) #define T1_VS_START_STPW_IDX (3) #define T1_VS_STOP_STPW_IDX (4) #define T1_VS_OTHER_IDX (5) #define T1_VS_EVENT_KINDS (6u) #define T1_CC_QUEUE_MAX (8u) /*----------------------------------------------------------------------------------*/ /*--- type definitions -------------------------------------------------------------*/ /*----------------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------------*/ /* The following type defines the structure of a single trace-entry */ /* The array T1_traceBuffer of entries of this type define the trace buffer */ #if defined T1_64BIT_TRACE_ENTRY typedef T1_uint64_t T1_eventInfo_t; /* in order to pass eventInfo to T1_TraceEvent() even with 32bit info */ typedef T1_uint64_t T1_traceEntry_t; # define T1_DATA_BYTES_PER_ENTRY (7u) # define T1_DATA_BYTES_USERDATA_STOP (4u) # define T1_INFO_BIT_WIDTH (32) #else /* ! defined T1_64BIT_TRACE_ENTRY */ typedef T1_uint16_t T1_eventInfo_t; typedef T1_uint32_t T1_traceEntry_t; # define T1_DATA_BYTES_PER_ENTRY (3u) # define T1_DATA_BYTES_USERDATA_STOP (1u) # define T1_INFO_BIT_WIDTH (10) #endif /* defined T1_64BIT_TRACE_ENTRY */ /*----------------------------------------------------------------------------------*/ /* When using a logic analyzer instead of the trace buffer, the event and the */ /* info is written to a single cell which is traced. Instead of the target's */ /* internal time, the logic analyzer's time stamp is used. */ typedef T1_uint16_t T1_traceCell_t; /*----------------------------------------------------------------------------------*/ typedef T1_uint16Least_t T1_nofEntries_t; //!< number of trace buffer entries /*----------------------------------------------------------------------------------*/ /*! \brief Storage for Lamport's Bakery algorithm. */ typedef volatile struct { T1_bool_t entering; T1_uint8_t align8; T1_uint16_t number; } T1_bakery_t; /*----------------------------------------------------------------------------------*/ /*! \brief T1.scope task identifier. */ #if defined T1_64BIT_TRACE_ENTRY typedef T1_sint32_t T1_taskId_t; #else /* ! defined T1_64BIT_TRACE_ENTRY */ typedef signed short T1_taskId_t; #endif /* defined T1_64BIT_TRACE_ENTRY */ /*! \brief T1.scope stopwatch identifier. */ typedef unsigned short T1_stpwId_t; /*! \brief 32-bit type for time calculations. */ typedef T1_uint32_t T1_longTime_t; /*! \brief Type for 31-bit T1.cont result and 1-bit flag. */ typedef T1_uint32_t T1_resultTime_t; /*! \brief T1.cont constraint index. */ typedef unsigned char T1_csrnIdx_t; /*! \brief T1.cont stopwatch index. */ typedef unsigned char T1_stpwIdx_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for one task being analysed in the foreground. */ typedef struct { T1_taskId_t prevTaskId; //!< Pre-empted task ID T1_uint8_t instanceKey; //!< Instance key of pre-empted task T1_uint8_t taskType; //!< Flags e.g. multi-activation T1_resultTime_t netAccumulation; //!< CET of pre-empted (or this in WAIT) T1_resultTime_t max; //!< Maximum core execution time T1_resultTime_t min; //!< Minimum core execution time T1_resultTime_t maxIPT; //!< Maximum initial pending time T1_resultTime_t maxRT; //!< Maximum response time union { T1_uint32_t data; //!< Activation data struct { T1_uint16_t dataOffset; //!< Index into multiple activation array T1_uint8_t activationHead; T1_uint8_t activationTail; } _; } act; T1_resultTime_t total; //!< Aggregated core execution time } T1_taskFgData_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for one task being analysed in the foreground. */ typedef const struct { T1_uint8_t taskType; //!< Flags e.g. multi-activation T1_uint8_t align8; T1_uint16_t dataOffset; //!< Index into multiple activation array } T1_taskFgInitData_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for task instance data. */ typedef union { struct { T1_uint8_t stpwType; //!< CET/GET/DA T1_uint8_t instanceKeyOrTail; //!< Distinguish task instances T1_taskId_t taskIdOrHead; //!< Started task ID for CET stopwatch } _; T1_uint32_t all; //!< Used for equality testing } T1_taskInstance_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for one stopwatch being analysed in the foreground. */ typedef struct { T1_taskInstance_t _; T1_uint32_t start; //!< Start time T1_sint8_t focusIdx_; //!< Minus one means no focus T1_sint8_t csrnIdx; //!< Minus one means no constraint T1_uint16_t shortThreshold; //!< Zero means use full 32-bit threshold T1_resultTime_t min; //!< Minimum CET or GET T1_resultTime_t max; //!< Maximum CET or GET } T1_stpwFgData_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for one foreground virtual stopwatch (event chain). */ typedef struct { T1_uint16_t eventInfo; T1_uint8_t startStopIdx; T1_stpwIdx_t stpwIdx; } T1_vStpwData_t; /*----------------------------------------------------------------------------------*/ /*! \brief Used for BSF CPU load. */ typedef struct { T1_longTime_t te_; T1_longTime_t lastFrameEventTime_; T1_longTime_t teTotal_; T1_longTime_t toTotal_; T1_uint16_t discardCount_; T1_uint8_t avgCPULoadCount_; T1_bool_t isFirstFrame_; } T1_cpuLoad_t; /*----------------------------------------------------------------------------------*/ /*! \brief Part of one focus measurement. */ struct T1_focusStruct_t { T1_uint32_t focusEventCount_; T1_resultTime_t focusTotalLow_; T1_resultTime_t focusIntervalLow_; union { T1_uint32_t both; struct { T1_uint16_t total; T1_uint16_t interval; } parts; } focusHighs_; T1_stpwIdx_t focusStpwIdx_; T1_uint8_t focusIdx_; union { T1_bool_t focusRunning_; T1_uint8_t focusState_; } _; T1_uint8_t coreId_; T1_uint32_t focusEventMax_; }; /*! \brief Used for one focus measurement. */ typedef struct { struct T1_focusStruct_t _; T1_resultTime_t focusLastTime_; } T1_focusData_t; /*----------------------------------------------------------------------------------*/ /*! \brief T1.scope data relating sync to trace time. */ typedef struct { T1_uint32_t syncTime; T1_tickUint_t traceTime; } T1_syncTimerBase_t; /*----------------------------------------------------------------------------------*/ typedef struct { T1_uint16_t eventInfoIn; T1_uint8_t eventOut; T1_stpwIdx_t stpwIdx; } T1_vStpwMapping_t; /*----------------------------------------------------------------------------------*/ /*! \brief Jump table for foreground T1.cont helper functions. */ struct T1_stpwDataStruct_t; struct T1_scopeConstsStruct_t; typedef struct { void (*pFgContRefreshTaskRTNoSuspPC)( T1_uint8Least_t coreId, T1_uint16Least_t nOfTasks ); void (*pFgContResetCPULoadNoSuspPC)( T1_uint8Least_t coreId, T1_uint8_t _avgCPULoadSamples ); void (*pFgContResetPC)( T1_uint8Least_t coreId ); T1_resultTime_t (*pFgContGetPC[6])( T1_uint8Least_t coreId, T1_uint16Least_t taskOrStpwIdx ); void (*pFgContResetTaskPC)( T1_uint8Least_t coreId, T1_uint16Least_t taskMinIdx, T1_uint16Least_t taskMaxIdx ); void (*pFgContResetStpwPC)( T1_uint8Least_t coreId, T1_uint16Least_t stpwMinIdx, T1_uint16Least_t stpwMaxIdx, struct T1_stpwDataStruct_t *pStpwConfig ); void (*pFgContCalibrationPC)( T1_uint8Least_t coreId, T1_uint8Least_t phaseId ); T1_uint8_t (*pFgContChangedStatusPC)( T1_uint8Least_t coreId ); void (*pFgContStartFocusNoSuspPC)( T1_uint8Least_t coreId, T1_uint8_t _focusIdx ); void (*pFgContHaltFocusNoSuspPC)( T1_uint8Least_t coreId, T1_uint8_t _focusIdx ); void (*pFgContSetVSNoSuspPC)( T1_uint8Least_t coreId, T1_uint32_t vStpwStartStopEventInfo, T1_stpwIdx_t stpwIdx, T1_uint8_t stpwCfg ); void (*pFgContUnsetVSPC)( T1_uint8Least_t coreId, T1_stpwIdx_t stpwIdx ); void (*pFgContSetConstraintPC)( T1_uint8Least_t coreId, T1_stpwIdx_t stpwIdx, T1_csrnIdx_t csrnIdx, T1_longTime_t threshold ); T1_uint8_t * (*pFgContAllocCCVS)( void ); void (*pFgContConfigCCVS)( void ); void (*pFgContSetCCVSPC)( T1_uint8Least_t coreId, T1_uint8Least_t analysisCoreId ); void (*pFgContCCVSPC)( T1_uint8Least_t coreId, T1_uint8Least_t analysisCoreId, T1_uint32_t syncTime ); T1_resultTime_t (*pFgContGetCCVSMinNoSusp)( void ); T1_resultTime_t (*pFgContGetCCVSMaxNoSusp)( void ); void (*pFgContResetCCVSMin)( void ); void (*pFgContResetCCVSMax)( void ); void (*pFgContInitNoSuspPC)( T1_uint8Least_t coreId ); void (*pFgContUpdateBsfPC)( T1_uint8Least_t coreId, T1_eventInfo_t bsfDelim ); void (*pFgContScopeOHHelper)( const struct T1_scopeConstsStruct_t *pScopeConsts ); void (*pFgContFlexOHHelper)( const struct T1_scopeConstsStruct_t *pScopeConsts, T1_eventInfo_t startEventInfo, T1_eventInfo_t stopEventInfo ); void (*pFgContRefreshCCVSPC)( T1_uint8Least_t coreId, T1_uint8Least_t analysisCoreId ); } T1_fgContHelpers_t; /*----------------------------------------------------------------------------------*/ /*! \brief T1.scope global data for one core. */ typedef struct { /* 0 */ union { T1_uint32_t combined; struct { T1_uint16_t wrIdx; T1_uint16_t wrWrapCounter; } _; } volatile tB; T1_uint16_t compareIdx; T1_uint8_t compareState; T1_uint8_t syncPeriodCounter; T1_uint16_t triggerIdx; T1_uint16_t streamBlockIdx; T1_uint16_t streamBlockEvents; T1_uint8_t triggerWrapMark; T1_uint8_t streamSeqIdx; /* 16 */ T1_syncTimerBase_t _; T1_uint8_t scopeState; /* See state machine */ T1_uint8_t partCount; /* For buffer > 64KB */ #if defined T1_CPU32BIT || defined T1_CPU64BIT T1_uint16_t align16; #endif /* defined T1_CPU32BIT || defined T1_CPU64BIT */ T1_uint32_t transmitControlMask; /* Messages to transmit */ /* 32 */ } T1_scopeGlobals_t; /*----------------------------------------------------------------------------------*/ struct T1_scopeFgConstsStruct_t; typedef T1_tickUint_t (*T1_pFgContEventHandler_t)( struct T1_scopeFgConstsStruct_t const *pScopeFgConsts, T1_eventInfo_t eventInfo, T1_uint32_t syncTime, T1_uint32_t traceTime ); /* polyspace Checker artefact: Tool seems to be confused by struct forward declaration. */ struct T1_contGlobalsStruct_t; typedef struct { T1_scopeGlobals_t _; T1_longTime_t now_; T1_resultTime_t netTaskAccumulation_; /* No init required because background task has no CET */ T1_taskInstance_t currentTask_; T1_uint16_t overhead_[2]; T1_uint16_t flexEpilogueOverhead_; T1_uint8_t cpuLoadMultiplier_; /* Zero in background task */ T1_uint8_t taskInstanceSeed_; T1_uint8_t nOfUserStpws_; T1_uint8_t nOfNonVrtlStpws_; T1_uint8_t align8; T1_uint8_t status; T1_longTime_t bsfTe; T1_longTime_t bsfStopTime; T1_tickUint_t (*pDispatcher)( struct T1_scopeFgConstsStruct_t const *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); T1_pFgContEventHandler_t pHandler[T1_NOF_HANDLERS]; T1_uint16_t tmp_; T1_eventInfo_t bsfDelimiter; T1_cpuLoad_t cpuLoadData; void (*pFgVStpwAll)( struct T1_scopeFgConstsStruct_t const *pScopeConsts, T1_uint16_t eventInfo, T1_uint32_t traceTime, T1_vStpwMapping_t const *vStpws ); T1_vStpwData_t ccvsData[T1_VS_EVENT_KINDS]; T1_uint32_t cCStpwData[T1_CC_QUEUE_MAX]; T1_uint8_t volatile cCStpwHead; T1_uint8_t volatile cCStpwTail; T1_uint16_t cCNow; T1_uint32_t handlerConfigMask; struct T1_contGlobalsStruct_t *pContGlobals; } T1_scopeFgGlobals_t; /*----------------------------------------------------------------------------------*/ /* * Elements 'bufferEntriesMinusOne' and 'syncTimerWidthBits' are not strictly * necessary but they are useful and, without them, we would have required alignment * padding. */ /*! \brief T1.scope constant data for one core. */ typedef const struct T1_scopeConstsStruct_t { union { T1_scopeGlobals_t *pScopeGlobals; //!< Non-consts T1_scopeFgGlobals_t *pScopeFgGlobals; //!< Non-consts with foreground T1.cont } _; T1_traceEntry_t T1_FARPTR pTraceBuffer; //!< Trace buffer T1_uint16_t bufferEntriesMinusOne; T1_bool_t syncTimerIsTraceTimer; T1_uint8_t syncTimerWidthBits; T1_uint8_t traceTimerWidthBits; T1_uint8_t coreId; T1_uint16_t bufferEntries; //!< Trace buffer entries /* 16 */ } T1_scopeConsts_t; /*----------------------------------------------------------------------------------*/ /*! \brief T1.scope constant data for one core extended for foreground T1.cont. */ typedef const struct T1_scopeFgConstsStruct_t { T1_scopeConsts_t _; T1_taskFgData_t *pTaskData; T1_focusData_t *pFocus; T1_stpwFgData_t *pStpwData; } T1_scopeFgConsts_t; /*----------------------------------------------------------------------------------*/ typedef const struct { T1_uint16_t overhead_; T1_uint16_t flexOverhead_; T1_uint16_t flexEpilogueOverhead_; T1_uint8_t nOfUserStpws_; T1_uint8_t nOfNonVrtlStpws_; /* 64-bit aligned */ T1_tickUint_t (*pDispatcher)( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); T1_uint32_t handlerConfigMask; #if defined T1_64BIT_TRACE_ENTRY && defined T1_CPU64BIT T1_uint32_t align; #elif ! defined T1_64BIT_TRACE_ENTRY && (defined T1_CPU32BIT || defined T1_CPU64BIT) T1_uint16_t align; #endif T1_eventInfo_t bsfDelimiter; } T1_scopeFgGlobalsInit_t; /*----------------------------------------------------------------------------------*/ typedef struct { T1_tickUint_t (*pNoSuspTime)( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t time ); T1_tickUint_t (*pUint32RestNoSusp)( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); } T1_traceIndirect_t; /*----------------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------------*/ /*--- macros, inline functions and forward declarations ----------------------------*/ /*----------------------------------------------------------------------------------*/ #define T1_NS_TO_TICKS_CORE0( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE0_NS)) #define T1_US_TO_TICKS_CORE0( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE0_NS)) #define T1_MS_TO_TICKS_CORE0( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE0_NS)) #define T1_NS_TO_TICKS_CORE1( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE1_NS)) #define T1_US_TO_TICKS_CORE1( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE1_NS)) #define T1_MS_TO_TICKS_CORE1( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE1_NS)) #define T1_NS_TO_TICKS_CORE2( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE2_NS)) #define T1_US_TO_TICKS_CORE2( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE2_NS)) #define T1_MS_TO_TICKS_CORE2( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE2_NS)) #define T1_NS_TO_TICKS_CORE3( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE3_NS)) #define T1_US_TO_TICKS_CORE3( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE3_NS)) #define T1_MS_TO_TICKS_CORE3( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE3_NS)) #define T1_NS_TO_TICKS_CORE4( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE4_NS)) #define T1_US_TO_TICKS_CORE4( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE4_NS)) #define T1_MS_TO_TICKS_CORE4( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE4_NS)) #define T1_NS_TO_TICKS_CORE5( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE5_NS)) #define T1_US_TO_TICKS_CORE5( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE5_NS)) #define T1_MS_TO_TICKS_CORE5( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE5_NS)) #define T1_NS_TO_TICKS_CORE6( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE6_NS)) #define T1_US_TO_TICKS_CORE6( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE6_NS)) #define T1_MS_TO_TICKS_CORE6( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE6_NS)) #define T1_NS_TO_TICKS_CORE7( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE7_NS)) #define T1_US_TO_TICKS_CORE7( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE7_NS)) #define T1_MS_TO_TICKS_CORE7( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE7_NS)) #define T1_NS_TO_TICKS_CORE8( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE8_NS)) #define T1_US_TO_TICKS_CORE8( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE8_NS)) #define T1_MS_TO_TICKS_CORE8( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE8_NS)) #define T1_NS_TO_TICKS_CORE9( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE9_NS)) #define T1_US_TO_TICKS_CORE9( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE9_NS)) #define T1_MS_TO_TICKS_CORE9( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE9_NS)) #define T1_NS_TO_TICKS_CORE10( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE10_NS)) #define T1_US_TO_TICKS_CORE10( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE10_NS)) #define T1_MS_TO_TICKS_CORE10( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE10_NS)) #define T1_NS_TO_TICKS_CORE11( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE11_NS)) #define T1_US_TO_TICKS_CORE11( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE11_NS)) #define T1_MS_TO_TICKS_CORE11( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE11_NS)) #define T1_NS_TO_TICKS_CORE12( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE12_NS)) #define T1_US_TO_TICKS_CORE12( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE12_NS)) #define T1_MS_TO_TICKS_CORE12( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE12_NS)) #define T1_NS_TO_TICKS_CORE13( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE13_NS)) #define T1_US_TO_TICKS_CORE13( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE13_NS)) #define T1_MS_TO_TICKS_CORE13( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE13_NS)) #define T1_NS_TO_TICKS_CORE14( ns_ ) ((T1_tickUint_t)(((ns_) * 1.0f) / T1_TICK_DURATION_CORE14_NS)) #define T1_US_TO_TICKS_CORE14( us_ ) ((T1_tickUint_t)(((us_) * 1000.0f) / T1_TICK_DURATION_CORE14_NS)) #define T1_MS_TO_TICKS_CORE14( ms_ ) ((T1_tickUint_t)(((ms_) * 1000000.0f) / T1_TICK_DURATION_CORE14_NS)) #define T1_INVALID_TASK_ID ((T1_taskId_t)-1) #define T1_FG_CONT_INVALID_FOCUS_IDX (-1) #define T1_FG_CONT_INVALID_CSRN_IDX (-1) /* taskType flags */ #define T1_TT_FG_TASK (0x1u) #define T1_TT_GET_CPU_LOAD_MULT( tt_ ) ((tt_) & 0x1u) #define T1_TT_ALL_CORE_ID (0xFu) #define T1_TT_GET_CORE_ID( tt_ ) ((T1_uint8Least_t)(((tt_) >> 1) & 0xFu)) #define T1_TT_MULTI_ACT_SHIFT (5) #define T1_TT_GET_MULTI_ACT( tt_ ) ((tt_) >> T1_TT_MULTI_ACT_SHIFT) #define T1_FOCUS_DISABLED (3u) /* foreground T1.cont calibration phases */ #define T1_CALIBRATION_SCOPE_START (0u) #define T1_CALIBRATION_SCOPE_STOP (1u) #define T1_CALIBRATION_FLEX_START (2u) #define T1_CALIBRATION_FLEX_STOP (3u) #if ! defined T1_OH_UNDERFLOW # define T1_OH_UNDERFLOW( coreId_ ) #endif /* Remove T1.flex bit. Override for debugging. */ #if ! defined T1_CHECK_HANDLER_IDX # define T1_CHECK_HANDLER_IDX( pScopeConsts_, handlerIdx_ ) \ do \ { \ (handlerIdx_) >>= 1; \ } \ while( 0 ) #endif #define T1_HANDLER_DIFF_SHIFT (27) #define T1_DIFF_MASK (0xFFFFFFFFuL >> (32 - T1_HANDLER_DIFF_SHIFT)) #if defined T1_SUPPORT_TIMER_OVERFLOW || defined T1_DETECT_TIMER_OVERFLOW && ! defined T1_64BIT_TRACE_ENTRY /* * Support for intervals > 65535 ticks at the expense of variable overhead. * Very large intervals are logged with T1_DISCONTINUITY. Shorter intervals are * logged by inserting T1_EMPTY events to synthesize intervals up to 65535 ticks. */ # define T1_CHECK_DIFF( pScopeConsts_, eventInfo_, diff_, syncTime_, handlerIdx_, near_ ) \ do \ { \ if( 0uL != (diff_) >> 16 ) \ { \ if( 100uL < (diff_) >> 16 ) \ { \ return T1_ ## near_ ## BrokenInterval( \ (pScopeConsts_), \ (eventInfo_), \ T1_INSERT32( (diff_), \ (handlerIdx_), \ T1_HANDLER_DIFF_SHIFT, \ (32 - T1_HANDLER_DIFF_SHIFT) ), \ (syncTime_) ); \ } \ return T1_## near_ ## LargeInterval( \ (pScopeConsts_), \ (eventInfo_), \ T1_INSERT32( (diff_), \ (handlerIdx_), \ T1_HANDLER_DIFF_SHIFT, \ (32 - T1_HANDLER_DIFF_SHIFT) ), \ (syncTime_) ); \ } \ } \ while( 0 ) #else /* With intervals <= 65535 ticks, bypass check to minimize latency. */ # define T1_CHECK_DIFF( pScopeConsts_, eventInfo_, diff_, syncTime_, handlerIdx_, near_ ) \ ( (void)0 ) #endif /* No do ... while( 0 ) to avoid Tasking warnings */ #define T1_DISPATCH_PC( coreId_, pScopeConsts_, eventInfo_, traceTime_, handlerIdx_, clm_, checkInterval_, near_ ) \ { \ T1_scopeFgGlobals_t * const pScopeGlobals = pScopeConsts->_._.pScopeFgGlobals; \ T1_uint32_t syncTime; \ T1_uint32_t withoutOverhead; \ T1_uint32_t const diff = ( (traceTime_) - pScopeGlobals->now_ ) \ & (0xFFFFFFFFuL >> (32 - T1_TRACE_TIMER_BIT_LENGTH_CORE ## coreId_)); \ pScopeGlobals->now_ += diff; \ withoutOverhead = diff - pScopeGlobals->overhead_[T1_IS_FLEX_HANDLER(handlerIdx_)]; \ T1_CHECK_HANDLER_IDX( pScopeGlobals, (handlerIdx_) ); \ pScopeGlobals->netTaskAccumulation_ += withoutOverhead; \ pScopeGlobals->bsfTe += withoutOverhead * (clm_); \ if( T1_TRACE_TIMER_IS_SYNC_TIMER_CORE ## coreId_ ) \ { \ syncTime = pScopeGlobals->now_; \ } \ else \ { \ T1_tickUint_t const traceTimerDelta = (traceTime_) - pScopeGlobals->_._.traceTime; \ syncTime = pScopeGlobals->_._.syncTime + T1_TRACE_TO_SYNC_TIME_CORE ## coreId_( traceTimerDelta ); \ } \ if( checkInterval_ ) \ { \ T1_CHECK_DIFF( pScopeConsts, (eventInfo_), diff, syncTime, (handlerIdx_), near_ ); \ } \ return pScopeGlobals->pHandler[handlerIdx_]( pScopeConsts, (eventInfo_), pScopeGlobals->now_, syncTime ); \ } #define T1_SCOPE_PLUGIN_ID (1u) /* Note check that eventId is not too large to be a valid shift. */ #define T1_FG_CONT_GET_HANDLER_IDX( eventInfo_, handlerIdx_ ) \ do \ { \ T1_uint16Least_t const eventId = (eventInfo >> T1_INFO_BIT_WIDTH) & 0x3Fu; \ (handlerIdx_) = T1_EMPTY_HANDLER_IDX; \ if( (eventId <= 15u) \ && ( 0u != ( ( ( (1u << T1_ACTIVATION_HANDLER_IDX) \ | (1u << T1_START_HANDLER_IDX) \ | (1u << T1_START_STOP_HANDLER_IDX) \ | (1u << T1_STOP_HANDLER_IDX) \ | (1u << T1_RESUME_HANDLER_IDX) \ | (1u << T1_WAIT_HANDLER_IDX) \ | (1u << T1_STOP_START_HANDLER_IDX) \ | (1u << T1_STPW_START_HANDLER_IDX) \ | (1u << T1_STPW_STOP_HANDLER_IDX) \ | (1u << T1_STPW_STOP_START_INC_HANDLER_IDX) \ | (1u << T1_STPW_STOP_START_HANDLER_IDX) ) >> eventId ) & 1u ) ) ) \ { \ (handlerIdx_) = eventId; \ (eventInfo_) &= T1_COMBINE_EVENT_INFO( 0u, 0xFFFFFFFFuL ); \ } \ } \ while( 0 ) #define T1_EMPTY_HANDLER_IDX ( 0u) #define T1_START_HANDLER_IDX ( 1u) #define T1_STOP_HANDLER_IDX ( 2u) #define T1_START_STOP_HANDLER_IDX ( 3u) #define T1_STOP_START_HANDLER_IDX ( 4u) #define T1_STPW_START_HANDLER_IDX ( 5u) #define T1_STPW_STOP_HANDLER_IDX ( 6u) #define T1_STPW_STOP_START_HANDLER_IDX ( 7u) #define T1_STPW_STOP_START_INC_HANDLER_IDX ( 8u) #define T1_FLEX_STPW_START_HANDLER_IDX ( 9u) #define T1_FLEX_STPW_STOP_HANDLER_IDX (10u) #define T1_START_NOACT_HANDLER_IDX (11u) #define T1_ACTIVATION_HANDLER_IDX (12u) #define T1_WAIT_HANDLER_IDX (13u) #define T1_RESUME_HANDLER_IDX (14u) #define T1_STOP_START_NOACT_HANDLER_IDX (15u) #define T1_FLEX_STPW_STOP_START_INC_HANDLER_IDX (16u) #define T1_FLEX_STPW_STOP_GET_START_HANDLER_IDX (17u) /* STOP SWD */ #define T1_FLEX_STPW_START_SWD_HANDLER_IDX (18u) #define T1_LAST_HANDLER_IDX (18u) #define T1_ALL_START_MASK \ ( (1uL << T1_START_HANDLER_IDX) \ | (1uL << T1_START_NOACT_HANDLER_IDX) \ | (1uL << T1_STOP_START_HANDLER_IDX) \ | (1uL << T1_STOP_START_NOACT_HANDLER_IDX) \ ) #define T1_ALL_STOP_MASK \ ( (1uL << T1_STOP_HANDLER_IDX) \ | (1uL << T1_STOP_START_HANDLER_IDX) \ | (1uL << T1_STOP_START_NOACT_HANDLER_IDX) \ ) #define T1_ALL_STOPWATCH_START_MASK \ ( (1uL << T1_STPW_START_HANDLER_IDX) \ | (1uL << T1_STPW_STOP_START_HANDLER_IDX) \ | (1uL << T1_STPW_STOP_START_INC_HANDLER_IDX) \ ) #define T1_ALL_STOPWATCH_STOP_MASK \ ( (1uL << T1_STPW_STOP_HANDLER_IDX) \ | (1uL << T1_STPW_STOP_START_HANDLER_IDX) \ | (1uL << T1_STPW_STOP_START_INC_HANDLER_IDX) \ ) #define T1_ALL_FLEX_STOPWATCH_START_MASK \ ( (1uL << T1_FLEX_STPW_START_HANDLER_IDX) \ | (1uL << T1_FLEX_STPW_START_SWD_HANDLER_IDX) \ | (1uL << T1_FLEX_STPW_STOP_START_INC_HANDLER_IDX) \ ) #define T1_ALL_FLEX_STOPWATCH_STOP_MASK \ ( (1uL << T1_FLEX_STPW_STOP_HANDLER_IDX) \ | (1uL << T1_FLEX_STPW_STOP_GET_START_HANDLER_IDX) \ | (1uL << T1_FLEX_STPW_STOP_START_INC_HANDLER_IDX) \ ) #if defined T1_DISABLE_T1_FLEX && ! defined T1_TEST_ONLY # define T1_IS_FLEX_HANDLER( handlerIdx_ ) (0u) #else # define T1_IS_FLEX_HANDLER( handlerIdx_ ) ((handlerIdx_) & 1uL) #endif /* defined T1_ALTERNATIVE_IS_FLEX_HANDLER */ #define T1_ALL_OTHER_MASK \ ( \ (1uL << T1_EMPTY_HANDLER_IDX) \ | (1uL << T1_WAIT_HANDLER_IDX) \ | (1uL << T1_RESUME_HANDLER_IDX) \ ) #define T1_BSF_EVENT_TO_MASK( eventId_ ) \ ( (T1_START == (eventId_)) ? T1_ALL_START_MASK \ : (T1_ACTIVATION == (eventId_)) ? 1uL << T1_ACTIVATION_HANDLER_IDX \ : 1uL << T1_EMPTY_HANDLER_IDX \ ) #define T1_EMPTY 0x00u /* empty (no entry, initialized) */ #define T1_START 0x01u /* start of a task or ISR */ #define T1_STOP 0x02u /* end of a task or ISR */ #define T1_START_STOP 0x03u /* start and end of a short task or ISR */ #define T1_STOP_START 0x04u /* end of one task and start of a 2nd */ #define T1_STOPWATCH_START 0x05u //!< start stopwatch #define T1_STOPWATCH_STOP 0x06u //!< stop stopwatch #define T1_STOPWATCH_STOP_START 0x07u //!< stop stopwatch n, start n #define T1_STOPWATCH_STOP_START_INC 0x08u //!< stop stopwatch n-1, start n #define T1_FLEX_UEC 0x09u /* T1.flex code event */ #define T1_FLEX_UED 0x0Au /* T1.flex data event */ #define T1_FLEX_USERDATA_START 0x0Bu /* T1.flex data event with data */ #define T1_ACTIVATION 0x0Cu /* successful task activation */ #if defined T1_DISABLE_T1_CONT || defined T1_WAIT_RESUME # define T1_WAIT 0x0Du /* task called WaitEvent */ # define T1_RESUME 0x0Eu /* task returned from WaitEvent */ #endif /* defined T1_DISABLE_T1_CONT || defined T1_WAIT_RESUME */ #define T1_DISCONTINUITY 0x0Fu /* resume after stop trace */ #define T1_ACTIVATION_FAILED 0x10u //!< failed task activation (E_OS_LIMIT) #define T1_RELEASE 0x11u /* task had a waiting event set */ #define T1_SYNCDATA 0x12u /* synchronisation timestamp data transfered with a single entry */ #define T1_SYNCDATA_START 0x12u /* synchronisation timestamp data transfered in a sequence */ #define T1_USERDATA_START 0x13u /* user data */ #define T1_USERDATA_MID 0x14u /* user data with no timestamp */ #define T1_USERDATA_STOP 0x15u /* user data */ #define T1_RUNNABLE_START 0x16u //!< start of a runnable #define T1_RUNNABLE_STOP 0x17u //!< end of a runnable #define T1_TRIGGER 0x18u /* trigger */ #define T1_STOPWATCH_STOP_GET_START 0x19u /* stop stopwatch plus GET user data */ #define T1_START_IPT_START 0x1Au /* start task plus IPT user data */ #define T1_FLEX_MSR_ID 0x1Bu /* start/stop measurement ID */ #define T1_STOP_START_IPT_START 0x1Du /* start task plus IPT and stop task user data */ #if T1_STOP_START_IPT_START - T1_START_IPT_START != T1_STOP_START - T1_START # error Invalid T1_STOP_START_IPT_START identifier #endif /* T1_STOP_START_IPT_START - T1_START_IPT_START != T1_STOP_START - T1_START */ #define T1_TASK_NAME_START 0x1Eu //!< dynamic task name #define T1_TASK_OS_IDS_START 0x1Fu //!< dynamic OS-specific IDs /* * Do not change the value of T1_NAMEBUFFER_ENTRIES, * It will break the traceBuffer interpretation on T1-HOST-SW side * Special care is required to ensure that a traceBuffer transfer is not mis-interpreted as a prefix transfer */ #define T1_NAMEBUFFER_ENTRIES (28) #define T1_NAME_BYTES (32) /* GCP handles up to 0xFFFF bytes but limit to 0xFFF8 to avoid cutting 64bit events in half. */ #define T1_MAX_TRACE_BUFFER_MSG_BYTES_ (0xFFF8) #define T1_MAX_TRACE_BUFFER_MSG_BYTES ((T1_uint32Least_t)T1_MAX_TRACE_BUFFER_MSG_BYTES_) #if defined T1_64BIT_TRACE_ENTRY # define T1_TRACE_ENTRY_BYTES (8) #else /* !defined T1_64BIT_TRACE_ENTRY */ # define T1_TRACE_ENTRY_BYTES (4) #endif /* defined T1_64BIT_TRACE_ENTRY */ #if defined T1_ENABLE && ! defined T1_DISABLE_T1_SCOPE /*! * Combine event ID and info field into a single 16-bit value. * \param[in] event_ the event ID * \param[in] info_ additional info field, for example task/stopwatch ID * \returns the combined result */ # define T1_COMBINE_EVENT_INFO( event_, info_ ) \ ( (T1_eventInfo_t)( ((T1_eventInfo_t)(event_) << T1_INFO_BIT_WIDTH) \ | ((T1_eventInfo_t)(info_) & (0xFFFFFFFFuL >> (32 - T1_INFO_BIT_WIDTH))) ) ) # define T1_TRACEDATA_UINT8 0x0u # define T1_TRACEDATA_SINT8 0x1u # define T1_TRACEDATA_UINT16 0x2u # define T1_TRACEDATA_SINT16 0x3u # define T1_TRACEDATA_UINT32 0x4u # define T1_TRACEDATA_SINT32 0x5u # define T1_TRACEDATA_UINT64 0x6u # define T1_TRACEDATA_SINT64 0x7u # define T1_TRACEDATA_FLOAT 0x8u # define T1_TRACEDATA_ADDRESS 0x9u # if defined T1_64BIT_TRACE_ENTRY # define T1_TRACEDATA_STR_REST0 0x200u # define T1_TRACEDATA_STR_REST1 0x201u # define T1_TRACEDATA_STR_REST2 0x202u # define T1_TRACEDATA_STR_REST3 0x203u # define T1_TRACEDATA_STR_REST4 0x204u # define T1_TRACEDATA_STR_REST5 0x205u # define T1_TRACEDATA_STR_REST6 0x206u # define T1_TRACEDATA_BIN_REST0 0x207u # define T1_TRACEDATA_BIN_REST1 0x208u # define T1_TRACEDATA_BIN_REST2 0x209u # define T1_TRACEDATA_BIN_REST3 0x20Au # define T1_TRACEDATA_BIN_REST4 0x20Bu # define T1_TRACEDATA_BIN_REST5 0x20Cu # define T1_TRACEDATA_BIN_REST6 0x20Du # else /* 16 bit trace time */ # define T1_TRACEDATA_STR_REST0 0xAu # define T1_TRACEDATA_STR_REST1 0xBu # define T1_TRACEDATA_STR_REST2 0xCu # define T1_TRACEDATA_BIN_REST0 0xDu # define T1_TRACEDATA_BIN_REST1 0xEu # define T1_TRACEDATA_BIN_REST2 0xFu # endif /* defined T1_64BIT_TRACE_ENTRY*/ # define T1_TRACE_ATOMIC_( vrnt_, te_, pScopeConsts_, eventInfo_ ) \ T1_CAT( T1_TRACE_ATOMIC3, vrnt_ )( te_, pScopeConsts_, eventInfo_ ) # define T1_TRACE_ATOMIC__( vrnt_, te_, pScopeConsts_, data1_, data2_ ) \ T1_CAT( T1_TRACE_ATOMIC4, vrnt_ )( te_, pScopeConsts_, data1_, data2_ ) # define T1_TRACE_ATOMIC___( vrnt_, te_, pScopeConsts_, data1_, data2_, data3_ ) \ T1_CAT( T1_TRACE_ATOMIC5, vrnt_ )( te_, pScopeConsts_, data1_, data2_, data3_ ) # if defined T1_INTERRUPTS_ARE_ENABLED # define T1_TRACE_ATOMIC3( te_, pScopeConsts_, eventInfo_ ) \ do \ { \ if( T1_INTERRUPTS_ARE_ENABLED( ) ) \ { \ T1_TRACE_ATOMIC3_FAST( te_, pScopeConsts_, eventInfo_ ); \ } \ else \ { \ T1_TRACE_ATOMIC3_NOSUSP( te_, pScopeConsts_, eventInfo_ ); \ } \ } \ while( 0 ) # define T1_TRACE_ATOMIC4( te_, pScopeConsts_, data1_, data2_ ) \ do \ { \ if( T1_INTERRUPTS_ARE_ENABLED( ) ) \ { \ T1_TRACE_ATOMIC4_FAST( te_, pScopeConsts_, data1_, data2_ ); \ } \ else \ { \ T1_TRACE_ATOMIC4_NOSUSP( te_, pScopeConsts_, data1_, data2_ ); \ } \ } \ while( 0 ) # else /* ! defined T1_INTERRUPTS_ARE_ENABLED */ # define T1_TRACE_ATOMIC3( te_, pScopeConsts_, eventInfo_ ) \ T1_TRACE_ATOMIC3_FAST( te_, pScopeConsts_, eventInfo_ ) # define T1_TRACE_ATOMIC4( te_, pScopeConsts_, data1_, data2_ ) \ T1_TRACE_ATOMIC4_FAST( te_, pScopeConsts_, data1_, data2_ ) # endif /* defined T1_INTERRUPTS_ARE_ENABLED */ # define T1_TRACE_ATOMIC3_FAST( te_, pScopeConsts_, eventInfo_ ) \ do \ { \ T1_DISABLE_INTERRUPTS( ); \ T1_TRACE_ATOMIC3_NOSUSP( te_, pScopeConsts_, eventInfo_ ); \ T1_ENABLE_INTERRUPTS( ); \ } \ while( 0 ) # define T1_TRACE_ATOMIC4_FAST( te_, pScopeConsts_, data1_, data2_ ) \ do \ { \ T1_DISABLE_INTERRUPTS( ); \ T1_TRACE_ATOMIC4_NOSUSP( te_, pScopeConsts_, data1_, data2_ ); \ T1_ENABLE_INTERRUPTS( ); \ } \ while( 0 ) # if defined T1_CONT_REMOTE # define T1_RC RC__ # define T1_TRACE_EVENT_NOSUSP_TIME T1_NearTraceEventNoSuspTimeRC__ # define T1_FAR_TRACE_EVENT_NOSUSP_TIME T1_TraceEventNoSuspTimeRC__ # else /* ! defined T1_CONT_REMOTE */ # define T1_RC __ # define T1_TRACE_EVENT_NOSUSP_TIME T1_NearTraceEventNoSuspTime__ # define T1_FAR_TRACE_EVENT_NOSUSP_TIME T1_TraceEventNoSuspTime__ # endif /* defined T1_CONT_REMOTE */ # define T1_TRACE_ATOMIC3_NOSUSP( te_, pScopeConsts_, eventInfo_ ) \ ( T1_CAT( te_ ## NoSusp, T1_RC )( pScopeConsts_, eventInfo_ ) ) # define T1_TRACE_ATOMIC4_NOSUSP( te_, pScopeConsts_, eventInfo_, data_ ) \ ( T1_CAT( te_ ## NoSusp, T1_RC )( pScopeConsts_, eventInfo_, data_ ) ) # define T1_TRACE_ATOMIC4_NOSUSPTIME( te_, pScopeConsts_, data1_, data2_ ) \ ( T1_CAT( te_ ## NoSuspTime, T1_RC )( pScopeConsts_, data1_, data2_ ) ) # define T1_TRACE_ATOMIC5_NOSUSPTIME( te_, pScopeConsts_, data1_, data2_, data3_ ) \ ( T1_CAT( te_ ## NoSuspTime, T1_RC )( pScopeConsts_, data1_, data2_, data3_ ) ) # define T1_TraceEventNoSuspRC__( pScopeConsts_, eventInfo_ ) \ T1_TraceEventNoSusp__( pScopeConsts_, eventInfo_ ) # define T1_TRACE_UINT32( vrnt_, pScopeConsts_, info_, ui32_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TRACE_UINT32_, pScopeConsts_, T1_COMBINE_EVENT_INFO( T1_USERDATA_START, info_ ), ui32_ ) # if defined T1_FG_CONT # define T1_TRACE_UINT32_NoSusp__( pScopeConsts_, eventInfo_, ui32_ ) \ ( (void)T1_Dispatch2_( pScopeConsts_, eventInfo_, T1_EMPTY_HANDLER_IDX << 1 ), (void)T1_TraceUint32RestNoSuspFg( pScopeConsts_, ui32_ ) ) # else /* ! defined T1_FG_CONT */ # define T1_TRACE_UINT32_NoSusp__( pScopeConsts_, eventInfo_, ui32_ ) \ ( (void)T1_TraceEventNoSusp__( pScopeConsts_, eventInfo_ ), (void)T1_TraceUint32RestNoSusp( pScopeConsts_, ui32_ ) ) # endif /* defined T1_FG_CONT */ # define T1_TRACE_UINT32_NoSuspRC__( pScopeConsts_, eventInfo_, ui32_ ) \ ( (void)T1_TraceEventNoSusp__( pScopeConsts_, eventInfo_ ), (void)T1_TraceUint32RestNoSuspRC( pScopeConsts_, ui32_ ) ) # if defined T1_SYNC_TIMER_WIDTH_BITS /* Inhibit for library build */ # if T1_SYNC_TIMER_WIDTH_BITS < 28 /* Truncate to correct any subtraction underflow for timer with less than 28 bits. */ # define T1_TRUNC_SYNC_GET( data_ ) ((data_) & (0xFFFFFFFFuL >> (32 - T1_SYNC_TIMER_WIDTH_BITS))) /* Truncate similarly but for values shifted left by 4. */ # define T1_TRUNC_SYNC_DATA( data_ ) ((data_) & (0xFFFFFFFFuL >> (28 - T1_SYNC_TIMER_WIDTH_BITS))) # else /* 28 <= T1_SYNC_TIMER_WIDTH_BITS */ # define T1_TRUNC_SYNC_GET( data_ ) (data_) # define T1_TRUNC_SYNC_DATA( data_ ) (data_) # endif /* T1_SYNC_TIMER_WIDTH_BITS < 28 */ # endif /* defined T1_SYNC_TIMER_WIDTH_BITS */ # define T1_TRACE_SYNC( vrnt_, pScopeConsts_, eventInfo_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TRACE_SYNC_, pScopeConsts_, eventInfo_ ) # if defined T1_SYNC_TIMER_WIDTH_BITS /* Inhibit for library build */ # if T1_ALL_TRACE_TIMERS_ARE_SYNC_TIMER && 28 <= T1_SYNC_TIMER_WIDTH_BITS # define T1_TRACE_TIMER_TO_SYNC_TIMER__( pScopeConsts_, traceTime_ ) \ (traceTime_) # else /* ! T1_ALL_TRACE_TIMERS_ARE_SYNC_TIMER || T1_SYNC_TIMER_WIDTH_BITS < 28 */ # define T1_TRACE_TIMER_TO_SYNC_TIMER__( pScopeConsts_, traceTime_ ) \ T1_TraceToSyncNoSusp__( (pScopeConsts_), (traceTime_) ) # endif /* T1_ALL_TRACE_TIMERS_ARE_SYNC_TIMER && 28 <= T1_SYNC_TIMER_WIDTH_BITS */ # endif /* defined T1_SYNC_TIMER_WIDTH_BITS */ # if defined T1_CONT_REMOTE # define T1_TRACE_SYNC_NoSuspRC__( pScopeConsts_, eventInfo_ ) \ ( \ (void)T1_TraceUint32RestNoSuspRC( (pScopeConsts_), \ T1_TRACE_TIMER_TO_SYNC_TIMER__( \ (pScopeConsts_), \ T1_TraceEventNoSusp__( (pScopeConsts_), \ (eventInfo_) ) ) ) \ ) # elif defined T1_FG_CONT # define T1_TRACE_SYNC_NoSusp__( pScopeConsts_, eventInfo_ ) \ ( \ (void)T1_TraceUint32RestNoSuspFg( (pScopeConsts_), \ T1_TRACE_TIMER_TO_SYNC_TIMER__( \ (pScopeConsts_), \ T1_TraceEventNoSusp__( (pScopeConsts_), \ (eventInfo_) ) ) ) \ ) # else # define T1_TRACE_SYNC_NoSusp__( pScopeConsts_, eventInfo_ ) \ ( \ (void)T1_TraceUint32RestNoSusp( (pScopeConsts_), \ T1_TRACE_TIMER_TO_SYNC_TIMER__( \ (pScopeConsts_), \ T1_TraceEventNoSusp__( (pScopeConsts_), \ (eventInfo_) ) ) ) \ ) # endif # define T1_TRACE_SYNC_SW( vrnt_, pScopeConsts_, eventInfo_, startData_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_SWStop, pScopeConsts_, eventInfo_, startData_ ) # define T1_TRACE_SYNC_SW_( vrnt_, pScopeConsts_, eventInfo_, startData_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_SWStop, pScopeConsts_, startData_, T1_TraceEventNoSuspTime__( (pScopeConsts_), (eventInfo_), (now_) ) ) # define T1_TRACEDATA( vrnt_, info_, pData_, len_ ) \ ( (void)T1_TraceData##vrnt_( T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), \ T1_COMBINE_EVENT_INFO( T1_USERDATA_START, info_ ), \ (pData_), \ (len_) ) ) # define T1_TRACEDATA_PC( vrnt_, coreId_, info_, pData_, len_ ) \ ( (void)T1_TraceData##vrnt_( T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), \ T1_COMBINE_EVENT_INFO( T1_USERDATA_START, info_ ), \ (pData_), \ (len_) ) ) # define T1_TRACEDATA_NOSUSPTIME( info_, pData_, len_, time_ ) \ ( (void)T1_TraceDataNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), \ T1_COMBINE_EVENT_INFO( T1_USERDATA_START, info_ ), \ (pData_), \ (len_), \ (time_) ) ) # define T1_TRACEDATA_NOSUSPTIME_PC( coreId_, info_, pData_, len_, time_ ) \ ( (void)T1_TraceDataNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), \ T1_COMBINE_EVENT_INFO( T1_USERDATA_START, info_ ), \ (pData_), \ (len_), \ (time_) ) ) # define T1_OH_SW (0x2FFu) # define T1_CONT_UPDATE_OH (0x3FCu) # if defined T1_SYNC_TIMER_WIDTH_BITS /* Inhibit for library build */ # if defined T1_TRACE_ACT_EVENT_AND_CROSS_CORE_ACT # define T1_TRACE_ACT_PC_NoSusp__( pScopeConsts_, ei_, offset_ ) \ ( (T1_TRACE_TIMER_TO_SYNC_TIMER__( (pScopeConsts_), T1_NearTraceEventNoSusp__( (pScopeConsts_), (ei_) ) ) << 4) - (offset_) ) # elif 28 <= T1_SYNC_TIMER_WIDTH_BITS /* Just read sync timer */ # define T1_TRACE_ACT_PC_NoSusp__( pScopeConsts_, ei_, offset_ ) \ ( (T1_GET_SYNC_TIME( ) << 4) - (offset_) ) # else /* Add high bits from synthesized sync timer */ # define T1_TRACE_ACT_PC_NoSusp__( pScopeConsts_, ei_, offset_ ) \ ( (((pScopeConsts_)->syncTime + T1_TRUNC_SYNC_GET(T1_GET_SYNC_TIME( ) - (pScopeConsts_)->syncTime)) << 4) - (offset_) ) # endif /* T1_TRACE_ACT_EVENT_AND_CROSS_CORE_ACT */ # define T1_TRACE_ACT_PC_NoSuspRC__( pScopeConsts_, ei_, offset_ ) \ ( T1_TRACE_ACT_PC_NoSusp__( (pScopeConsts_), (ei_), (offset_) ) ) # endif /* defined T1_SYNC_TIMER_WIDTH_BITS */ # if ! defined T1_DISABLE_T1_CONT && defined T1_FG_CONT # define T1_TRACE_START_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStart, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_) ) # define T1_TRACE_START_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStart, coreId_, (taskId_), (now_) ) # define T1_TRACE_STOP_START_PC( vrnt_, coreId_, startTaskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStopStart, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (startTaskId_) ) # define T1_TRACE_STOP_START_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStopStart, coreId_, (taskId_), (now_) ) # define T1_TRACE_START_NOACT_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStartNoAct, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_) ) # define T1_TRACE_START_NOACT_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStartNoAct, coreId_, (taskId_), (now_) ) # define T1_TRACE_STOP_START_NOACT_PC( vrnt_, coreId_, startTaskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStopStartNoAct, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (startTaskId_) ) # define T1_TRACE_STOP_START_NOACT_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStopStartNoAct, coreId_, (taskId_), (now_) ) # define T1_TRACE_STOP_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStop, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_) ) # define T1_TRACE_STOP_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStop, coreId_ , (taskId_), (now_) ) # define T1_TRACE_ACT_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskAct, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_) ) # define T1_TRACE_START_ACT_PC( vrnt_, coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStartAct, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_), ((actTime_) << 4) - (actCoreId_) - 1 ) # define T1_TRACE_START_ACT_PC_( vrnt_, coreId_, taskId_, actCoreId_, actTime_, now_ ) \ T1_TRACE_ATOMIC___( vrnt_, T1_TaskStartAct, coreId_, (taskId_), ((actTime_) << 4) - (actCoreId_) - 1, (now_) ) # define T1_TRACE_STOP_START_ACT_PC( vrnt_, coreId_, startTaskId_, actCoreId_, actTime_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TaskStopStartAct, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (startTaskId_), ((actTime_) << 4) - (actCoreId_) - 1 ) # define T1_TRACE_STOP_START_ACT_PC_( vrnt_, coreId_, startTaskId_, actCoreId_, actTime_, now_ ) \ T1_TRACE_ATOMIC___( vrnt_, T1_TaskStopStartAct, coreId_, (startTaskId_), ((actTime_) << 4) - (actCoreId_) - 1, (now_) ) # define T1_TRACE_START_STOP_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStartStop, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_) ) # define T1_TRACE_START_STOP_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TaskStartStop, coreId_, (taskId_), (now_) ) # define T1_TaskStartNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_START_HANDLER_IDX << 1 ) # define T1_TaskStartNoSuspTime__( coreId_, taskId_, now_ ) \ T1_DISPATCH_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_START_HANDLER_IDX << 1 ) # define T1_TaskStartNoActNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_START_NOACT_HANDLER_IDX << 1 ) # define T1_TaskStartNoActNoSuspTime__( coreId_, taskId_, now_ ) \ T1_DISPATCH_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_START_NOACT_HANDLER_IDX << 1 ) # define T1_TaskStopNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_STOP_HANDLER_IDX << 1 ) # define T1_TaskStopNoSuspTime__( coreId_, taskId_, now_ ) \ T1_DISPATCH_STOP_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_STOP_HANDLER_IDX << 1 ) # define T1_TaskStopStartNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_STOP_START_HANDLER_IDX << 1 ) # define T1_TaskStopStartNoSuspTime__( coreId_, taskId_, now_ ) \ T1_DISPATCH_STOP_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_STOP_START_HANDLER_IDX << 1 ) # define T1_TaskStopStartNoActNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_STOP_START_NOACT_HANDLER_IDX << 1 ) # define T1_TaskStopStartNoActNoSuspTime__( coreId_, taskId_, now_ ) \ T1_DISPATCH_STOP_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_STOP_START_NOACT_HANDLER_IDX << 1 ) # define T1_TaskActNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_ACTIVATION_HANDLER_IDX << 1 ) # define T1_TaskStartActNoSusp__( pScopeConsts_, taskId_, actData_ ) \ ( T1_taskFgData[taskId_].act.data = (actData_), T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_START_HANDLER_IDX << 1 ) ) # define T1_TaskStartActNoSuspTime__( coreId_, taskId_, actData_, now_ ) \ ( T1_taskFgData[taskId_].act.data = (actData_), T1_DISPATCH_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_START_HANDLER_IDX << 1 ) ) # define T1_TaskStopStartActNoSusp__( pScopeConsts_, taskId_, actData_ ) \ ( T1_taskFgData[taskId_].act.data = (actData_), T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_STOP_START_HANDLER_IDX << 1 ) ) # define T1_TaskStopStartActNoSuspTime__( coreId_, taskId_, actData_, now_ ) \ ( T1_taskFgData[taskId_].act.data = (actData_), T1_DISPATCH_STOP_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_STOP_START_HANDLER_IDX << 1 ) ) # define T1_TaskStartStopNoSusp__( pScopeConsts_, taskId_ ) \ T1_Dispatch2_( (pScopeConsts_), (taskId_), T1_START_STOP_HANDLER_IDX << 1 ) # define T1_TaskStartStopNoSuspTime__( pScopeConsts_, taskId_, now_ ) \ T1_DISPATCH_ ## coreId_( T1_CORE_ID_TO_SCOPE_FG_CONSTS( coreId_ ), (taskId_), (now_), T1_START_STOP_HANDLER_IDX << 1 ) # if defined __GNUC__ /* Avoid double expansion of pScopeConsts_ */ /* polyspace The cast is intentional */ # define T1_Dispatch2_( pScopeConsts_, eventInfo_, handlerIdx_ ) \ ({ \ T1_scopeConsts_t * const pScopeConsts__ = (pScopeConsts_); \ pScopeConsts__->_.pScopeFgGlobals->pDispatcher( (T1_scopeFgConsts_t *)pScopeConsts__, (eventInfo_), (handlerIdx_) ); \ }) # else /* ! defined __GNUC__ unavoidable double expansion of pScopeConsts_ */ /* polyspace The cast is intentional */ # define T1_Dispatch2_( pScopeConsts_, eventInfo_, handlerIdx_ ) \ ( (pScopeConsts_)->_.pScopeFgGlobals->pDispatcher( (T1_scopeFgConsts_t *)(pScopeConsts_), (eventInfo_), (handlerIdx_) ) ) # endif /* defined __GNUC__ */ # else /* defined T1_DISABLE_T1_CONT || ! defined T1_FG_CONT */ # if defined T1_CROSS_CORE_ACT && 1 < T1_NOF_CORES # define T1_TRACE_START_PC( vrnt_, coreId_, taskId_ ) \ do \ { \ T1_uint8Least_t const coreId__ = (coreId_); \ (void)coreId__; /* Avoid compiler warnings if coreId is not used. */ \ if( ((taskId_) < T1_MAX_NOF_TASKS) && T1_NEEDS_IPT(coreId__, (taskId_)) ) \ { \ T1_scopeConsts_t * const pScopeConsts__ = T1_CORE_ID_TO_SCOPE_CONSTS( coreId__ ); \ T1_INCR_PREEMPTIONS_PC( coreId__, \ T1_TRACE_SYNC_SW( vrnt_, \ pScopeConsts__, \ T1_COMBINE_EVENT_INFO( T1_START_IPT_START, \ (taskId_) ), \ T1_taskAct[taskId_] ) \ ); \ T1_taskAct[taskId_] = 0uL; \ } \ else \ { \ T1_TRACE_START_NOACT_PC( vrnt_, coreId__, (taskId_) ); \ } \ } \ while( 0 ) # define T1_TRACE_START_PC_( vrnt_, coreId_, taskId_, now_ ) \ do \ { \ T1_uint8Least_t const coreId__ = (coreId_); \ (void)coreId__; /* Avoid compiler warnings if coreId is not used. */ \ if( ((taskId_) < T1_MAX_NOF_TASKS) && T1_NEEDS_IPT(coreId__, (taskId_)) ) \ { \ T1_scopeConsts_t * const pScopeConsts__ = T1_CORE_ID_TO_SCOPE_CONSTS( coreId__ ); \ T1_INCR_PREEMPTIONS_PC( coreId__, \ T1_TRACE_SYNC_SW_( vrnt_, \ pScopeConsts__, \ T1_COMBINE_EVENT_INFO( T1_START_IPT_START, \ (taskId_) ), \ T1_taskAct[taskId_], (now_) ) \ ); \ T1_taskAct[taskId_] = 0uL; \ } \ else \ { \ T1_TRACE_START_NOACT_PC( vrnt_, coreId__, (taskId_) ); \ } \ } \ while( 0 ) # define T1_TRACE_STOP_START_PC( vrnt_, coreId_, startTaskId_ ) \ do \ { \ T1_uint8Least_t const coreId__ = (coreId_); \ (void)coreId__; /* Avoid compiler warnings if coreId is not used. */ \ if( ((startTaskId_) < T1_MAX_NOF_TASKS) && T1_NEEDS_IPT(coreId__, (startTaskId_)) ) \ { \ T1_scopeConsts_t * const pScopeConsts__ = T1_CORE_ID_TO_SCOPE_CONSTS( coreId__ ); \ T1_TRACE_SYNC_SW( vrnt_, \ pScopeConsts__, \ T1_COMBINE_EVENT_INFO( T1_STOP_START_IPT_START, \ (startTaskId_) ), \ T1_taskAct[startTaskId_] ); \ T1_taskAct[startTaskId_] = 0uL; \ } \ else \ { \ T1_TRACE_STOP_START_NOACT_PC( vrnt_, coreId__, (startTaskId_) ); \ } \ } \ while( 0 ) # define T1_TRACE_STOP_START_PC_( vrnt_, coreId_, startTaskId_, now_ ) \ do \ { \ T1_uint8Least_t const coreId__ = (coreId_); \ (void)coreId__; /* Avoid compiler warnings if coreId is not used. */ \ if( ((startTaskId_) < T1_MAX_NOF_TASKS) && T1_NEEDS_IPT(coreId__, (startTaskId_)) ) \ { \ T1_scopeConsts_t * const pScopeConsts__ = T1_CORE_ID_TO_SCOPE_CONSTS( coreId__ ); \ T1_TRACE_SYNC_SW( vrnt_, \ pScopeConsts__, \ T1_COMBINE_EVENT_INFO( T1_STOP_START_IPT_START, \ (startTaskId_) ), \ T1_taskAct[startTaskId_], (now_) ); \ T1_taskAct[startTaskId_] = 0uL; \ } \ else \ { \ T1_TRACE_STOP_START_NOACT_PC( vrnt_, coreId__, (startTaskId_) ); \ } \ } \ while( 0 ) # define T1_TRACE_ACT_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC__( vrnt_, \ T1_taskAct[(taskId_) < T1_MAX_NOF_TASKS ? (taskId_) : T1_MAX_NOF_TASKS] = T1_TRACE_ACT_PC_, \ T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), \ T1_COMBINE_EVENT_INFO( T1_ACTIVATION, (taskId_) ), \ (coreId_) + 1 ) # else /* not logging cross-core activations */ # define T1_TRACE_START_PC( vrnt_, coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START, (taskId_) ) ) ) # define T1_TRACE_START_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START, (taskId_) ), (now_) ) ) # define T1_TRACE_STOP_START_PC( vrnt_, coreId_, startTaskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START, (startTaskId_) ) ) # define T1_TRACE_STOP_START_PC_( vrnt_, coreId_, startTaskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START, (startTaskId_) ), (now_) ) # define T1_TRACE_ACT_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_ACTIVATION, (taskId_) ) ) # endif /* defined T1_CROSS_CORE_ACT && 1 < T1_NOF_CORES */ # define T1_TRACE_START_NOACT_PC( vrnt_, coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START, (taskId_) ) ) ) # define T1_TRACE_START_NOACT_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START, (taskId_) ), (now_) ) ) # define T1_TRACE_STOP_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP, (taskId_) ) ) # define T1_TRACE_STOP_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP, (taskId_) ), (now_) ) # define T1_TRACE_STOP_START_NOACT_PC( vrnt_, coreId_, startTaskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START, (startTaskId_) ) ) # define T1_TRACE_STOP_START_NOACT_PC_( vrnt_, coreId_, startTaskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START, (startTaskId_) ), (now_) ) # define T1_TRACE_START_ACT_PC( vrnt_, coreId_, taskId_, actCoreId_, actTime_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_SYNC_SW( vrnt_, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START_IPT_START, (taskId_) ), ((actTime_) << 4) - (actCoreId_) ) ) # define T1_TRACE_START_ACT_PC_( vrnt_, coreId_, taskId_, actCoreId_, actTime_, now_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_SYNC_SW_( vrnt_, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START_IPT_START, (taskId_) ), ((actTime_) << 4) - (actCoreId_), (now_) ) ) # define T1_TRACE_STOP_START_ACT_PC( vrnt_, coreId_, startTaskId_, actCoreId_, actTime_ ) \ T1_TRACE_SYNC_SW( vrnt_, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START_IPT_START, (startTaskId_) ), ((actTime_) << 4) - (actCoreId_) ) # define T1_TRACE_STOP_START_ACT_PC_( vrnt_, coreId_, startTaskId_, actCoreId_, actTime_, now_ ) \ T1_TRACE_SYNC_SW_( vrnt_, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_STOP_START_IPT_START, (startTaskId_) ), ((actTime_) << 4) - (actCoreId_), (now_) ) # define T1_TRACE_START_STOP_PC( vrnt_, coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START_STOP, (taskId_) ) ) # define T1_TRACE_START_STOP_PC_( vrnt_, coreId_, taskId_, now_ ) \ T1_TRACE_ATOMIC__( vrnt_, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( T1_START_STOP, (taskId_) ), (now_) ) # if defined T1_TRACE_ACT_EVENT_AND_CROSS_CORE_ACT # define T1_NEEDS_IPT( coreId_, taskId_ ) \ ( (0u != T1_taskAct[taskId_]) && (0u != ((~(coreId_) ^ T1_taskAct[taskId_]) & 0xFuL)) ) # else # define T1_NEEDS_IPT( coreId_, taskId_ ) ( 0u != T1_taskAct[taskId_] ) # endif /* T1_TRACE_ACT_EVENT_AND_CROSS_CORE_ACT */ # endif /* ! defined T1_DISABLE_T1_CONT && defined T1_FG_CONT */ # define T1_P_SCOPE_FG_CONSTS0 (&T1_scopeFgConsts0) # define T1_P_SCOPE_FG_CONSTS1 (&T1_scopeFgConsts1) # define T1_P_SCOPE_FG_CONSTS2 (&T1_scopeFgConsts2) # define T1_P_SCOPE_FG_CONSTS3 (&T1_scopeFgConsts3) # define T1_P_SCOPE_FG_CONSTS4 (&T1_scopeFgConsts4) # define T1_P_SCOPE_FG_CONSTS5 (&T1_scopeFgConsts5) # define T1_P_SCOPE_FG_CONSTS6 (&T1_scopeFgConsts6) # define T1_P_SCOPE_FG_CONSTS7 (&T1_scopeFgConsts7) # define T1_P_SCOPE_FG_CONSTS8 (&T1_scopeFgConsts8) # define T1_P_SCOPE_FG_CONSTS9 (&T1_scopeFgConsts9) # define T1_P_SCOPE_FG_CONSTS10 (&T1_scopeFgConsts10) # define T1_P_SCOPE_FG_CONSTS11 (&T1_scopeFgConsts11) # define T1_P_SCOPE_FG_CONSTS12 (&T1_scopeFgConsts12) # define T1_P_SCOPE_FG_CONSTS13 (&T1_scopeFgConsts13) # define T1_P_SCOPE_FG_CONSTS14 (&T1_scopeFgConsts14) # if ! defined T1_FG_CONT || defined T1_DISABLE_T1_CONT # define T1_P_SCOPE_CONSTS0 (&T1_scopeConsts0) # define T1_P_SCOPE_CONSTS1 (&T1_scopeConsts1) # define T1_P_SCOPE_CONSTS2 (&T1_scopeConsts2) # define T1_P_SCOPE_CONSTS3 (&T1_scopeConsts3) # define T1_P_SCOPE_CONSTS4 (&T1_scopeConsts4) # define T1_P_SCOPE_CONSTS5 (&T1_scopeConsts5) # define T1_P_SCOPE_CONSTS6 (&T1_scopeConsts6) # define T1_P_SCOPE_CONSTS7 (&T1_scopeConsts7) # define T1_P_SCOPE_CONSTS8 (&T1_scopeConsts8) # define T1_P_SCOPE_CONSTS9 (&T1_scopeConsts9) # define T1_P_SCOPE_CONSTS10 (&T1_scopeConsts10) # define T1_P_SCOPE_CONSTS11 (&T1_scopeConsts11) # define T1_P_SCOPE_CONSTS12 (&T1_scopeConsts12) # define T1_P_SCOPE_CONSTS13 (&T1_scopeConsts13) # define T1_P_SCOPE_CONSTS14 (&T1_scopeConsts14) # else /* defined T1_FG_CONT && ! defined T1_DISABLE_T1_CONT */ # define T1_P_SCOPE_CONSTS0 (&T1_scopeFgConsts0._) # define T1_P_SCOPE_CONSTS1 (&T1_scopeFgConsts1._) # define T1_P_SCOPE_CONSTS2 (&T1_scopeFgConsts2._) # define T1_P_SCOPE_CONSTS3 (&T1_scopeFgConsts3._) # define T1_P_SCOPE_CONSTS4 (&T1_scopeFgConsts4._) # define T1_P_SCOPE_CONSTS5 (&T1_scopeFgConsts5._) # define T1_P_SCOPE_CONSTS6 (&T1_scopeFgConsts6._) # define T1_P_SCOPE_CONSTS7 (&T1_scopeFgConsts7._) # define T1_P_SCOPE_CONSTS8 (&T1_scopeFgConsts8._) # define T1_P_SCOPE_CONSTS9 (&T1_scopeFgConsts9._) # define T1_P_SCOPE_CONSTS10 (&T1_scopeFgConsts10._) # define T1_P_SCOPE_CONSTS11 (&T1_scopeFgConsts11._) # define T1_P_SCOPE_CONSTS12 (&T1_scopeFgConsts12._) # define T1_P_SCOPE_CONSTS13 (&T1_scopeFgConsts13._) # define T1_P_SCOPE_CONSTS14 (&T1_scopeFgConsts14._) # endif /* ! defined T1_FG_CONT || defined T1_DISABLE_T1_CONT */ /*! \brief T1.scope entry in plugin table. */ # define T1_scopePlugin (&T1_scopePluginStruct) # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_DeclarePlugin( T1_scopePluginStruct ); # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" # define T1_START_SEC_VAR_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_bakery_t T1_SEC_VAR_CLEARED_32 T1_calibrationSemPC[]; # define T1_STOP_SEC_VAR_CLEARED_32 # include "T1_MemMap.h" # if defined T1_CROSS_CORE_ACT && 1 < T1_NOF_CORES # define T1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_uint32_t T1_SEC_VAR_POWER_ON_CLEARED_32 T1_taskAct[]; # define T1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* defined T1_CROSS_CORE_ACT */ # define T1_START_SEC_CODE # include "T1_MemMap.h" # if defined T1_CROSS_CORE_ACT && 1 < T1_NOF_CORES T1_EXTERN void T1_CODE T1_InitTaskAct( void ); # else /* not logging cross-core activations */ # define T1_InitTaskAct( ) (void)0 # endif /* defined T1_CROSS_CORE_ACT && 1 < T1_NOF_CORES */ /*! * Re-initialize T1.scope for CERT version of the T1-TARGET-SW. In other versions this * has no effect. This can be used to re-start tracing after a trigger. Use only when * the T1-HOST-SW is not connected. * See \ref PC. */ T1_EXTERN void T1_CODE T1_InitTraceBufferPC( T1_uint8Least_t coreId ); /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param[in] coreId the T1 logical ID of the calling core * \param[in] afterXevents halt tracing only after this number of further events * \returns #T1_NOFUNC if the trigger has already been set */ T1_EXTERN T1_status_t T1_CODE T1_SetStopTriggerPC( T1_uint8Least_t coreId, T1_nofEntries_t afterXevents ); /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param[in] coreId the T1 logical ID of the calling core * \param[in] afterXevents halt tracing only after this number of further events * \returns #T1_NOFUNC if the trigger has already been set */ T1_EXTERN T1_status_t T1_CODE T1_SetStopTriggerNoSuspPC( T1_uint8Least_t coreId, T1_nofEntries_t afterXevents ); /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param[in] afterXevents_ halt tracing only after this number of further events * \returns #T1_NOFUNC if the trigger has already been set */ # define T1_SetStopTrigger( afterXevents_ ) T1_SetStopTriggerPC( T1_GetCoreIdOffset( ), afterXevents_ ) /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param[in] afterXevents_ halt tracing only after this number of further events * \returns #T1_NOFUNC if the trigger has already been set */ # define T1_SetStopTriggerNoSusp( afterXevents_ ) T1_SetStopTriggerNoSuspPC( T1_GetCoreIdOffset( ), afterXevents_ ) # define T1_InitTraceBuffer( ) T1_InitTraceBufferPC( T1_GetCoreIdOffset( ) ) /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param afterXevents_ Halt tracing only after this number of further events. */ # define T1_SetStopTriggerFast( afterXevents_ ) T1_SetStopTrigger( afterXevents_ ) /*! * Insert T1_TRIGGER event to mark interesting trace data. * Unless already streaming, halt tracing for download and analysis by the T1-HOST-SW. * See \ref PC, \ref INTRPT and \ref USER_TRIGGERS. * \param coreId_ the T1 logical ID of the calling core * \param afterXevents_ Halt tracing only after this number of further events. */ # define T1_SetStopTriggerFastPC( coreId_, afterXevents_ ) T1_SetStopTriggerPC( coreId_, afterXevents_ ) T1_EXTERN T1_uint8Least_t T1_CODE T1_TraceData_( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8_t const *pData, T1_uint8Least_t length ); T1_EXTERN T1_uint8Least_t T1_CODE T1_TraceDataNoSusp_( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8_t const *pData, T1_uint8Least_t length ); T1_EXTERN T1_uint8Least_t T1_CODE T1_TraceDataNoSuspTime_( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8_t const *pData, T1_uint8Least_t length, T1_tickUint_t now ); # define T1_TraceDataRC_ T1_TraceData_ # define T1_TraceDataNoSuspRC_ T1_TraceDataNoSusp_ T1_EXTERN T1_uint32_t T1_CODE T1_16toU32( T1_uint16_t data16 ); T1_EXTERN void T1_CODE T1_ScopeOverheadSequenceNoSuspPC( T1_uint8Least_t coreId ); /*! * Trace the dynamic re-naming of a task. * See \ref PC and \ref INTRPT. * \param coreId_ the T1 logical ID of the calling core * \param now_ the trace time * \param taskId_ the T1.scope task ID */ # define T1_TraceNameNoSuspTimePC( coreId_, now_, taskId_ ) \ ( T1_TraceNameNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_), (now_) ) ) # define T1_TraceNameNoSuspTime( now_, taskId_ ) \ ( T1_TraceNameNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), (taskId_), (now_) ) ) T1_EXTERN T1_uint8Least_t T1_CODE T1_TraceNameNoSuspTime_( T1_scopeConsts_t *pScopeConsts, T1_taskId_t taskId, T1_tickUint_t now ); /*! * Trace the dynamic re-initialising of OS-specific IDs. * See \ref PC and \ref INTRPT. * \param coreId_ the T1 logical ID of the calling core * \param now_ the trace time * \param taskId_ the T1.scope task ID */ # define T1_TraceOsIdsNoSuspTimePC( coreId_, now_, taskId_ ) \ ( T1_TraceOsIdsNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (taskId_), (now_) ) ) # define T1_TraceOsIdsNoSuspTime( now_, taskId_ ) \ ( T1_TraceOsIdsNoSuspTime_( T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), (taskId_), (now_) ) ) T1_EXTERN T1_uint8Least_t T1_CODE T1_TraceOsIdsNoSuspTime_( T1_scopeConsts_t *pScopeConsts, T1_taskId_t taskId, T1_tickUint_t now ); /* * The following functions, by default, map to their equivalent without 'UM'. They * are called from T1_Handler and T1_ContBgHandler, which (can) run in user mode and * they can be overridden in the event that calling T1_TraceEvent in user mode is not * permitted. We know of one case where the trace timer cannot be accessed in user * mode, for example. In this case, these functions can be re-implemented using * CallTrustedFunction, or some equivalent, to call T1_TraceEvent in supervisor mode. * This should only be done with support from GLIWA. */ /*! * \brief Callout to execute T1_ScopeOverheadSequenceNoSuspPC() from T1_HandlerPC(). * \param[in] coreId the T1 logical core ID of the calling core * * Call T1_ScopeOverheadSequenceNoSuspPC() in supervisor mode. * * \par Default Implementation * The default implementation assumes that T1_HandlerPC() runs in supervisor mode already. * * \note T1_ScopeOverheadSequenceNoSuspPC() reads the trace timer which might not be * safe from user-mode. * */ T1_EXTERN void T1_CODE T1_ScopeOverheadSequenceUMPC( T1_uint8Least_t coreId ); /*! * \brief Callout to insert one event in the trace buffer without assuming supervisor privileges. * \param[in] coreId the T1 logical core ID of the calling core * \param[in] eventInfo combined event ID and info field created by * T1_COMBINE_EVENT_INFO() * \returns all counting bits of the time-stamp * * This is used as a callout from library code and should not normally be called * directly from user code. * * \par Default Implementation * The default implementation uses T1.flex to insert the event into the trace buffer, * if T1.flex is available. It will call T1_TraceEventNoSuspUMPC() with interrupts * disabled if T1.flex is not available. * */ T1_EXTERN void T1_CODE T1_TraceEventUMPC( T1_uint8Least_t coreId, T1_eventInfo_t eventInfo ); /*! * \brief Callout to insert one event in the trace buffer without assuming that * interrupts are disabled without assuming supervisor privileges. * \param[in] coreId the T1 logical core ID of the calling core * \param[in] eventInfo combined event ID and info field created by * T1_COMBINE_EVENT_INFO() * \returns all counting bits of the time-stamp * * This is used as a callout from library code and should not normally be called * directly from user code. * */ T1_EXTERN T1_tickUint_t T1_CODE T1_TraceEventNoSuspUMPC( T1_uint8Least_t coreId, T1_eventInfo_t eventInfo ); /* For testing only. */ T1_EXTERN void T1_CODE T1_TraceScopeUploadNoSuspTime__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); # define T1_STOP_SEC_CODE # include "T1_MemMap.h" # define T1_START_SEC_CONST_8 # include "T1_MemMap.h" T1_EXTERN const T1_uint8_t T1_SEC_CONST_8 T1_syncTimerWidthBits; # define T1_STOP_SEC_CONST_8 # include "T1_MemMap.h" # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN const T1_uint32_t T1_SEC_CONST_32 T1_scopeRevision; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" /*! * Number of events stored in the core specific trace buffer, see \ref PC. * \param coreId_ the T1 logical ID of the calling core */ # define T1_TRACE_BUFFER_ENTRIES_PC( coreId_ ) ( T1_scopeConstsPC[(coreId_)]->bufferEntries ) # define T1_BUFFER_SIZE_PC( coreId_ ) ( T1_TRACE_BUFFER_ENTRIES_PC( coreId_ ) ) # define T1_BUFFER_SIZE( ) ( T1_BUFFER_SIZE_PC( T1_GetCoreIdOffset( ) ) ) # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FARPTR const T1_SEC_CONST_32 T1_traceBufferPC[]; T1_EXTERN const T1_traceIndirect_t T1_SEC_CONST_32 T1_traceIndirect; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" # define T1_TRACEBUFFER_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer[]; # define T1_TRACEBUFFER_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # define T1_START_SEC_CODE_FAST # include "T1_MemMap.h" /*! * \brief Callout to insert one event in the trace buffer assuming that interrupts are disabled. * * This is not part of the T1-TARGET-SW API. Do **NOT** call it directly from user * code. It is called from the T1.scope API macro layer, see T1_TraceEventNoSuspPC(), * for * example. * This is one of the most time-critical routines in the T1-TARGET-SW. In addition to * requiring efficient code, the following additional restrictions apply: * - Processors with floating point and/or MAC registers are not permitted to use them * - RH850 projects using `-no_check_rh850_abi_flags` with the *22* libraries * are not permitted to use *R2* and *R15-R24*. * * \note This code should only be changed under advice from a GLIWA engineer. * */ T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_NOINLINE T1_CODE_OPT T1_TraceEventNoSusp__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_NOINLINE T1_CODE_OPT T1_TraceEventNoSuspTime__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_NOINLINE T1_CODE_OPT T1_TraceEventNoSuspTimeRC__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); # if defined T1_NEAR_CODE_FAST T1_EXTERN T1_tickUint_t T1_NOINLINE T1_NEAR_CODE_FAST T1_NearTraceEventNoSusp__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo ); T1_EXTERN T1_tickUint_t T1_NOINLINE T1_NEAR_CODE_FAST T1_NearTraceEventNoSuspTime__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); T1_EXTERN T1_tickUint_t T1_NOINLINE T1_NEAR_CODE_FAST T1_NearTraceEventNoSuspTimeRC__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); T1_EXTERN void T1_NOINLINE T1_NEAR_CODE_FAST T1_CODE_OPT T1_NearSWStopNoSusp__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t syncData ); T1_EXTERN T1_tickUint_t T1_NEAR_CODE_FAST T1_CODE_OPT T1_NearTraceUint32RestNoSusp( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); T1_EXTERN T1_tickUint_t T1_NEAR_CODE_FAST T1_CODE_OPT T1_NearTraceUint32RestNoSuspRC( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); T1_EXTERN T1_tickUint_t T1_NEAR_CODE_FAST T1_CODE_OPT T1_NearTraceUint32RestNoSuspFg( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); # else # define T1_NearTraceEventNoSusp__ T1_TraceEventNoSusp__ # define T1_NearTraceEventNoSuspTime__ T1_TraceEventNoSuspTime__ # define T1_NearTraceEventNoSuspTimeRC__ T1_TraceEventNoSuspTimeRC__ # define T1_NearSWStopNoSusp__ T1_SWStopNoSusp__ # define T1_NearTraceUint32RestNoSusp T1_TraceUint32RestNoSusp # define T1_NearTraceUint32RestNoSuspRC T1_TraceUint32RestNoSuspRC # define T1_NearTraceUint32RestNoSuspFg T1_TraceUint32RestNoSuspFg # endif /* defined T1_NEAR_CODE_FAST */ # define T1_SWStopNoSuspRC__ T1_SWStopNoSusp__ # define T1_SWStopNoSuspTimeRC__ T1_SWStopNoSuspTime__ T1_EXTERN T1_CODE_FAST( void ) T1_NOINLINE T1_CODE_OPT T1_SWStopNoSusp__( T1_scopeConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t syncData ); T1_EXTERN T1_CODE_FAST( void ) T1_NOINLINE T1_CODE_OPT T1_SWStopNoSuspTime__( T1_scopeConsts_t *pScopeConsts, T1_uint32_t syncData, T1_tickUint_t traceTime ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_CODE_OPT T1_TraceUint32RestNoSusp( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_CODE_OPT T1_TraceUint32RestNoSuspRC( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_CODE_OPT T1_TraceUint32RestNoSuspFg( T1_scopeConsts_t *pScopeConsts, T1_uint32_t data ); T1_EXTERN T1_CODE_FAST( T1_uint32_t ) T1_CODE_OPT T1_TraceToSyncNoSusp__( T1_scopeConsts_t *pScopeConsts, T1_tickUint_t traceTime ); # define T1_STOP_SEC_CODE_FAST # include "T1_MemMap.h" /* Foreground T1.cont dispatchers without and with event chain support. */ # if 1 == T1_NOF_CORES || (defined T1_GET_RAW_TIME && defined T1_RAW_TO_TRACE_TIME) # define T1_START_SEC_CODE_FAST # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch0( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_STOP_SEC_CODE_FAST # include "T1_MemMap.h" # else /* 1 != T1_NOF_CORES && (! defined T1_GET_RAW_TIME || ! defined T1_RAW_TO_TRACE_TIME) */ # define T1_CORE0_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch0( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE0_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 1 == T1_NOF_CORES || (defined T1_GET_RAW_TIME && defined T1_RAW_TO_TRACE_TIME) */ # if 1 < T1_NOF_CORES # define T1_CORE1_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch1( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE1_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_CORE2_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch2( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE2_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_CORE3_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch3( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE3_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_CORE4_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch4( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE4_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_CORE5_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch5( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE5_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_CORE6_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch6( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE6_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_CORE7_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch7( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE7_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_CORE8_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch8( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE8_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_CORE9_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch9( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE9_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_CORE10_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch10( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE10_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_CORE11_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch11( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE11_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_CORE12_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch12( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE12_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_CORE13_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch13( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE13_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_CORE14_START_SEC_CODE # include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_Dispatch14( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx ); # define T1_CORE14_STOP_SEC_CODE # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_START_SEC_CODE # include "T1_MemMap.h" T1_tickUint_t T1_CODE T1_DispatchTimePC( T1_uint8Least_t coreId, T1_eventInfo_t eventInfo, T1_uint8Least_t handlerIdx, T1_tickUint_t now ); # define T1_STOP_SEC_CODE # include "T1_MemMap.h" /*! * \def T1_TraceActivation * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceActivationPC * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceActivationFast * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceActivationFastPC * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceActivationNoSusp * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceActivationNoSuspPC * Call at task activation. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of activated task * \def T1_TraceStart * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartPC * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See * \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartFast * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartFastPC * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See * \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoSusp * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoSuspPC * Call at task/ISR start. See also T1_TraceStartNoAct(), especially for ISRs. See * \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoAct * Call at task/ISR start for which there is no activation event. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActPC * Call at task/ISR start for which there is no activation event. See \ref PC and \ref * INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActFast * Call at task/ISR start for which there is no activation event. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActFastPC * Call at task/ISR start for which there is no activation event. See \ref PC and \ref * INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActNoSusp * Call at task/ISR start for which there is no activation event. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActNoSuspPC * Call at task/ISR start for which there is no activation event. See \ref PC and \ref * INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartNoActNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStartAct * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActPC * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActFast * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActFastPC * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActNoSusp * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActNoSuspPC * Call at task/ISR start for which there is no activation event but the activation * time is somehow derived without reference to T1_taskAct. The most common example is * a timer ISR where the activation time can be derived from the old compare value. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartActNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of starting task * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStop * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopPC * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopFast * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopFastPC * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopNoSusp * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopNoSuspPC * Call at task/ISR stop. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of stopping task * \def T1_TraceStopStart * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartPC * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartFast * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartFastPC * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartNoSusp * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartNoSuspPC * Call at the context switch from a stopping task to a newly activated starting task. * It is important to use this in preference to having two separate events, where possible. * See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task * \def T1_TraceStopStartNoAct * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActPC * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActFast * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActFastPC * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActNoSusp * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActNoSuspPC * Call at the context switch from a stopping task to a newly starting task for which * there is no activation event. It is important to use this in preference to having * two separate events, where possible. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartNoActNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \def T1_TraceStopStartAct * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActPC * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActFast * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActFastPC * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActNoSusp * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActNoSuspPC * Call at the context switch from a stopping task to a newly starting task/ISR for * which there is no activation event but the activation time is somehow derived * without reference to T1_taskAct. The most common example is a timer ISR that is * already pending on exit and will re-start immediately and where the * activation time can be derived from the old compare value. It is important to use * this in preference to having two separate events, where possible. See \ref PC and * \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStopStartActNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] stopTaskId_ T1.scope task ID of stopping task * (this parameter is only for backwards compatibility, the * value is ignored) * \param[in] taskId_ T1.scope task ID of starting task/ISR * \param[in] actCoreId_ the T1 logical ID of the activating core * \param[in] actTime_ activation time of starting task in sync timer ticks * \def T1_TraceStartNoActStop * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopPC * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopFast * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopFastPC * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopNoSusp * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopNoSuspPC * Call at ISR too short for T1_TraceStart() then T1_TraceStop(). See also * T1_ContStartStopCETPC(). See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopNoSuspTime * Only provided for GLIWA T1 integration optimization. * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceStartNoActStopNoSuspTimePC * Only provided for GLIWA T1 integration optimization. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] time_ nominal time of task/ISR start * \param[in] taskId_ T1.scope task ID of short ISR * \def T1_TraceRelease * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceReleasePC * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceReleaseFast * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceReleaseFastPC * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceReleaseNoSusp * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceReleaseNoSuspPC * Call when a WAITING task becomes READY, in SetEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of released task * \def T1_TraceWait * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceWaitPC * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * \param[in] coreId_ the T1 logical ID of the calling core * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceWaitFast * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceWaitFastPC * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * \param[in] coreId_ the T1 logical ID of the calling core * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceWaitNoSusp * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceWaitNoSuspPC * Call when a RUNNING task becomes WAITING, on entry to WaitEvent. * \param[in] coreId_ the T1 logical ID of the calling core * See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResume * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResumePC * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResumeFast * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResumeFastPC * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResumeNoSusp * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceResumeNoSuspPC * Call on exit from WaitEvent. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] taskId_ T1.scope task ID of waiting task * \def T1_TraceEvent * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceEventPC * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceEventFast * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceEventFastPC * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceEventNoSusp * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceEventNoSuspPC * Call at a user event or user stopwatch event. See \ref PC and \ref INTRPT. * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] event_ #T1_STOPWATCH_START/#T1_STOPWATCH_STOP or configured * user event ID * \param[in] info_ T1.scope stopwatch ID or user event 10-bit info field * \def T1_TraceUint32 * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS. * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint32PC * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint32Fast * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint32FastPC * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint32NoSusp * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint32NoSuspPC * Call at user data event with 32-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui32_ 32-bit unsigned integer * \def T1_TraceUint16 * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceUint16PC * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceUint16Fast * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceUint16FastPC * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceUint16NoSusp * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceUint16NoSuspPC * Call at user data event with 16-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui16_ 16-bit unsigned integer * \def T1_TraceSint32 * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint32PC * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint32Fast * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint32FastPC * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint32NoSusp * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint32NoSuspPC * Call at user data event with 32-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si32_ 32-bit signed integer * \def T1_TraceSint16 * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceSint16PC * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceSint16Fast * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceSint16FastPC * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceSint16NoSusp * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceSint16NoSuspPC * Call at user data event with 16-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si16_ 16-bit signed integer * \def T1_TraceUint64 * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceUint64PC * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceUint64Fast * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceUint64FastPC * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceUint64NoSusp * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceUint64NoSuspPC * Call at user data event with 64-bit unsigned integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] ui64_ 64-bit unsigned integer * \def T1_TraceSint64 * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceSint64PC * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceSint64Fast * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceSint64FastPC * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceSint64NoSusp * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceSint64NoSuspPC * Call at user data event with 64-bit signed integer. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] si64_ 64-bit signed integer * \def T1_TraceAddr * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceAddrPC * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceAddrFast * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceAddrFastPC * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceAddrNoSusp * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceAddrNoSuspPC * Call at user data event with 32-bit address. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] addr_ 32-bit address * \def T1_TraceFloat * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceFloatPC * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceFloatFast * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceFloatFastPC * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceFloatNoSusp * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceFloatNoSuspPC * Call at user data event with IEEE 754 32-bit float. See \ref PC, \ref INTRPT and * \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] float_ IEEE 754 32-bit float * \def T1_TraceString * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceStringPC * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceStringFast * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceStringFastPC * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceStringNoSusp * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceStringNoSuspPC * Call at user data event with address and length of string data. See \ref PC, \ref * INTRPT and \ref USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of string * \param[in] len_ length of string (max 255 bytes) * \def T1_TraceBinary( id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array * \def T1_TraceBinaryFast( id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array * \def T1_TraceBinaryNoSusp( id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array * \def T1_TraceBinaryPC( coreId_, id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array * \def T1_TraceBinaryFastPC( coreId_, id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array * \def T1_TraceBinaryNoSuspPC( coreId_, id_, pData_, len_ ) * Call at user data event with a struct or array. See \ref PC, \ref INTRPT and \ref * USER_DATA_EVENTS * \param[in] coreId_ the T1 logical ID of the calling core * \param[in] id_ configured user data event ID * \param[in] pData_ address of struct or array * \param[in] len_ length of struct/array */ /* BEGIN generated variant macros */ # if 1 == T1_NOF_CORES # define T1_TraceActivation( taskId_ ) \ T1_TRACE_ACT_PC( , 0, (taskId_) ) # define T1_TraceActivationPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( , 0, (taskId_) ) # define T1_TraceActivationFast( taskId_ ) \ T1_TRACE_ACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceActivationFastPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceActivationNoSusp( taskId_ ) \ T1_TRACE_ACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceActivationNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceEvent( event_, info_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventFast( event_, info_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventFastPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSusp( event_, info_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSuspPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSuspTime( time_, event_, info_ ) \ T1_TRACE_ATOMIC__( _NOSUSPTIME, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ), (time_) ) # define T1_TraceEventNoSuspTimePC( coreId_, time_, event_, info_ ) \ T1_TRACE_ATOMIC__( _NOSUSPTIME, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( (event_), (info_) ), (time_) ) # define T1_TraceRelease( taskId_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleasePC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseFast( taskId_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseFastPC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseNoSusp( taskId_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceResume( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumePC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeFast( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeFastPC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeNoSusp( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeNoSuspPC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceStart( taskId_ ) \ T1_TRACE_START_PC( , 0, (taskId_) ) # define T1_TraceStartPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( , 0, (taskId_) ) # define T1_TraceStartFast( taskId_ ) \ T1_TRACE_START_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartFastPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartNoSusp( taskId_ ) \ T1_TRACE_START_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStartNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStartAct( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( , 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( , 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActFast( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _FAST, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActFastPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _FAST, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActNoSusp( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _NOSUSP, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActNoSuspPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _NOSUSP, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStartActNoSuspTime( time_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC_( _NOSUSPTIME, 0, (taskId_), 0, (actTime_), (time_) ) # define T1_TraceStartActNoSuspTimePC( coreId_, time_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC_( _NOSUSPTIME, 0, (taskId_), 0, (actTime_), (time_) ) # define T1_TraceStartNoAct( taskId_ ) \ T1_TRACE_START_NOACT_PC( , 0, (taskId_) ) # define T1_TraceStartNoActPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( , 0, (taskId_) ) # define T1_TraceStartNoActFast( taskId_ ) \ T1_TRACE_START_NOACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartNoActFastPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartNoActNoSusp( taskId_ ) \ T1_TRACE_START_NOACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoActNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoActNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_NOACT_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStartNoActNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_NOACT_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStartNoActStop( taskId_ ) \ T1_TRACE_START_STOP_PC( , 0, (taskId_) ) # define T1_TraceStartNoActStopPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( , 0, (taskId_) ) # define T1_TraceStartNoActStopFast( taskId_ ) \ T1_TRACE_START_STOP_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartNoActStopFastPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( _FAST, 0, (taskId_) ) # define T1_TraceStartNoActStopNoSusp( taskId_ ) \ T1_TRACE_START_STOP_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoActStopNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStartNoActStopNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_STOP_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStartNoActStopNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_STOP_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStop( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( , 0, (taskId_) ) ) # define T1_TraceStopPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( , 0, (taskId_) ) ) # define T1_TraceStopFast( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( _FAST, 0, (taskId_) ) ) # define T1_TraceStopFastPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( _FAST, 0, (taskId_) ) ) # define T1_TraceStopNoSusp( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( _NOSUSP, 0, (taskId_) ) ) # define T1_TraceStopNoSuspPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC( _NOSUSP, 0, (taskId_) ) ) # define T1_TraceStopNoSuspTime( time_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) ) # define T1_TraceStopNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_STOP_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) ) # define T1_TraceStopStart( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( , 0, (taskId_) ) # define T1_TraceStopStartPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( , 0, (taskId_) ) # define T1_TraceStopStartFast( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _FAST, 0, (taskId_) ) # define T1_TraceStopStartFastPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _FAST, 0, (taskId_) ) # define T1_TraceStopStartNoSusp( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStopStartNoSuspPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStopStartNoSuspTime( time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStopStartNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStopStartAct( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( , 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( , 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActFast( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _FAST, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActFastPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _FAST, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActNoSusp( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _NOSUSP, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActNoSuspPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _NOSUSP, 0, (taskId_), 0, (actTime_) ) # define T1_TraceStopStartActNoSuspTime( time_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC_( _NOSUSPTIME, 0, (taskId_), 0, (actTime_), (time_) ) # define T1_TraceStopStartActNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC_( _NOSUSPTIME, 0, (taskId_), 0, (actTime_), (time_) ) # define T1_TraceStopStartNoAct( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( , 0, (taskId_) ) # define T1_TraceStopStartNoActPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( , 0, (taskId_) ) # define T1_TraceStopStartNoActFast( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceStopStartNoActFastPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _FAST, 0, (taskId_) ) # define T1_TraceStopStartNoActNoSusp( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStopStartNoActNoSuspPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _NOSUSP, 0, (taskId_) ) # define T1_TraceStopStartNoActNoSuspTime( time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceStopStartNoActNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC_( _NOSUSPTIME, 0, (taskId_), (time_) ) # define T1_TraceSyncTimer( coreId_ ) \ T1_TRACE_SYNC( , T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerPC( coreId_ ) \ T1_TRACE_SYNC( , T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerFast( coreId_ ) \ T1_TRACE_SYNC( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerFastPC( coreId_ ) \ T1_TRACE_SYNC( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerNoSusp( coreId_ ) \ T1_TRACE_SYNC( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerNoSuspPC( coreId_ ) \ T1_TRACE_SYNC( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceWait( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitFast( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitFastPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitNoSusp( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitNoSuspPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( 0, T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( 0 ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # else /* more than one core */ # define T1_TraceActivation( taskId_ ) \ T1_TRACE_ACT_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceActivationPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( , (coreId_), (taskId_) ) # define T1_TraceActivationFast( taskId_ ) \ T1_TRACE_ACT_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceActivationFastPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceActivationNoSusp( taskId_ ) \ T1_TRACE_ACT_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceActivationNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_ACT_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceEvent( event_, info_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventFast( event_, info_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventFastPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSusp( event_, info_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSuspPC( coreId_, event_, info_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ) ) # define T1_TraceEventNoSuspTime( time_, event_, info_ ) \ T1_TRACE_ATOMIC__( _NOSUSPTIME, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( (event_), (info_) ), (time_) ) # define T1_TraceEventNoSuspTimePC( coreId_, time_, event_, info_ ) \ T1_TRACE_ATOMIC__( _NOSUSPTIME, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), T1_COMBINE_EVENT_INFO( (event_), (info_) ), (time_) ) # define T1_TraceRelease( taskId_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleasePC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseFast( taskId_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseFastPC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseNoSusp( taskId_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceReleaseNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RELEASE, (taskId_) ) ) # define T1_TraceResume( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumePC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeFast( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeFastPC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeNoSusp( taskId_ ) \ T1_INCR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceResumeNoSuspPC( coreId_, taskId_ ) \ T1_INCR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_RESUME, (taskId_) ) ) ) # define T1_TraceStart( taskId_ ) \ T1_TRACE_START_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( , (coreId_), (taskId_) ) # define T1_TraceStartFast( taskId_ ) \ T1_TRACE_START_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartFastPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceStartNoSusp( taskId_ ) \ T1_TRACE_START_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceStartNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) # define T1_TraceStartNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) # define T1_TraceStartAct( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( , T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( , (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActFast( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActFastPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _FAST, (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActNoSusp( taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActNoSuspPC( coreId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC( _NOSUSP, (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStartActNoSuspTime( time_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_), (time_) ) # define T1_TraceStartActNoSuspTimePC( coreId_, time_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_START_ACT_PC_( _NOSUSPTIME, coreId_, (taskId_), (actCoreId_), (actTime_), (time_) ) # define T1_TraceStartNoAct( taskId_ ) \ T1_TRACE_START_NOACT_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( , (coreId_), (taskId_) ) # define T1_TraceStartNoActFast( taskId_ ) \ T1_TRACE_START_NOACT_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActFastPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceStartNoActNoSusp( taskId_ ) \ T1_TRACE_START_NOACT_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_NOACT_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceStartNoActNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_NOACT_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) # define T1_TraceStartNoActNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_NOACT_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) # define T1_TraceStartNoActStop( taskId_ ) \ T1_TRACE_START_STOP_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActStopPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( , (coreId_), (taskId_) ) # define T1_TraceStartNoActStopFast( taskId_ ) \ T1_TRACE_START_STOP_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActStopFastPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceStartNoActStopNoSusp( taskId_ ) \ T1_TRACE_START_STOP_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStartNoActStopNoSuspPC( coreId_, taskId_ ) \ T1_TRACE_START_STOP_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceStartNoActStopNoSuspTime( time_, taskId_ ) \ T1_TRACE_START_STOP_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) # define T1_TraceStartNoActStopNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_TRACE_START_STOP_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) # define T1_TraceStop( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_STOP_PC( , T1_GetCoreIdOffset( ), (taskId_) ) ) # define T1_TraceStopPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_STOP_PC( , (coreId_), (taskId_) ) ) # define T1_TraceStopFast( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_STOP_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) ) # define T1_TraceStopFastPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_STOP_PC( _FAST, (coreId_), (taskId_) ) ) # define T1_TraceStopNoSusp( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_STOP_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) ) # define T1_TraceStopNoSuspPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_STOP_PC( _NOSUSP, (coreId_), (taskId_) ) ) # define T1_TraceStopNoSuspTime( time_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_STOP_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) ) # define T1_TraceStopNoSuspTimePC( coreId_, time_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( coreId_, T1_TRACE_STOP_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) ) # define T1_TraceStopStart( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( , (coreId_), (taskId_) ) # define T1_TraceStopStartFast( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartFastPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceStopStartNoSusp( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartNoSuspPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceStopStartNoSuspTime( time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) # define T1_TraceStopStartNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) # define T1_TraceStopStartAct( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( , T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( , (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActFast( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActFastPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _FAST, (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActNoSusp( stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActNoSuspPC( coreId_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC( _NOSUSP, (coreId_), (taskId_), (actCoreId_), (actTime_) ) # define T1_TraceStopStartActNoSuspTime( time_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (actCoreId_), (actTime_), (time_) ) # define T1_TraceStopStartActNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_, actCoreId_, actTime_ ) \ T1_TRACE_STOP_START_ACT_PC_( _NOSUSPTIME, coreId_, (taskId_), (actCoreId_), (actTime_), (time_) ) # define T1_TraceStopStartNoAct( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( , T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartNoActPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( , (coreId_), (taskId_) ) # define T1_TraceStopStartNoActFast( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _FAST, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartNoActFastPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _FAST, (coreId_), (taskId_) ) # define T1_TraceStopStartNoActNoSusp( stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _NOSUSP, T1_GetCoreIdOffset( ), (taskId_) ) # define T1_TraceStopStartNoActNoSuspPC( coreId_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC( _NOSUSP, (coreId_), (taskId_) ) # define T1_TraceStopStartNoActNoSuspTime( time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC_( _NOSUSPTIME, T1_GetCoreIdOffset( ), (taskId_), (time_) ) # define T1_TraceStopStartNoActNoSuspTimePC( coreId_, time_, stopTaskId_, taskId_ ) \ T1_TRACE_STOP_START_NOACT_PC_( _NOSUSPTIME, coreId_, (taskId_), (time_) ) # define T1_TraceSyncTimer( coreId_ ) \ T1_TRACE_SYNC( , T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerPC( coreId_ ) \ T1_TRACE_SYNC( , T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerFast( coreId_ ) \ T1_TRACE_SYNC( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerFastPC( coreId_ ) \ T1_TRACE_SYNC( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerNoSusp( coreId_ ) \ T1_TRACE_SYNC( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceSyncTimerNoSuspPC( coreId_ ) \ T1_TRACE_SYNC( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_SYNCDATA_START, T1_TRACEDATA_UINT32 ) ) # define T1_TraceWait( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( , T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitFast( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitFastPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( _FAST, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitNoSusp( taskId_ ) \ T1_DECR_PREEMPTIONS_PC( T1_GetCoreIdOffset( ), T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset( ) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # define T1_TraceWaitNoSuspPC( coreId_, taskId_ ) \ T1_DECR_PREEMPTIONS_PC( (coreId_), T1_TRACE_ATOMIC_( _NOSUSP, T1_TraceEvent, T1_CORE_ID_TO_SCOPE_CONSTS( (coreId_) ), T1_COMBINE_EVENT_INFO( T1_WAIT, (taskId_) ) ) ) # endif /* 1 == T1_NOF_CORES */ /* END generated variant macros */ /* Used by T1_TraceUint16/Sint16... */ # if defined T1_TRICORE || defined T1_RH850 || defined T1_HOST # define T1_16_TO_U32( _16_ ) ( (T1_uint32_t)(T1_uint16_t)(_16_) ) # elif defined T1_MPC5XXXX # define T1_16_TO_U32( _16_ ) ( (T1_uint32_t)(_16_) << 16 ) # else /* endian-ness depends on specific variant */ # define T1_16_TO_U32( _16_ ) ( T1_16toU32( _16_ ) ) # endif /* endian-ness */ # define T1_TraceData( id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataFast( id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataNoSusp( id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataNoSuspTime( id_, vrnt_, pData_, len_, time_ ) \ T1_TRACEDATA_NOSUSPTIME( (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_), (time_) ) # define T1_TraceUint16( id_, ui16_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint16Fast( id_, ui16_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint16NoSusp( id_, ui16_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint32( id_, ui32_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceUint32Fast( id_, ui32_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceUint32NoSusp( id_, ui32_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceSint16( id_, si16_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint16Fast( id_, si16_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint16NoSusp( id_, si16_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint32( id_, si32_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceSint32Fast( id_, si32_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceSint32NoSusp( id_, si32_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceAddr( id_, addr_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceAddrFast( id_, addr_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceAddrNoSusp( id_, addr_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( T1_GetCoreIdOffset() ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceFloat( id_, float_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceFloatFast( id_, float_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceFloatNoSusp( id_, float_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceUint64( id_, ui64_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceUint64Fast( id_, ui64_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceUint64NoSusp( id_, ui64_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceSint64( id_, si64_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceSint64Fast( id_, si64_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceSint64NoSusp( id_, si64_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceString( id_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceStringFast( id_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceStringNoSusp( id_, pData_, len_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinary( id_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinaryFast( id_, pData_, len_ ) \ T1_TRACEDATA( _, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinaryNoSusp( id_, pData_, len_ ) \ T1_TRACEDATA( NoSusp_, (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataPC( coreId_, id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataFastPC( coreId_, id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataNoSuspPC( coreId_, id_, vrnt_, pData_, len_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceDataNoSuspTimePC( coreId_, id_, vrnt_, pData_, len_, time_ ) \ T1_TRACEDATA_NOSUSPTIME_PC( (coreId_), (((id_) & 0x1Fu) << 4) | (vrnt_), (T1_uint8_t const *)(pData_), (len_), (time_) ) # define T1_TraceUint16PC( coreId_, id_, ui16_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint16FastPC( coreId_, id_, ui16_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint16NoSuspPC( coreId_, id_, ui16_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT16, T1_16_TO_U32(ui16_) ) # define T1_TraceUint32PC( coreId_, id_, ui32_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceUint32FastPC( coreId_, id_, ui32_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceUint32NoSuspPC( coreId_, id_, ui32_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT32, (ui32_) ) # define T1_TraceSint16PC( coreId_, id_, si16_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint16FastPC( coreId_, id_, si16_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint16NoSuspPC( coreId_, id_, si16_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT16, T1_16_TO_U32(si16_) ) # define T1_TraceSint32PC( coreId_, id_, si32_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceSint32FastPC( coreId_, id_, si32_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceSint32NoSuspPC( coreId_, id_, si32_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT32, (T1_uint32_t)(si32_) ) # define T1_TraceAddrPC( coreId_, id_, addr_ ) \ T1_TRACE_UINT32( , T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceAddrFastPC( coreId_, id_, addr_ ) \ T1_TRACE_UINT32( _FAST, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceAddrNoSuspPC( coreId_, id_, addr_ ) \ T1_TRACE_UINT32( _NOSUSP, T1_CORE_ID_TO_SCOPE_CONSTS( coreId_ ), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_ADDRESS, (T1_uint32_t)(addr_) ) # define T1_TraceFloatPC( coreId_, id_, float_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceFloatFastPC( coreId_, id_, float_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceFloatNoSuspPC( coreId_, id_, float_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_FLOAT, (T1_uint8_t const *)&(float_), 4u ) # define T1_TraceUint64PC( coreId_, id_, ui64_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceUint64FastPC( coreId_, id_, ui64_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceUint64NoSuspPC( coreId_, id_, ui64_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_UINT64, (T1_uint8_t const *)&(ui64_), 8u ) # define T1_TraceSint64PC( coreId_, id_, si64_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceSint64FastPC( coreId_, id_, si64_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceSint64NoSuspPC( coreId_, id_, si64_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | T1_TRACEDATA_SINT64, (T1_uint8_t const *)&(si64_), 8u ) # define T1_TraceStringPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceStringFastPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceStringNoSuspPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_STR_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinaryPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinaryFastPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( _, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) # define T1_TraceBinaryNoSuspPC( coreId_, id_, pData_, len_ ) \ T1_TRACEDATA_PC( NoSusp_, (coreId_), (((id_) & 0x1Fu) << 4) | (T1_TRACEDATA_BIN_REST0 + (len_) % T1_DATA_BYTES_PER_ENTRY), (T1_uint8_t const *)(pData_), (len_) ) /* Deprecated */ # define T1_TraceSync( pTime_ ) ((void)0) # define T1_TraceSyncFast( pTime_ ) ((void)0) # define T1_TraceSyncNoSusp( pTime_ ) ((void)0) /*! * Trace a user stopwatch event or user event only if application feature is enabled. * See \ref INTRPT. * \param[in] event_ the event ID * \param[in] info_ additional info field, for example task/stopwatch ID * \param[in] mask_ the application feature to test */ # define T1_TraceEventPerFeature( event_, info_, mask_ ) \ do \ { \ if( T1_IsFeatureEnabled( mask_ ) ) \ { \ T1_TraceEvent( event_, info_ ); \ } \ } \ while( 0 ) /*! * Trace a user stopwatch event or user event only if application feature is enabled. * See \ref INTRPT. * \param[in] event_ the event ID * \param[in] info_ additional info field, for example task/stopwatch ID * \param[in] mask_ the application feature to test */ # define T1_TraceEventFastPerFeature( event_, info_, mask_ ) \ do \ { \ if( T1_IsFeatureEnabled( mask_ ) ) \ { \ T1_TraceEventFast( event_, info_ ); \ } \ } \ while( 0 ) /*! * Trace a user stopwatch event or user event only if application feature is enabled. * See \ref INTRPT. * \param[in] event_ the event ID * \param[in] info_ additional info field, for example task/stopwatch ID * \param[in] mask_ the application feature to test */ # define T1_TraceEventNoSuspPerFeature( event_, info_, mask_ ) \ do \ { \ if( T1_IsFeatureEnabled( mask_ ) ) \ { \ T1_TraceEventNoSusp( event_, info_ ); \ } \ } \ while( 0 ) #else /* ! defined T1_ENABLE || defined T1_DISABLE_T1_SCOPE */ # define T1_scopePlugin (T1_DISABLED_PLUGIN) /* empty macros */ # define T1_InitTraceBufferPC( coreId_ ) ((void)0) # define T1_TraceEvent( event_, info_ ) ((void)0) # define T1_TraceEventFast( event_, info_ ) ((void)0) # define T1_TraceEventNoSusp( event_, info_ ) ((void)0) # define T1_TraceEventNoSuspTime( time_, event_, info_ ) ((void)0) # define T1_TraceEventPC( coreId_, event_, info_ ) ((void)0) # define T1_TraceEventFastPC( coreId_, event_, info_ ) ((void)0) # define T1_TraceEventNoSuspPC( coreId_, event_, info_ ) ((void)0) # define T1_TraceEventNoSuspTimePC( coreId_, time_, event_, info_ ) ((void)0) # define T1_TraceStart( taskId_ ) ((void)0) # define T1_TraceStartFast( taskId_ ) ((void)0) # define T1_TraceStartNoSusp( taskId_ ) ((void)0) # define T1_TraceStartPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartFastPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartNoSuspPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartAct( taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartActFast( taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartActNoSusp( taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartActPC( coreId_, taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartActFastPC( coreId_, taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartActNoSuspPC( coreId_, taskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStartNoAct( taskId_ ) ((void)0) # define T1_TraceStartNoActFast( taskId_ ) ((void)0) # define T1_TraceStartNoActNoSusp( taskId_ ) ((void)0) # define T1_TraceStartNoActPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartNoActFastPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartNoActNoSuspPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStop( taskId_ ) ((void)0) # define T1_TraceStopFast( taskId_ ) ((void)0) # define T1_TraceStopNoSusp( taskId_ ) ((void)0) # define T1_TraceStopPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStopFastPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStopNoSuspPC( coreId_, taskId_ ) ((void)0) # define T1_TraceActivation( taskId_ ) ((void)0) # define T1_TraceActivationFast( taskId_ ) ((void)0) # define T1_TraceActivationNoSusp( taskId_ ) ((void)0) # define T1_TraceActivationPC( coreId_, taskId_ ) ((void)0) # define T1_TraceActivationFastPC( coreId_, taskId_ ) ((void)0) # define T1_TraceActivationNoSuspPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStopStart( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartFast( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoSusp( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartFastPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoSuspPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartAct( stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartActFast( stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartActNoSusp( stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartActPC( coreId_, stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartActFastPC( coreId_, stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartActNoSuspPC( coreId_, stopTaskId_, startTaskId_, actCoreId_, time_ ) ((void)0) # define T1_TraceStopStartNoAct( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoActFast( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoActNoSusp( stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoActPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoActFastPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStopStartNoActNoSuspPC( coreId_, stopTaskId_, startTaskId_ ) ((void)0) # define T1_TraceStartNoActStop( taskId_ ) ((void)0) # define T1_TraceStartNoActStopFast( taskId_ ) ((void)0) # define T1_TraceStartNoActStopNoSusp( taskId_ ) ((void)0) # define T1_TraceStartNoActStopPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartNoActStopFastPC( coreId_, taskId_ ) ((void)0) # define T1_TraceStartNoActStopNoSuspPC( coreId_, taskId_ ) ((void)0) # define T1_TraceData( id_, kind_, pData_, len_ ) ((void)0) # define T1_TraceDataFast( id_, kind_, pData_, len_ ) ((void)0) # define T1_TraceDataNoSusp( id_, kind_, pData_, len_ ) ((void)0) # define T1_TraceUint16( id_, ui16_ ) ((void)0) # define T1_TraceUint16Fast( id_, ui16_ ) ((void)0) # define T1_TraceUint16NoSusp( id_, ui16_ ) ((void)0) # define T1_TraceUint32( id_, ui32_ ) ((void)0) # define T1_TraceUint32Fast( id_, ui32_ ) ((void)0) # define T1_TraceUint32NoSusp( id_, ui32_ ) ((void)0) # define T1_TraceAddr( id_, addr_ ) ((void)0) # define T1_TraceAddrFast( id_, addr_ ) ((void)0) # define T1_TraceAddrNoSusp( id_, addr_ ) ((void)0) # define T1_TraceString( id_, pData_, len_ ) ((void)0) # define T1_TraceStringFast( id_, pData_, len_ ) ((void)0) # define T1_TraceStringNoSusp( id_, pData_, len_ ) ((void)0) # define T1_TraceBinary( id_, pData_, len_ ) ((void)0) # define T1_TraceBinaryFast( id_, pData_, len_ ) ((void)0) # define T1_TraceBinaryNoSusp( id_, pData_, len_ ) ((void)0) # define T1_TraceDataPC( coreId_, id_, kind_, pData_, len_ )((void)0) # define T1_TraceDataFastPC( coreId_, id_, kind_, pData_, len_ ) ((void)0) # define T1_TraceDataNoSuspPC( coreId_, id_, kind_, pData_, len_ ) ((void)0) # define T1_TraceUint16PC( coreId_, id_, ui16_ ) ((void)0) # define T1_TraceUint16FastPC( coreId_, id_, ui16_ ) ((void)0) # define T1_TraceUint16NoSuspPC( coreId_, id_, ui16_ ) ((void)0) # define T1_TraceUint32PC( coreId_, id_, ui32_ ) ((void)0) # define T1_TraceUint32FastPC( coreId_, id_, ui32_ ) ((void)0) # define T1_TraceUint32NoSuspPC( coreId_, id_, ui32_ ) ((void)0) # define T1_TraceAddrPC( coreId_, id_, addr_ ) ((void)0) # define T1_TraceAddrFastPC( coreId_, id_, addr_ ) ((void)0) # define T1_TraceAddrNoSuspPC( coreId_, id_, addr_ ) ((void)0) # define T1_TraceStringPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceStringFastPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceStringNoSuspPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceBinaryPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceBinaryFastPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceBinaryNoSuspPC( coreId_, id_, pData_, len_ ) ((void)0) # define T1_TraceSync( pTime_ ) ((void)0) # define T1_TraceSyncFast( pTime_ ) ((void)0) # define T1_TraceSyncNoSusp( pTime_ ) ((void)0) # define T1_TraceSyncTimer( core_ ) ((void)0) # define T1_TraceSyncTimerFast( core_ ) ((void)0) # define T1_TraceSyncTimerNoSusp( core_ ) ((void)0) # define T1_TraceSyncTimerPC( core_ ) ((void)0) # define T1_TraceSyncTimerFastPC( core_ ) ((void)0) # define T1_TraceSyncTimerNoSuspPC( core_ ) ((void)0) # define T1_SetStopTrigger( afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_SetStopTriggerFast( afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_SetStopTriggerNoSusp( afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_SetStopTriggerPC( coreId_, afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_SetStopTriggerFastPC( coreId_, afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_SetStopTriggerNoSuspPC( coreId_, afterXevents_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_TraceEventPerFeature( event_, info_, mask_ ) ((void)0) # define T1_TraceEventFastPerFeature( event_, info_, mask_ ) ((void)0) # define T1_TraceEventNoSuspPerFeature( event_, info_, mask_ ) ((void)0) # define T1_scopeRevision (0uL) # define T1_TraceNamePC( coreId_, taskId_ ) (T1_PLUGIN_NOT_AVAILABLE) # define T1_TraceName( taskId_ ) (T1_PLUGIN_NOT_AVAILABLE) #endif /* defined T1_ENABLE && ! defined T1_DISABLE_T1_SCOPE */ /*----------------------------------------------------------------------------------*/ /*--- Declarations for global data structures --------------------------------------*/ /*----------------------------------------------------------------------------------*/ #if ! defined T1_MULTICORE_CLONE # define T1_CORE0_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE0_SEC_CONST_32 T1_scopeConsts0; T1_EXTERN T1_scopeFgConsts_t T1_CORE0_SEC_CONST_32 T1_scopeFgConsts0; # define T1_CORE0_STOP_SEC_CONST_32 # include "T1_MemMap.h" # if 1 < T1_NOF_CORES # define T1_CORE1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE1_SEC_CONST_32 T1_scopeConsts1; T1_EXTERN T1_scopeFgConsts_t T1_CORE1_SEC_CONST_32 T1_scopeFgConsts1; # define T1_CORE1_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_CORE2_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE2_SEC_CONST_32 T1_scopeConsts2; T1_EXTERN T1_scopeFgConsts_t T1_CORE2_SEC_CONST_32 T1_scopeFgConsts2; # define T1_CORE2_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_CORE3_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE3_SEC_CONST_32 T1_scopeConsts3; T1_EXTERN T1_scopeFgConsts_t T1_CORE3_SEC_CONST_32 T1_scopeFgConsts3; # define T1_CORE3_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_CORE4_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE4_SEC_CONST_32 T1_scopeConsts4; T1_EXTERN T1_scopeFgConsts_t T1_CORE4_SEC_CONST_32 T1_scopeFgConsts4; # define T1_CORE4_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_CORE5_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE5_SEC_CONST_32 T1_scopeConsts5; T1_EXTERN T1_scopeFgConsts_t T1_CORE5_SEC_CONST_32 T1_scopeFgConsts5; # define T1_CORE5_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_CORE6_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE6_SEC_CONST_32 T1_scopeConsts6; T1_EXTERN T1_scopeFgConsts_t T1_CORE6_SEC_CONST_32 T1_scopeFgConsts6; # define T1_CORE6_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_CORE7_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE7_SEC_CONST_32 T1_scopeConsts7; T1_EXTERN T1_scopeFgConsts_t T1_CORE7_SEC_CONST_32 T1_scopeFgConsts7; # define T1_CORE7_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_CORE8_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE8_SEC_CONST_32 T1_scopeConsts8; T1_EXTERN T1_scopeFgConsts_t T1_CORE8_SEC_CONST_32 T1_scopeFgConsts8; # define T1_CORE8_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_CORE9_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE9_SEC_CONST_32 T1_scopeConsts9; T1_EXTERN T1_scopeFgConsts_t T1_CORE9_SEC_CONST_32 T1_scopeFgConsts9; # define T1_CORE9_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_CORE10_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE10_SEC_CONST_32 T1_scopeConsts10; T1_EXTERN T1_scopeFgConsts_t T1_CORE10_SEC_CONST_32 T1_scopeFgConsts10; # define T1_CORE10_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_CORE11_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE11_SEC_CONST_32 T1_scopeConsts11; T1_EXTERN T1_scopeFgConsts_t T1_CORE11_SEC_CONST_32 T1_scopeFgConsts11; # define T1_CORE11_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_CORE12_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE12_SEC_CONST_32 T1_scopeConsts12; T1_EXTERN T1_scopeFgConsts_t T1_CORE12_SEC_CONST_32 T1_scopeFgConsts12; # define T1_CORE12_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_CORE13_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE13_SEC_CONST_32 T1_scopeConsts13; T1_EXTERN T1_scopeFgConsts_t T1_CORE13_SEC_CONST_32 T1_scopeFgConsts13; # define T1_CORE13_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_CORE14_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeConsts_t T1_CORE14_SEC_CONST_32 T1_scopeConsts14; T1_EXTERN T1_scopeFgConsts_t T1_CORE14_SEC_CONST_32 T1_scopeFgConsts14; # define T1_CORE14_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_CORE0_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE0_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData0[]; # define T1_CORE0_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # if 1 < T1_NOF_CORES # define T1_CORE1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE1_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData1[]; # define T1_CORE1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_CORE2_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE2_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData2[]; # define T1_CORE2_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_CORE3_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE3_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData3[]; # define T1_CORE3_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_CORE4_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE4_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData4[]; # define T1_CORE4_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_CORE5_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE5_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData5[]; # define T1_CORE5_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_CORE6_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE6_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData6[]; # define T1_CORE6_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_CORE7_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE7_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData7[]; # define T1_CORE7_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_CORE8_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE8_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData8[]; # define T1_CORE8_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_CORE9_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE9_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData9[]; # define T1_CORE9_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_CORE10_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE10_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData10[]; # define T1_CORE10_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_CORE11_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE11_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData11[]; # define T1_CORE11_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_CORE12_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE12_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData12[]; # define T1_CORE12_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_CORE13_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE13_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData13[]; # define T1_CORE13_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_CORE14_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_stpwFgData_t T1_CORE14_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData14[]; # define T1_CORE14_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_CHECKED_CORE0_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE0_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals0; # define T1_CHECKED_CORE0_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # if 1 < T1_NOF_CORES # define T1_CHECKED_CORE1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE1_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals1; # define T1_CHECKED_CORE1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_CHECKED_CORE2_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE2_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals2; # define T1_CHECKED_CORE2_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_CHECKED_CORE3_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE3_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals3; # define T1_CHECKED_CORE3_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_CHECKED_CORE4_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE4_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals4; # define T1_CHECKED_CORE4_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_CHECKED_CORE5_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE5_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals5; # define T1_CHECKED_CORE5_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_CHECKED_CORE6_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE6_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals6; # define T1_CHECKED_CORE6_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_CHECKED_CORE7_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE7_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals7; # define T1_CHECKED_CORE7_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_CHECKED_CORE8_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE8_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals8; # define T1_CHECKED_CORE8_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_CHECKED_CORE9_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE9_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals9; # define T1_CHECKED_CORE9_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_CHECKED_CORE10_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE10_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals10; # define T1_CHECKED_CORE10_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_CHECKED_CORE11_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE11_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals11; # define T1_CHECKED_CORE11_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_CHECKED_CORE12_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE12_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals12; # define T1_CHECKED_CORE12_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_CHECKED_CORE13_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE13_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals13; # define T1_CHECKED_CORE13_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_CHECKED_CORE14_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CHECKED_CORE14_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals14; # define T1_CHECKED_CORE14_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_CORE0_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE0_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals0; # define T1_CORE0_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # if 1 < T1_NOF_CORES # define T1_CORE1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE1_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals1; # define T1_CORE1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_CORE2_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE2_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals2; # define T1_CORE2_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_CORE3_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE3_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals3; # define T1_CORE3_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_CORE4_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE4_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals4; # define T1_CORE4_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_CORE5_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE5_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals5; # define T1_CORE5_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_CORE6_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE6_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals6; # define T1_CORE6_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_CORE7_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE7_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals7; # define T1_CORE7_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_CORE8_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE8_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals8; # define T1_CORE8_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_CORE9_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE9_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals9; # define T1_CORE9_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_CORE10_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE10_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals10; # define T1_CORE10_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_CORE11_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE11_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals11; # define T1_CORE11_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_CORE12_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE12_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals12; # define T1_CORE12_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_CORE13_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE13_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals13; # define T1_CORE13_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_CORE14_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeFgGlobals_t T1_CORE14_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeFgGlobals14; # define T1_CORE14_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_TRACEBUFFER_CORE0_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE0_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer0[]; # define T1_TRACEBUFFER_CORE0_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # if 1 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE1_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer1[]; # define T1_TRACEBUFFER_CORE1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 1 < T1_NOF_CORES */ # if 2 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE2_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE2_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer2[]; # define T1_TRACEBUFFER_CORE2_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 2 < T1_NOF_CORES */ # if 3 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE3_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE3_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer3[]; # define T1_TRACEBUFFER_CORE3_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 3 < T1_NOF_CORES */ # if 4 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE4_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE4_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer4[]; # define T1_TRACEBUFFER_CORE4_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 4 < T1_NOF_CORES */ # if 5 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE5_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE5_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer5[]; # define T1_TRACEBUFFER_CORE5_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 5 < T1_NOF_CORES */ # if 6 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE6_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE6_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer6[]; # define T1_TRACEBUFFER_CORE6_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 6 < T1_NOF_CORES */ # if 7 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE7_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE7_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer7[]; # define T1_TRACEBUFFER_CORE7_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 7 < T1_NOF_CORES */ # if 8 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE8_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE8_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer8[]; # define T1_TRACEBUFFER_CORE8_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 8 < T1_NOF_CORES */ # if 9 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE9_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE9_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer9[]; # define T1_TRACEBUFFER_CORE9_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 9 < T1_NOF_CORES */ # if 10 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE10_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE10_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer10[]; # define T1_TRACEBUFFER_CORE10_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 10 < T1_NOF_CORES */ # if 11 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE11_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE11_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer11[]; # define T1_TRACEBUFFER_CORE11_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 11 < T1_NOF_CORES */ # if 12 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE12_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE12_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer12[]; # define T1_TRACEBUFFER_CORE12_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 12 < T1_NOF_CORES */ # if 13 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE13_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE13_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer13[]; # define T1_TRACEBUFFER_CORE13_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 13 < T1_NOF_CORES */ # if 14 < T1_NOF_CORES # define T1_TRACEBUFFER_CORE14_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_traceEntry_t T1_FAR T1_TRACEBUFFER_CORE14_SEC_VAR_POWER_ON_CLEARED_32 T1_traceBuffer14[]; # define T1_TRACEBUFFER_CORE14_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # endif /* 14 < T1_NOF_CORES */ # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t * const T1_SEC_CONST_32 T1_scopeGlobalsPC[]; /*! \brief Array of core-specific T1.scope global data. */ T1_EXTERN T1_scopeConsts_t * const T1_SEC_CONST_32 T1_scopeConstsPC[]; T1_EXTERN T1_scopeFgGlobals_t * const T1_SEC_CONST_32 T1_scopeFgGlobalsPC[]; T1_EXTERN T1_scopeFgConsts_t * const T1_SEC_CONST_32 T1_scopeFgConstsPC[]; T1_EXTERN T1_stpwFgData_t * const T1_SEC_CONST_32 T1_stpwFgDataPC[]; T1_EXTERN T1_scopeFgGlobalsInit_t T1_SEC_CONST_32 T1_initFgContScopePC[]; T1_EXTERN T1_taskFgInitData_t T1_SEC_CONST_32 T1_initFgContTasks[]; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" #else /* clone */ # define T1_CLONE_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_scopeGlobals_t T1_CLONE_SEC_VAR_POWER_ON_CLEARED_32 T1_scopeGlobals; T1_EXTERN T1_stpwFgData_t T1_CLONE_SEC_VAR_POWER_ON_CLEARED_32 T1_stpwFgData; # define T1_CLONE_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" #endif /* ! defined T1_MULTICORE_CLONE */ #if ! defined T1_DISABLE_T1_CONT && defined T1_FG_CONT # define T1_START_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" T1_EXTERN T1_taskFgData_t T1_SEC_VAR_POWER_ON_CLEARED_32 T1_taskFgData[]; T1_EXTERN T1_uint32_t T1_SEC_VAR_POWER_ON_CLEARED_32 T1_actExtra[]; # define T1_STOP_SEC_VAR_POWER_ON_CLEARED_32 # include "T1_MemMap.h" # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_EXTERN T1_pFgContEventHandler_t const T1_SEC_CONST_32 T1_initHandlers[T1_NOF_HANDLERS][2]; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" #endif /* ! defined T1_DISABLE_T1_CONT && defined T1_FG_CONT */ #define T1_START_SEC_CONST_32 #include "T1_MemMap.h" T1_EXTERN T1_fgContHelpers_t const * const T1_SEC_CONST_32 T1_pFgContHelpers; T1_EXTERN T1_fgContHelpers_t const T1_SEC_CONST_32 T1_46828; T1_EXTERN T1_fgContHelpers_t const T1_SEC_CONST_32 T1_91054; #define T1_STOP_SEC_CONST_32 #include "T1_MemMap.h" #define T1_START_SEC_CONST_8 #include "T1_MemMap.h" T1_EXTERN T1_uint8_t const T1_SEC_CONST_8 T1_syncPeriodPC[]; #define T1_STOP_SEC_CONST_8 #include "T1_MemMap.h" #define T1_START_SEC_CONST_16 #include "T1_MemMap.h" T1_EXTERN T1_uint16_t const T1_SEC_CONST_16 T1_maxNofTasks; #define T1_STOP_SEC_CONST_16 #include "T1_MemMap.h" /*----------------------------------------------------------------------------------*/ /*--- forward declarations for external functions ----------------------------------*/ /*----------------------------------------------------------------------------------*/ #define T1_START_SEC_CODE_FAST #include "T1_MemMap.h" T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_LargeInterval( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t diff, T1_uint32_t syncTime ); T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_BrokenInterval( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t diff, T1_uint32_t syncTime ); #if defined T1_NEAR_CODE_FAST T1_EXTERN T1_tickUint_t T1_NEAR_CODE_FAST T1_NearLargeInterval( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t diff, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_NEAR_CODE_FAST T1_NearBrokenInterval( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t diff, T1_uint32_t syncTime ); #else /* ! defined T1_NEAR_CODE_FAST */ # define T1_NearLargeInterval T1_LargeInterval # define T1_NearBrokenInterval T1_BrokenInterval #endif /* defined T1_NEAR_CODE_FAST */ #define T1_STOP_SEC_CODE_FAST #include "T1_MemMap.h" #define T1_START_SEC_CODE #include "T1_MemMap.h" T1_EXTERN T1_tickUint_t T1_CODE T1_Empty( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_EmptyVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ActivateTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ActivateTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ActivateAndTraceTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ActivateAndTraceTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ResumeTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_ResumeTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartFlexStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartFlexSwd( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartFlexSwdVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartNoActTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartNoActTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartNoIptTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartNoIptTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartStopNoIptTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StartStopNoIptTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopFlexStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopFlexStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopFlexSwd( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopFlexSwdSyncIsTraceTimer( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopFlexSwdVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartIncFlexStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartIncFlexStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartIncStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartIncStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartNoActTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartNoActTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartNoIptTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStartNoIptTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t startTaskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopStopwatchVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_StopTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_WaitTask( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_WaitTaskVS( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t taskId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_CalibStartStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_CalibStopStartStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_tickUint_t T1_CODE T1_CalibStopFlexStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t stpwId, T1_uint32_t traceTime, T1_uint32_t syncTime ); T1_EXTERN T1_char_t const T1_FARPTR T1_CODE T1_GetTaskName( T1_taskId_t taskId ); T1_EXTERN void T1_CODE T1_InitNameBufferNoSuspPC( T1_uint8Least_t coreId ); T1_EXTERN T1_uint8_t T1_FARPTR T1_CODE T1_GetNameBufferPC( T1_uint8Least_t coreId ); T1_EXTERN void * T1_CODE T1_InitTaskIdListPC( T1_uint8Least_t coreId ); T1_EXTERN T1_taskId_t T1_CODE T1_GetNextTaskId( void *pHandle ); T1_EXTERN T1_status_t T1_CODE T1_RewindTaskId( void *pHandle ); T1_EXTERN T1_uint8Least_t T1_CODE T1_GetTaskOsIds( T1_taskId_t taskId, T1_uint32_t const **ppOsIds ); T1_EXTERN void T1_CODE T1_TraceScopeUploadNoSuspTimeIntern( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_tickUint_t now ); T1_EXTERN T1_scopeConsts_t * T1_CODE T1_GetSpinlockPC( T1_uint8Least_t coreId, T1_bakery_t *pSem, T1_uint8Least_t semId, T1_uint8Least_t nOfSemIds, T1_bool_t isPrivNoSusp ); T1_EXTERN void T1_CODE T1_ReleaseSpinlockPC( T1_uint8Least_t coreId, T1_bakery_t *pSem, T1_uint8Least_t semId, T1_bool_t isPrivNoSusp ); /*----------------------------------------------------------------------------------*/ /*--- forward declarations for user functions --------------------------------------*/ /*----------------------------------------------------------------------------------*/ /*! * \brief Callout to obtain the current trace timer value with at least 16 counting bits. * \returns the trace timer count register * * There is no need to mask off any non-counting bits. * It is not time-critical and does not need to be safe to call from user mode. * */ T1_EXTERN T1_tickUint_t T1_CODE T1_GetTraceTime( void ); /*! * \brief Callout to obtain the current trace timer value with at least 16 counting bits. * \returns the trace timer count register * * It is not time-critical but does **need to be safe to call from user mode**. * There is no need to mask off any non-counting bits. * */ T1_EXTERN T1_tickUint_t T1_CODE T1_GetTraceTimeUM( void ); /*! * \brief Callout to obtain the synchronization trace timer value and the trace timer * value together. * \param[in] coreId the T1 logical core ID of the calling core * \param[out] pSyncTimerBase both timer count registers * * Read them as close together as possible. Extend sync timer to 32 bits. * */ T1_EXTERN void T1_NOINLINE T1_CODE T1_GetTraceAndSyncTimeNoSuspPC( T1_uint8Least_t coreId, T1_syncTimerBase_t *pSyncTimerBase ); /*! * \brief Callout to obtain the synchronization trace timer value and the trace timer * value together. * \param[in] coreId the T1 logical core ID of the calling core * \param[out] pSyncTimerBase both timer count registers * * Read them as close together as possible. * There is no need to mask off any non-counting bits. * It is not time-critical but does run with interrupts disabled. It does * **need to be safe to call from user mode**, if T1_Handler() runs in user mode. * The default implementation assumes that T1_Handler() runs in supervisor * mode, or that both timers can be read in user mode. */ T1_EXTERN void T1_CODE T1_GetTraceAndSyncTimeNoSuspUMPC( T1_uint8Least_t coreId, T1_syncTimerBase_t *pSyncTimerBase ); #define T1_STOP_SEC_CODE #include "T1_MemMap.h" #define T1_START_SEC_CODE_FAST #include "T1_MemMap.h" /*! * \brief Callout to translate a duration in trace timer ticks to synchronization timer ticks. * * \note This callout function is generated into T1_configGen.c. * */ T1_EXTERN T1_CODE_FAST( T1_uint32_t ) T1_TraceToSyncTimerPC( T1_uint8Least_t coreId, T1_tickUint_t traceTime ); #if defined T1_NEAR_CODE_FAST T1_EXTERN T1_tickUint_t T1_NOINLINE T1_NEAR_CODE_FAST T1_NearTraceToSyncTimerPC( T1_uint8Least_t coreId, T1_tickUint_t traceTime ); #else # define T1_NearTraceToSyncTimerPC T1_TraceToSyncTimerPC #endif /* defined T1_NEAR_CODE_FAST */ T1_EXTERN T1_CODE_FAST( T1_tickUint_t ) T1_StartFlexStopwatch( T1_scopeFgConsts_t *pScopeConsts, T1_eventInfo_t eventInfo, T1_uint32_t traceTime, T1_uint32_t syncTime ); #define T1_STOP_SEC_CODE_FAST #include "T1_MemMap.h" /*----------------------------------------------------------------------------------*/ /*--- documentation ----------------------------------------------------------------*/ /*----------------------------------------------------------------------------------*/ #if defined T1_DOXYGEN_ONLY /*! \page USER_EVENTS User events T1 user events can be inserted anywhere in the application to observe specific events, log data in the T1.scope trace and/or be used to configure virtual stopwatches with the T1-HOST-SW. Configure user events {#USER_EVENTS_CONFIG} ===================== The user event must be declared in T1_AppInterface.h in order to get recognized in the T1-HOST-SW when a trace is downloaded. ~~~~~~~~~~~~~~~{.c} ...*/ /* @T1@ */ #define T1_OS_ERROR (0x21) /* @T1@ */ /*... ~~~~~~~~~~~~~~~ The inline XML syntax in the C comments must be exactly as in the example above, because these are parsed also by the T1-HOST-SW: - The body of the macro determines the user event identifier and has to be in the range 0x20 to 0x3F (32 to 63) and different from all other user event identifiers. - The "Name" field is configurable and can be changed by the user. It is possible to define the meaning of each value, which will be observed by user events. The additional information must be defined such as the following code. In this case the defined names will be shown instead of the values in the T1.scope view. ~~~~~~~~~~~~~~~{.c} ...*/ /* @T1@ */ /*enum { Error message 1 = 1, Error message 2 = 3, Error message 3 = 5 };*/ #define T1_OS_ERROR (0x21) /* @T1@ */ /*... ~~~~~~~~~~~~~~~ Trace user events {#TRACE_USER_EVENTS} ================= After the ID has been declared following \ref USER_EVENTS_CONFIG, it can be traced anywhere in the application in order to show the current value of a interesting variable in the trace using T1_TraceEvent(). Only 10 bits of data are traced with a user event, so the result is transferred modulo 1024. If a variable out of this range need to be observed, please see \ref USER_DATA_EVENTS. The following code shows an example of tracing a user event: ~~~~~~~~~~~~~~~{.c} T1_uint16Least_t osErrCode; ... osErrCode = fun1(...); T1_TraceEvent( T1_OS_ERROR, osErrCode ); ~~~~~~~~~~~~~~~ */ /*! * \page USER_DATA_EVENTS User data events T1 user data events can be inserted anywhere in the application. In comparison with user event, user data event can provide more ways to observe specific events or to log data. For example, printf can be mapped on to a T1 user data event so that string data is captured in the trace. Besides, not like user event, user data event can log any 16 bit or 32 bit variable, even an array or struct. Configure user data events {#USER_DATA_EVENTS_CONFIG} ========================== Like user event, the user data event must also be declared in T1_AppInterface.h in order for the T1-HOST-SW to interpret the event in a downloaded trace. ~~~~~~~~~~~~~~~{.c} ...*/ /* @T1@ */ #define T1_UDE_PRINTF (0x05) /* @T1@ */ /* @T1@ */ #define T1_UDE_16BitDataTrace (0x06) /* @T1@ */ /* @T1@ */ #define T1_UDE_32BitDataTrace (0x07) /* @T1@ */ /* @T1@ */ #define T1_UDE_BinaryTrace (0x08) /* @T1@ */ /*... ~~~~~~~~~~~~~~~ The inline XML syntax in the C comments must be exactly as in the example above, because these are parsed also by the T1-HOST-SW: - The body of the macro determines the user data event identifier and has to be in the range 0x00 to 0x1F (0 to 31) and different from all other user data event identifiers. - The "Name" field is configurable and can be changed by the user. Note on user data event {#USER_DATA_EVENTS_NOTE} ======================= Tracing a variable using a user data event must not be done while measuring this variable with a T1.flex data measurement. The T1.flex data measurement result would include the additional read access performed to trace the variable in a user data event, concealing the real result. To support this, user data events tracing should be guarded by an application feature. During a T1.flex data measurement, the application feature must be disabled: ~~~~~~~~~~~~~~~{.c} ...*/ if( T1_IsFeatureEnabled( T1_AF_ALLOW_TRACEDATA ) ) { T1_TraceUint32( T1_UDE_32BitDataTrace, tmp ); } /*... ~~~~~~~~~~~~~~~ Additionally, the T1 API reads data one byte at a time, variables updated by peripherals or other cores potentially could be traced incorrectly, with one byte coming from an old value and another byte coming from a newer value. In this case, the data should be atomically copied to an auto variable before being traced. If the variable read is not inherently atomic then some other mechanism must be used to protect against inconsistency In the following example u32value is 32-bit aligned in the memory of a TriCore processor, so the read is inherently atomic: ~~~~~~~~~~~~~~~{.c} ...*/ if( T1_IsFeatureEnabled( T1_AF_ALLOW_TRACEDATA ) ) { const T1_uint32_t tmp = u32value;/* Atomic read */ T1_TraceUint32( T1_UDE_32BitDataTrace, tmp ); } /*... ~~~~~~~~~~~~~~~ Specific API for user data events {#USER_DATA_EVENTS_API} ================================= Trace string ------------ String can be traced using T1_TraceString() or its variants, see \ref PC and \ref INTRPT. The following example implementation of fputc redirects a typical embedded printf function to generate T1 user data events. ~~~~~~~~~~~~~~~{.c} ...*/ int fputc( int c, FILE* ignored ) { static T1_uint8_t buff[20]; static T1_uint8Least_t buffIdx = 0u; if( (c == '\n') || (c == EOF) || (buffIdx == 20u) ) { if( T1_IsFeatureEnabled( T1_AF_ALLOW_TRACEDATA ) ) { T1_TraceString( T1_PRINTF, buff, buffIdx ); } buffIdx = 0u; } else { buff[buffIdx++] = (T1_uint8_t)c; } return c; } /*... ~~~~~~~~~~~~~~~ Trace integer ------------- Signed and unsigned integer can be traced using T1_TraceUint16(), T1_TraceUint32(), T1_TraceSint16(), T1_TraceSint32() or their variants, see \ref PC and \ref INTRPT. For example, the following implementation of 5msTask observes the variable "counter": ~~~~~~~~~~~~~~~{.c} void 5msTask( void ) { static T1_uint16_t counter = 0; ... ++counter; if( T1_IsFeatureEnabled( T1_AF_ALLOW_TRACEDATA ) ) { T1_TraceUint16( T1_UDE_16BitDataTrace, counter ); } ... } ~~~~~~~~~~~~~~~ Trace binary ------------ Structure or array can be traced using T1_TraceBinary() or its variants, see \ref PC and \ref INTRPT. For example, the following implementation of 5msTask observes the array "array1": ~~~~~~~~~~~~~~~{.c} void 5msTask( void ) { static T1_uint16_t array1[20]; ... if( T1_IsFeatureEnabled( T1_AF_ALLOW_TRACEDATA ) ) { T1_TraceBinary( T1_UDE_BinaryTrace, array1, sizeof(array1) ); } ... } ~~~~~~~~~~~~~~~ Trace address ------------- The value of a 32-bit address can be traced using T1_TraceAddr() or its variants, see \ref PC and \ref INTRPT. Advanced tracing {#USER_DATA_EVENTS_ADVANCED} ================ For less commonly used data type, such as a 64 bits variable or float variable, please contact support@gliwa.com for assistance. */ /*! \page USER_STOPWATCHES User stopwatches T1 stopwatches can be used in order to statically instrument any code fragment to either determine its core execution time or gross execution time via T1.scope and T1.cont and also allowing it to be supervised by T1.cont. It can also be used to determine data-age, the minimum and maximum time between a write access and the consecutive read accesses. Declaration {#USER_STOPWATCHES_DECLARATION} =========== In order to expose the ID of a stopwatch to the T1-HOST-SW as well as to the T1-TARGET-SW the following definition including the inline XML syntax is to be used in T1_AppInterface.h for any stopwatch assigned in the project: ~~~~~~~~~~~~~~~{.c} ...*/ /* @T1@ */ #define T1_SW_T1_HANDLER_CORE0 0u /* @T1@ */ /* @T1@ */ #define T1_SW_DATA_AGE_V_VEH 1u /* @T1@ */ /* @T1@ */ #define T1_SW_INTRPT 0u /* @T1@ */ /*... ~~~~~~~~~~~~~~~ The inline XML syntax in the C comments must be exactly as in the example above, because these are parsed also by the T1-HOST-SW: - The body of the macro determines the stopwatch identifier and has to be in the range 0x0 to 0x2FC (0 to 764) and different from all other stopwatch identifiers used on this core. - The "Name" field is configurable and can be changed by the user. - The "SID" field is the system identifier of the core, it is usually the core id incremented by 2, if all cores are used and no shifting occurs. The value is specified via the parameter -sid in T1_Cfg.inv per system. If no "SID" is given, the stopwatch is added to all cores, and it must be ensured that the number of stopwatches on each core is adjusted to accommodate the given stopwatch ID, in order that T1.cont can supervise its results. - The field "IsDataflow" can be set, as shown in the second example, to select data flow visualization in downloaded traces. Additionally, the number of user stopwatches per core must be defined. It can be done either by adding the parameter -numberOfUserStpws per system in T1_UserCfg.inv or by adding the macro T1_NOF_USER_STPWS_CORE in T1_AppInterface.h, in the previous example T1_NOF_USER_STPWS_CORE0 would be 2 and T1_NOF_USER_STPWS_CORE1 would be 1. Please note that if the macro and the parameter are both present, but with different values, an error will be generated during the generation. Please note that this macro controls how many user stopwatches are analyzed by T1.cont. The max number of stopwatches analyzed by T1.cont per core is 255. User stopwatches with an identifier larger or equal to T1_NOF_USER_STPWS_CORE can still be used with T1.scope, but are not analyzed by T1.cont. Default configuration {#USER_STOPWATCHES_DEFAULT_CONFIG} ===================== According to its ID, each stopwatch is initialized to record a CET, GET or data age time. A default configuration is generated that is active if the macro #T1_CONT_DEFAULT_CONFIG_STOPWATCH is defined. This is particularly useful when using large numbers of user stopwatches, as the manual configuration: - is time-consuming and potentially error-prone - needs to be maintained consistent with the number of configured user stopwatches for T1.cont to observe. This default configuration is generated in T1_configGen.c, here is an example with two cores: ~~~~~~~~~~~~~~~{.c} ...*/ # if defined T1_CONT_DEFAULT_CONFIG_STOPWATCH # define T1_START_SEC_CONST_8 # include "T1_MemMap.h" T1_stpwConfig_t T1_SEC_CONST_8 T1_stpwConfig0[1] = { T1_CONT_DEFAULT_CONFIG_STOPWATCH( 0u ) }; T1_stpwConfig_t T1_SEC_CONST_8 T1_stpwConfig1[1] = { T1_CONT_DEFAULT_CONFIG_STOPWATCH( 0u ) }; # define T1_STOP_SEC_CONST_8 # include "T1_MemMap.h" # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_stpwConfig_t * const T1_SEC_CONST_32 T1_stpwConfigPC[2] = { T1_stpwConfig0, T1_stpwConfig1 }; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* defined T1_CONT_DEFAULT_CONFIG_STOPWATCH */ /*... ~~~~~~~~~~~~~~~ Advanced configuration {#USER_STOPWATCHES_ADVANCED_CONFIG} ====================== If the default configuration is not suitable, for example because we require some CET stopwatches and some GET stopwatches, then #T1_CONT_DEFAULT_CONFIG_STOPWATCH must be undefined and the array initializers must be adapted as needed and added into T1_config.c. Please remember the difficulty in correctly maintaining such a manual configuration and only use it when necessary. The following example can be added in T1_config.c: ~~~~~~~~~~~~~~~{.c} ...*/ # if ! defined T1_CONT_DEFAULT_CONFIG_STOPWATCH /* * Advanced configuration example of user stopwatches * In this example, we take the default generated code from T1_configGen.c with * 2 cores as template and adapt it by configuring: * - on the first core: a CET stopwatch and a data-age stopwatch * - on the second core: a GET stopwatch. */ # define T1_START_SEC_CONST_8 # include "T1_MemMap.h" T1_stpwConfig_t T1_SEC_CONST_8 T1_stpwConfig0[2] = { /* Core0 SW0: CET */ T1_CONT_CET_STOPWATCH( T1_SW_T1_HANDLER_CORE0 ), /* Core0 SW1: Data age */ T1_CONT_DATA_AGE_STOPWATCH( T1_SW_DATA_AGE_V_VEH ) }; T1_stpwConfig_t T1_SEC_CONST_8 T1_stpwConfig1[1] = { /* Core1 SW0: GET */ T1_CONT_GET_STOPWATCH( T1_SW_INTRPT ) }; # define T1_STOP_SEC_CONST_8 # include "T1_MemMap.h" # define T1_START_SEC_CONST_32 # include "T1_MemMap.h" T1_stpwConfig_t * const T1_SEC_CONST_32 T1_stpwConfigPC[2] = { T1_stpwConfig0, T1_stpwConfig1 }; # define T1_STOP_SEC_CONST_32 # include "T1_MemMap.h" # endif /* ! defined T1_CONT_DEFAULT_CONFIG_STOPWATCH */ /*... ~~~~~~~~~~~~~~~ Please note that the size of each core specific array initializer in T1_config.c must match the number of stopwatches defined in T1_AppInterface.h. CET and GET stopwatches usage {#USER_STOPWATCHES_CET_GET} ============================= A stopwatch start event has to be traced at the beginning of the code fragment to be measured and a stopwatch stop event has to be traced at the end: ~~~~~~~~~~~~~~~{.c} void T1_AppHandler(void) { T1_TraceEvent(T1_STOPWATCH_START, T1_SW_T1HANDLER); T1_Handler(); T1_TraceEvent(T1_STOPWATCH_STOP, T1_SW_T1HANDLER); } ~~~~~~~~~~~~~~~ Data age stopwatches usage {#USER_STOPWATCHES_DATA_AGE} ========================== Starting from a write access to a variable, data age stopwatches allow to determine the minimum and maximum time of the consecutive read accesses in order to supervise possible constraint violations arising from outdated data read accesses. Please note that cross-core data-age are only possible using T1.flex with the T1-HOST-SW. A stopwatch start event has to be traced where any write access takes place: ~~~~~~~~~~~~~~~{.c} void set_v_veh( uint32_t val ) { T1_SuspendAllInterrupts( ); v_veh = val; T1_TraceEventNoSusp( T1_STOPWATCH_START, T1_SW_DATA_AGE_V_VEH ); T1_ResumeAllInterrupts( ); } ~~~~~~~~~~~~~~~ A stopwatch stop has to be traced where any read access takes place: ~~~~~~~~~~~~~~~{.c} uint32_t get_v_veh( void ) { uint32_t result; T1_SuspendAllInterrupts( ); result = v_veh; T1_TraceEventNoSusp( T1_STOPWATCH_STOP, T1_SW_DATA_AGE_V_VEH ); T1_ResumeAllInterrupts( ); return result; } ~~~~~~~~~~~~~~~ Special note on usage {#USER_STOPWATCHES_NOTES} ===================== Note that interrupt locks are nearly always required for meaningful data age stopwatches. Otherwise an interrupt, a task switch and an arbitrary amount of time can elapse between the actual data read/write and the stopwatch event. Consider the above example without interrupt locks, you see that you could even trace the stopwatch stop before the stopwatch start, if an interrupt separates the write from the trace event and that interrupt (calls code that) calls get_v_veh. GET stopwatch instrumentation must be done with similar care, with regard to preemption. In contrast, CET stopwatches rarely need such interrupt locks because the start and stop events occur in the same task or ISR instance and interrupting time gets subtracted. */ /*! * \page USER_TRIGGERS User triggers T1 user triggers can be inserted anywhere in the application to stop tracing and ensure that specific events or sequences are captured for download and visualization. It is possible to trigger a specific core with T1_SetStopTrigger() and T1_SetStopTriggerPC(). T1_AppInterface.c provides a default implementation of T1_AppSetStopTriggerAllCores() allowing to trigger all cores. Additionally the default implementation of T1_AppInit() allows to capture the start-up trace depending on the application feature T1_AF_TRACE_STARTUP, see \ref APP_FEATURES. \note After the initial start-up or re-starting the tracing, an entirely new trace is captured regardless of the parameter "afterXevents"! Thus, more events than "afterXevents" may be traced after the trigger point if the trace buffer needs to be filled. In general, in a downloaded trace, the trigger might be earlier than expected. Examples {#USER_TRIGGERS_EXAMPLES} ======== To capture a full buffer containing only events after this point in the code, we call: ~~~~~~~~~~~~~~~{.c} (void)T1_SetStopTrigger( T1_TRACE_BUFFER_ENTRIES_PC( coreId ) ); ~~~~~~~~~~~~~~~ To capture a buffer containing an equal number of events before and after this point in the code with the T1 logical core ID, we call: ~~~~~~~~~~~~~~~{.c} (void)T1_SetStopTriggerPC( coreId, T1_TRACE_BUFFER_ENTRIES_PC( coreId ) >> 1 ); ~~~~~~~~~~~~~~~ */ /*! * \page RUNNABLES Runnables Runnables can be instrumented in the T1-TARGET-SW or by using T1.flex in the T1-HOST-SW (see the GUI help for more information). T1 assumes that runnables are functions with no arguments and no return value that are called from tasks. There are two ways to do static instrumentation of runnables depending on the way the runnables are deployed. These ways define the kind of ID that T1 uses to trace those runnables: - a static runnable ID can be used for runnables that are called directly, unconditionally and in a fixed order from a single task. - dynamic runnable IDs must be used if the requirements for using a static runnable ID are not fulfilled. Typical cases are runnables called from two or more tasks and runnables which are called conditionally. It is important to note that only one of those two methods can be used in a single task. The table \ref RUNNABLES_SUMMARY "Static instrumentation of runnables" summarizes the differences between both methods.
Static instrumentation of runnables
Runnable ID Type Number of IDs used Supported by T1.cont Number of Events Traced
static 1 no With N Runnables, 2N or N+1
dynamic N° of runnables traced yes with event chains With N Runnables, 2N (T1.cont capable) or N+1
Configuration {#RUNNABLES_CONFIG} ============= Static runnable ID {#RUNNABLES_CONFIG_STATIC} ------------------ This method requires each runnable to be assigned to its unique respective task in the T1 project file which needs to be generated during the build process. The following parameter used in T1_UserCfg.inv: ~~~~~~~~~~~~~~~{.c} -staticRunnableID= [0..1023]. ~~~~~~~~~~~~~~~ will generate the following macro in T1_config.h: ~~~~~~~~~~~~~~~{.c} #define T1_STATIC_RUNNABLE_ID (u) ~~~~~~~~~~~~~~~ Dynamic runnable ID {#RUNNABLES_CONFIG_DYNAMIC} ------------------- This method requires each runnable traced to be assigned its own ID. The ID range is 0 to 1023 and the runnable IDs are specific to one T1 System ID. If the static runnable ID is also used in the project, no dynamic runnables can use this particular ID. It is necessary to create the runnables IDs in T1_AppInterface.h as follow: ~~~~~~~~~~~~~~~{.c} ...*/ /* @T1@ */ #define T1_Core2_10msRunnable0_ID 0u /* @T1@ */ /* @T1@ */ #define T1_Core2_10msRunnable1_ID 1u /* @T1@ */ /* @T1@ */ #define T1_Core2_10msRunnable2_ID 2u /* @T1@ */ /*... ~~~~~~~~~~~~~~~ Runnable tracing {#RUNNABLES_TRACING} ================ The runnables are traced with T1_TraceEvent() or its variants, see \ref PC and \ref INTRPT. N+1 events {#RUNNABLES_TRACING_SINGLE} ---------- If the runnable calls are back to back, i.e. there is no code being executed between runnables, then it is possible to instrument the runnables using consecutive #T1_RUNNABLE_START and one final #T1_RUNNABLE_STOP. Furthermore, if resource conservation is prioritized over runnable measurement precision, this is also the preferred method. ~~~~~~~~~~~~~~~{.c} ...*/ TASK(Core2_5msTask) { T1_TraceEvent(T1_RUNNABLE_START , T1_STATIC_RUNNABLE_ID); Core2_5msRunnable0( ); T1_TraceEvent(T1_RUNNABLE_START , T1_STATIC_RUNNABLE_ID); Core2_5msRunnable1( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_STATIC_RUNNABLE_ID); } TASK(Core2_10msTask) { T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable0_ID); Core2_10msRunnable0( ); T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable1_ID); Core2_10msRunnable1( ); T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable2_ID); Core2_10msRunnable2( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_Core2_10msRunnable2_ID); } /*... ~~~~~~~~~~~~~~~ 2N events {#RUNNABLES_TRACING_DOUBLE} --------- Explicit #T1_RUNNABLE_START/#T1_RUNNABLE_STOP pairs have to be used in order to obtain reliable measurements for the runnables when they are separated by: - explicit CPU yielding, e.g. a call to the OS scheduler. - a call to WaitEvent, GetSpinlock or a similar function. - any other significant code sequences not part of a runnable. This method is also required in order to use \ref EVENT_CHAINS to obtain T1.cont results with the dynamic runnable ID. ~~~~~~~~~~~~~~~{.c} ...*/ TASK(Core2_5msTask) { T1_TraceEvent(T1_RUNNABLE_START , T1_STATIC_RUNNABLE_ID); Core2_5msRunnable0( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_STATIC_RUNNABLE_ID); Os_Schedule( ); T1_TraceEvent(T1_RUNNABLE_START , T1_STATIC_RUNNABLE_ID); Core2_5msRunnable1( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_STATIC_RUNNABLE_ID); } TASK(Core2_10msTask) { EventMaskType ev; T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable0_ID); Core2_10msRunnable0( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_Core2_10msRunnable0_ID); WaitEvent( event1, event2 ); GetEvent( Core2_10msTask, ev); if( ev & event1 != 0 ) { T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable1_ID); Core2_10msRunnable1( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_Core2_10msRunnable1_ID); } if( ev & event2 != 0 ) { T1_TraceEvent(T1_RUNNABLE_START , T1_Core2_10msRunnable2_ID); Core2_10msRunnable2( ); T1_TraceEvent(T1_RUNNABLE_STOP , T1_Core2_10msRunnable2_ID); } } /*... ~~~~~~~~~~~~~~~ */ /*! * \page EXTERNAL_TRACEBUFFER External Trace Buffers T1 store the number of events + 1 in each core trace buffer. The preferred usage is to set the number of events using the invocation parameter -traceBufferEntries. It can be necessary to select the size of the T1 trace buffer outside of the T1-TARGET-SW build process (if part of the application is provided as library, or if the size depends on some configuration unrelated to the T1-TARGET-SW). How to Enable {#EXTERNAL_TRACEBUFFER_ENABLE} ============= It is necessary to set the invocation file parameter -externalTraceBuffer to true and -configBuffC to the path the generated T1_configBuff.c which will holds the trace buffer configuration externally. Configuration {#EXTERNAL_TRACEBUFFER_CONFIGURATION} ============= T1_configBuff.c contains the generated trace buffer configuration of each core. The number of events is set using the macro T1_EXT_TRACEBUFFER_ENTRIES_COREx with x being the core Id. If not defined, T1_EXT_TRACEBUFFER_ENTRIES_COREx is set using T1_TRACEBUFFER_ENTRIES_COREx (set by -traceBufferEntries). T1_EXT_TRACEBUFFER_ENTRIES_COREx can be defined globally or in T1_AppInterface.h to a different value, example for two cores: ~~~~~~~~~~~~~~~{.c} ...*/ /* number of event on core 0 */ #define T1_EXT_TRACEBUFFER_ENTRIES_CORE0 (500) /* number of event on core 1 */ #define T1_EXT_TRACEBUFFER_ENTRIES_CORE1 (1000) /*... ~~~~~~~~~~~~~~~ */ #endif /* defined T1_DOXYGEN_ONLY */ #endif /* T1_SCOPE_INTERFACE_H_ */