Changeset ccd5434 in rtems


Ignore:
Timestamp:
Jan 7, 2016, 8:55:45 AM (3 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
master
Children:
1506658c
Parents:
3d1becf
git-author:
Sebastian Huber <sebastian.huber@…> (01/07/16 08:55:45)
git-committer:
Sebastian Huber <sebastian.huber@…> (01/11/16 07:47:01)
Message:

score: Introduce Thread_Entry_information

This avoids potential dead code in _Thread_Handler(). It gets rid of
the dangerous function pointer casts.

Update #2514.

Files:
3 added
33 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/arm/gdbarmsim/include/bsp.h

    r3d1becf rccd5434  
    4646 * @brief Support for simulated clock tick
    4747 */
    48 Thread clock_driver_sim_idle_body(uintptr_t);
     48void *clock_driver_sim_idle_body(uintptr_t);
    4949#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    5050
  • c/src/lib/libbsp/epiphany/epiphany_sim/include/bsp.h

    r3d1becf rccd5434  
    5757 * @{
    5858 */
    59 Thread clock_driver_sim_idle_body(uintptr_t);
     59void *clock_driver_sim_idle_body(uintptr_t);
    6060#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    6161/** @} */
  • c/src/lib/libbsp/i386/pc386/include/bsp.h

    r3d1becf rccd5434  
    199199   *  @brief Clock Tick Support Package
    200200   */
    201    Thread clock_driver_sim_idle_body(uintptr_t);
     201   void *clock_driver_sim_idle_body(uintptr_t);
    202202   #define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    203203  /* 
  • c/src/lib/libbsp/m32c/m32cbsp/include/bsp.h

    r3d1becf rccd5434  
    4343  */
    4444
    45 Thread clock_driver_sim_idle_body(uintptr_t);
     45void *clock_driver_sim_idle_body(uintptr_t);
    4646#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    4747
  • c/src/lib/libbsp/moxie/moxiesim/include/bsp.h

    r3d1becf rccd5434  
    2929
    3030/* support for simulated clock tick */
    31 Thread clock_driver_sim_idle_body(uintptr_t);
     31void *clock_driver_sim_idle_body(uintptr_t);
    3232#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    3333
  • c/src/lib/libbsp/sh/shsim/include/bsp.h

    r3d1becf rccd5434  
    4545/* Constants */
    4646
    47 Thread clock_driver_sim_idle_body(uintptr_t);
     47void *clock_driver_sim_idle_body(uintptr_t);
    4848#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    4949
  • c/src/lib/libbsp/shared/clock_driver_simidle.c

    r3d1becf rccd5434  
    4747 *  interrupt work but is enough for many tests.
    4848 */
    49 Thread clock_driver_sim_idle_body(
     49void *clock_driver_sim_idle_body(
    5050  uintptr_t   ignored
    5151)
  • c/src/lib/libbsp/shared/clockdrv_shell.h

    r3d1becf rccd5434  
    106106      while (
    107107        _Thread_Heir == _Thread_Executing
    108           && _Thread_Executing->Start.entry_point
    109             == (Thread_Entry) rtems_configuration_get_idle_task()
     108          && _Thread_Executing->Start.Entry.Kinds.Idle.entry
     109            == rtems_configuration_get_idle_task()
    110110      ) {
    111111        _Timecounter_Tick_simple(interval, (*tc->tc_get_timecount)(tc));
  • c/src/lib/libbsp/sparc64/niagara/include/bsp.h

    r3d1becf rccd5434  
    2727/* support for simulated clock tick */
    2828/*
    29 Thread clock_driver_sim_idle_body(uintptr_t);
     29void *clock_driver_sim_idle_body(uintptr_t);
    3030#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    3131*/
  • c/src/lib/libbsp/sparc64/usiii/include/bsp.h

    r3d1becf rccd5434  
    2828/* support for simulated clock tick */
    2929/*
    30 Thread clock_driver_sim_idle_body(uintptr_t);
     30void *clock_driver_sim_idle_body(uintptr_t);
    3131#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    3232*/
  • c/src/lib/libbsp/v850/gdbv850sim/include/bsp.h

    r3d1becf rccd5434  
    2929
    3030/* support for simulated clock tick */
    31 Thread clock_driver_sim_idle_body(uintptr_t);
     31void *clock_driver_sim_idle_body(uintptr_t);
    3232#define BSP_IDLE_TASK_BODY clock_driver_sim_idle_body
    3333
  • c/src/lib/libcpu/bfin/clock/clock.c

    r3d1becf rccd5434  
    3838  } while (
    3939    _Thread_Heir == _Thread_Executing
    40       && _Thread_Executing->Start.entry_point
    41         == (Thread_Entry) rtems_configuration_get_idle_task()
     40      && _Thread_Executing->Start.Entry.Kinds.Idle.entry
     41        == rtems_configuration_get_idle_task()
    4242  );
    4343#else
  • c/src/lib/libcpu/powerpc/mpc6xx/clock/c_clock.c

    r3d1becf rccd5434  
    108108    while (
    109109      _Thread_Heir == _Thread_Executing
    110         && _Thread_Executing->Start.entry_point
    111           == (Thread_Entry) rtems_configuration_get_idle_task()
     110        && _Thread_Executing->Start.Entry.Kinds.Idle.entry
     111          == rtems_configuration_get_idle_task()
    112112    ) {
    113113      tb += Clock_Decrementer_value;
  • cpukit/libmisc/cpuuse/cpuusagetop.c

    r3d1becf rccd5434  
    485485      rtems_object_get_name(thread->Object.id, sizeof(name), name);
    486486      if (name[0] == '\0')
    487         snprintf(name, sizeof(name) - 1, "(%p)", thread->Start.entry_point);
     487        snprintf(name, sizeof(name) - 1, "(%p)", thread->Start.Entry.Kinds.Numeric.entry);
    488488
    489489      (*data->plugin.print)(data->plugin.context,
  • cpukit/libmisc/monitor/mon-task.c

    r3d1becf rccd5434  
    2626    api = rtems_thread->API_Extensions[ THREAD_API_RTEMS ];
    2727
    28     canonical_task->entry = rtems_thread->Start.entry_point;
    29     canonical_task->argument = rtems_thread->Start.numeric_argument;
     28    canonical_task->entry = rtems_thread->Start.Entry;
    3029    canonical_task->stack = rtems_thread->Start.Initial_stack.area;
    3130    canonical_task->stack_size = rtems_thread->Start.Initial_stack.size;
  • cpukit/libmisc/monitor/monitor.h

    r3d1becf rccd5434  
    9696    rtems_name                 name;
    9797  /* end of common portion */
    98     Thread_Entry               entry;
    99     Thread_Entry_numeric_type  argument;
     98    Thread_Entry_information   entry;
    10099    void                      *stack;
    101100    uint32_t                   stack_size;
  • cpukit/posix/src/pthreadcreate.c

    r3d1becf rccd5434  
    5353)
    5454{
     55  Thread_Entry_information entry = {
     56    .adaptor = _Thread_Entry_adaptor_pointer,
     57    .Kinds = {
     58      .Pointer = {
     59        .entry = start_routine,
     60        .argument = arg
     61      }
     62    }
     63  };
    5564  const pthread_attr_t               *the_attr;
    5665  Priority_Control                    core_priority;
     
    220229   *  POSIX threads are allocated and started in one operation.
    221230   */
    222   status = _Thread_Start(
    223     the_thread,
    224     THREAD_START_POINTER,
    225     start_routine,
    226     arg,
    227     0,                    /* unused */
    228     NULL
    229   );
     231  status = _Thread_Start( the_thread, &entry, NULL );
    230232
    231233  #if defined(RTEMS_DEBUG)
  • cpukit/posix/src/pthreadinitthreads.c

    r3d1becf rccd5434  
    3838static void *_POSIX_Global_construction( void *arg )
    3939{
    40   Thread_Entry entry_point = (Thread_Entry) Configuration_POSIX_API
     40  Thread_Control           *executing = _Thread_Get_executing();
     41  Thread_Entry_information  entry = executing->Start.Entry;
     42
     43  entry.Kinds.Pointer.entry = Configuration_POSIX_API
    4144    .User_initialization_threads_table[ 0 ].thread_entry;
    4245
    4346  (void) arg;
    44   _Thread_Global_construction( entry_point );
     47  _Thread_Global_construction( executing, &entry );
    4548}
    4649
  • cpukit/rtems/src/taskinitusers.c

    r3d1becf rccd5434  
    3434static void _RTEMS_Global_construction( rtems_task_argument arg )
    3535{
    36   Thread_Entry entry_point = (Thread_Entry)
     36  Thread_Control           *executing = _Thread_Get_executing();
     37  Thread_Entry_information  entry = executing->Start.Entry;
     38
     39  entry.Kinds.Numeric.entry =
    3740    Configuration_RTEMS_API.User_initialization_tasks_table[ 0 ].entry_point;
    3841
    3942  (void) arg;
    40   _Thread_Global_construction( entry_point );
     43  _Thread_Global_construction( executing, &entry );
    4144}
    4245
  • cpukit/rtems/src/taskrestart.c

    r3d1becf rccd5434  
    2929  Thread_Control          *the_thread;
    3030  Objects_Locations        location;
     31  Thread_Entry_information entry;
    3132
    3233  the_thread = _Thread_Get( id, &location );
     
    3435
    3536    case OBJECTS_LOCAL:
    36       if ( _Thread_Restart( the_thread, _Thread_Executing, NULL, argument ) ) {
     37      entry = the_thread->Start.Entry;
     38      entry.Kinds.Numeric.argument = argument;
     39      if ( _Thread_Restart( the_thread, _Thread_Executing, &entry ) ) {
    3740        _Objects_Put( &the_thread->Object );
    3841        return RTEMS_SUCCESSFUL;
  • cpukit/rtems/src/taskstart.c

    r3d1becf rccd5434  
    4545)
    4646{
    47   Thread_Control          *the_thread;
    48   Objects_Locations        location;
    49   bool                     successfully_started;
     47  Thread_Entry_information entry = {
     48    .adaptor = _Thread_Entry_adaptor_numeric,
     49    .Kinds = {
     50      .Numeric = {
     51        .entry = entry_point,
     52        .argument = argument
     53      }
     54    }
     55  };
     56  Thread_Control    *the_thread;
     57  Objects_Locations  location;
     58  bool               successfully_started;
    5059
    5160  if ( entry_point == NULL )
     
    5665
    5766    case OBJECTS_LOCAL:
    58       successfully_started = _Thread_Start(
    59         the_thread,
    60         THREAD_START_NUMERIC,
    61         entry_point,
    62         NULL,
    63         argument,
    64         NULL
    65       );
     67      successfully_started = _Thread_Start( the_thread, &entry, NULL );
    6668
    6769      _Objects_Put( &the_thread->Object );
  • cpukit/sapi/include/rtems/config.h

    r3d1becf rccd5434  
    182182   * the default one provided with RTEMS.
    183183   */
    184   Thread                       (*idle_task)( uintptr_t );
     184  void                        *(*idle_task)( uintptr_t );
    185185
    186186  /**
  • cpukit/score/Makefile.am

    r3d1becf rccd5434  
    302302    src/threadstackallocate.c src/threadstackfree.c src/threadstart.c \
    303303    src/threadstartmultitasking.c src/iterateoverthreads.c
     304libscore_a_SOURCES += src/threadentryadaptoridle.c
     305libscore_a_SOURCES += src/threadentryadaptornumeric.c
     306libscore_a_SOURCES += src/threadentryadaptorpointer.c
    304307libscore_a_SOURCES += src/threadglobalconstruction.c
    305308libscore_a_SOURCES += src/threadtimeout.c
  • cpukit/score/include/rtems/score/thread.h

    r3d1becf rccd5434  
    8989typedef Timestamp_Control Thread_CPU_usage_t;
    9090
    91 /**
    92  *  The following defines the "return type" of a thread.
    93  *
    94  *  @note  This cannot always be right.  Some APIs have void
    95  *         tasks/threads, others return pointers, others may
    96  *         return a numeric value.  Hopefully a pointer is
    97  *         always at least as big as an uint32_t  . :)
    98  */
    99 typedef void *Thread;
     91/*
     92 * Only provided for backward compatiblity to not break application
     93 * configurations.
     94 */
     95typedef void *Thread RTEMS_DEPRECATED;
    10096
    10197/**
     
    111107
    112108/**
    113  *  The following defines the ways in which the entry point for a
    114  *  thread can be invoked.  Basically, it can be passed any
    115  *  combination/permutation of a pointer and an uint32_t   value.
    116  *
    117  *  @note For now, we are ignoring the return type.
    118  */
    119 typedef enum {
    120   THREAD_START_NUMERIC,
    121   THREAD_START_POINTER,
    122   #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
    123     THREAD_START_BOTH_POINTER_FIRST,
    124     THREAD_START_BOTH_NUMERIC_FIRST
    125   #endif
    126 } Thread_Start_types;
    127 
    128 /** This type corresponds to a very simple style thread entry point. */
    129 typedef Thread ( *Thread_Entry )( void );   /* basic type */
    130 
    131 /** This type corresponds to a thread entry point which takes a single
    132  *  unsigned thirty-two bit integer as an argument.
    133  */
    134 typedef Thread ( *Thread_Entry_numeric )( Thread_Entry_numeric_type );
    135 
    136 /** This type corresponds to a thread entry point which takes a single
    137  *  untyped pointer as an argument.
    138  */
    139 typedef Thread ( *Thread_Entry_pointer )( void * );
    140 
    141 /** This type corresponds to a thread entry point which takes a single
    142  *  untyped pointer and an unsigned thirty-two bit integer as arguments.
    143  */
    144 typedef Thread ( *Thread_Entry_both_pointer_first )( void *, Thread_Entry_numeric_type );
    145 
    146 /** This type corresponds to a thread entry point which takes a single
    147  *  unsigned thirty-two bit integer and an untyped pointer and an
    148  *  as arguments.
    149  */
    150 typedef Thread ( *Thread_Entry_both_numeric_first )( Thread_Entry_numeric_type, void * );
     109 * @brief Data for idle thread entry.
     110 */
     111typedef struct {
     112  void *( *entry )( uintptr_t argument );
     113} Thread_Entry_idle;
     114
     115/**
     116 * @brief Data for thread entry with one numeric argument and no return value.
     117 */
     118typedef struct {
     119  void ( *entry )( Thread_Entry_numeric_type argument );
     120  Thread_Entry_numeric_type argument;
     121} Thread_Entry_numeric;
     122
     123/**
     124 * @brief Data for thread entry with one pointer argument and a pointer return
     125 * value.
     126 */
     127typedef struct {
     128  void *( *entry )( void *argument  );
     129  void *argument;
     130} Thread_Entry_pointer;
     131
     132/**
     133 * @brief Thread entry information.
     134 */
     135typedef struct {
     136  /**
     137   * @brief Thread entry adaptor.
     138   *
     139   * Calls the corresponding thread entry with the right parameters.
     140   *
     141   * @param executing The executing thread.
     142   */
     143  void ( *adaptor )( Thread_Control *executing );
     144
     145  /**
     146   * @brief Thread entry data used by the adaptor to call the thread entry
     147   * function with the right parameters.
     148   */
     149  union {
     150    Thread_Entry_idle Idle;
     151    Thread_Entry_numeric Numeric;
     152    Thread_Entry_pointer Pointer;
     153  } Kinds;
     154} Thread_Entry_information;
    151155
    152156/**
     
    207211 */
    208212typedef struct {
    209   /** This field is the starting address for the thread. */
    210   Thread_Entry                         entry_point;
    211   /** This field indicates the how task is invoked. */
    212   Thread_Start_types                   prototype;
    213   /** This field is the pointer argument passed at thread start. */
    214   void                                *pointer_argument;
    215   /** This field is the numeric argument passed at thread start. */
    216   Thread_Entry_numeric_type            numeric_argument;
     213  /** This field contains the thread entry information. */
     214  Thread_Entry_information             Entry;
    217215  /*-------------- initial execution modes ----------------- */
    218216  /** This field indicates whether the thread was preemptible when
  • cpukit/score/include/rtems/score/threadimpl.h

    r3d1becf rccd5434  
    186186 *  thread competes with all other threads for CPU time.
    187187 *
    188  *  @param the_thread is the thread to be initialized
    189  *  @param the_prototype
    190  *  @param entry_point
    191  *  @param pointer_argument
    192  *  @param numeric_argument
     188 *  @param the_thread The thread to be started.
     189 *  @param entry The thread entry information.
    193190 *  @param[in,out] cpu The processor if used to start an idle thread
    194191 *  during system initialization.  Must be set to @c NULL to start a normal
     
    196193 */
    197194bool _Thread_Start(
    198   Thread_Control            *the_thread,
    199   Thread_Start_types         the_prototype,
    200   void                      *entry_point,
    201   void                      *pointer_argument,
    202   Thread_Entry_numeric_type  numeric_argument,
    203   Per_CPU_Control           *cpu
     195  Thread_Control                 *the_thread,
     196  const Thread_Entry_information *entry,
     197  Per_CPU_Control                *cpu
    204198);
    205199
    206200bool _Thread_Restart(
    207   Thread_Control            *the_thread,
    208   Thread_Control            *executing,
    209   void                      *pointer_argument,
    210   Thread_Entry_numeric_type  numeric_argument
     201  Thread_Control                 *the_thread,
     202  Thread_Control                 *executing,
     203  const Thread_Entry_information *entry
    211204);
    212205
     
    301294);
    302295
     296void _Thread_Entry_adaptor_idle( Thread_Control *executing );
     297
     298void _Thread_Entry_adaptor_numeric( Thread_Control *executing );
     299
     300void _Thread_Entry_adaptor_pointer( Thread_Control *executing );
     301
    303302/**
    304303 *  @brief Wrapper function for all threads.
     
    326325 * are present.
    327326 */
    328 void _Thread_Global_construction( Thread_Entry entry_point ) RTEMS_NO_RETURN;
     327void _Thread_Global_construction(
     328  Thread_Control                 *executing,
     329  const Thread_Entry_information *entry
     330) RTEMS_NO_RETURN;
    329331
    330332/**
  • cpukit/score/src/threadcreateidle.c

    r3d1becf rccd5434  
    2626static void _Thread_Create_idle_for_cpu( Per_CPU_Control *cpu )
    2727{
     28  Thread_Entry_information entry = {
     29    .adaptor = _Thread_Entry_adaptor_idle,
     30    .Kinds = {
     31      .Idle = {
     32        .entry = rtems_configuration_get_idle_task()
     33      }
     34    }
     35  };
    2836  Objects_Name    name;
    2937  Thread_Control *idle;
     
    6068  cpu->executing = idle;
    6169
    62   _Thread_Start(
    63     idle,
    64     THREAD_START_NUMERIC,
    65     rtems_configuration_get_idle_task(),
    66     NULL,
    67     0,
    68     cpu
    69   );
     70  _Thread_Start( idle, &entry, cpu );
    7071}
    7172
  • cpukit/score/src/threadglobalconstruction.c

    r3d1becf rccd5434  
    4545#endif
    4646
    47 void _Thread_Global_construction( Thread_Entry entry_point )
     47void _Thread_Global_construction(
     48  Thread_Control                 *executing,
     49  const Thread_Entry_information *entry
     50)
    4851{
    49   Thread_Control *executing;
    50 
    5152#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
    5253  /*
     
    5960
    6061  _Thread_Disable_dispatch();
    61 
    62   executing = _Thread_Executing;
    63   executing->Start.entry_point = entry_point;
    64 
    65   _Thread_Restart(
    66     executing,
    67     executing,
    68     executing->Start.pointer_argument,
    69     executing->Start.numeric_argument
    70   );
    71 
     62  _Thread_Restart( executing, executing, entry );
    7263  _Thread_Enable_dispatch();
    7364
  • cpukit/score/src/threadhandler.c

    r3d1becf rccd5434  
    9191   *  user thread entry point using the prototype expected.
    9292   */
    93   if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
    94     executing->Wait.return_argument =
    95       (*(Thread_Entry_numeric) executing->Start.entry_point)(
    96         executing->Start.numeric_argument
    97       );
    98   }
    99   #if defined(RTEMS_POSIX_API)
    100     else if ( executing->Start.prototype == THREAD_START_POINTER ) {
    101       executing->Wait.return_argument =
    102         (*(Thread_Entry_pointer) executing->Start.entry_point)(
    103           executing->Start.pointer_argument
    104         );
    105     }
    106   #endif
    107   #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
    108     else if ( executing->Start.prototype == THREAD_START_BOTH_POINTER_FIRST ) {
    109       executing->Wait.return_argument =
    110          (*(Thread_Entry_both_pointer_first) executing->Start.entry_point)(
    111            executing->Start.pointer_argument,
    112            executing->Start.numeric_argument
    113          );
    114     }
    115     else if ( executing->Start.prototype == THREAD_START_BOTH_NUMERIC_FIRST ) {
    116       executing->Wait.return_argument =
    117        (*(Thread_Entry_both_numeric_first) executing->Start.entry_point)(
    118          executing->Start.numeric_argument,
    119          executing->Start.pointer_argument
    120        );
    121     }
    122   #endif
     93  ( *executing->Start.Entry.adaptor )( executing );
    12394
    12495  /*
    125    *  In the switch above, the return code from the user thread body
    126    *  was placed in return_argument.  This assumed that if it returned
    127    *  anything (which is not supporting in all APIs), then it would be
     96   *  In the call above, the return code from the user thread body which return
     97   *  something was placed in return_argument.  This assumed that if it
     98   *  returned anything (which is not supporting in all APIs), then it would be
    12899   *  able to fit in a (void *).
    129100   */
  • cpukit/score/src/threadrestart.c

    r3d1becf rccd5434  
    357357
    358358bool _Thread_Restart(
    359   Thread_Control            *the_thread,
    360   Thread_Control            *executing,
    361   void                      *pointer_argument,
    362   Thread_Entry_numeric_type  numeric_argument
     359  Thread_Control                 *the_thread,
     360  Thread_Control                 *executing,
     361  const Thread_Entry_information *entry
    363362)
    364363{
    365364  if ( !_States_Is_dormant( the_thread->current_state ) ) {
    366     the_thread->Start.pointer_argument = pointer_argument;
    367     the_thread->Start.numeric_argument = numeric_argument;
     365    the_thread->Start.Entry = *entry;
    368366
    369367    _Thread_Request_life_change(
  • cpukit/score/src/threadstart.c

    r3d1becf rccd5434  
    2626
    2727bool _Thread_Start(
    28   Thread_Control            *the_thread,
    29   Thread_Start_types         the_prototype,
    30   void                      *entry_point,
    31   void                      *pointer_argument,
    32   Thread_Entry_numeric_type  numeric_argument,
    33   Per_CPU_Control           *cpu
     28  Thread_Control                 *the_thread,
     29  const Thread_Entry_information *entry,
     30  Per_CPU_Control                *cpu
    3431)
    3532{
    3633  if ( _States_Is_dormant( the_thread->current_state ) ) {
    37 
    38     the_thread->Start.entry_point      = (Thread_Entry) entry_point;
    39 
    40     the_thread->Start.prototype        = the_prototype;
    41     the_thread->Start.pointer_argument = pointer_argument;
    42     the_thread->Start.numeric_argument = numeric_argument;
    43 
     34    the_thread->Start.Entry = *entry;
    4435    _Thread_Load_environment( the_thread );
    4536
  • testsuites/samples/minimum/init.c

    r3d1becf rccd5434  
    2121#include <rtems/score/thread.h>
    2222
    23 /* forward declarations to avoid warnings */
    24 rtems_task Init(rtems_task_argument argument);
    25 
    26 rtems_task Init(
    27   rtems_task_argument ignored
    28 )
     23static void *Init( uintptr_t ignored )
    2924{
    3025  /* initialize application */
     
    3328
    3429  /* but in this case, just return and fall into a fatal error */
     30
     31  return NULL;
    3532}
    3633
     
    9996 *  initialization and then transforms itself into the idle task.
    10097 */
    101 #define CONFIGURE_IDLE_TASK_BODY (Thread_Entry_numeric) Init
     98#define CONFIGURE_IDLE_TASK_BODY Init
    10299#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
    103100
  • testsuites/sptests/sp54/init.c

    r3d1becf rccd5434  
    2323const char rtems_test_name[] = "SP 54";
    2424
    25 /* forward declarations to avoid warnings */
    26 rtems_task Init(rtems_task_argument argument);
    27 
    28 rtems_task Init(
    29   rtems_task_argument ignored
    30 )
     25static void *Init( uintptr_t ignored )
    3126{
    3227  rtems_status_code    status;
     
    6964 *  initialization and then transforms itself into the idle task.
    7065 */
    71 #define CONFIGURE_IDLE_TASK_BODY (Thread_Entry_numeric) Init
     66#define CONFIGURE_IDLE_TASK_BODY Init
    7267#define CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION
    7368
  • testsuites/sptests/spintrcritical_support/intrcritical.c

    r3d1becf rccd5434  
    176176static bool is_idle( const Thread_Control *thread )
    177177{
    178   return thread->Start.entry_point
    179     == (Thread_Entry) rtems_configuration_get_idle_task();
     178  return thread->Start.Entry.Kinds.Idle.entry
     179    == rtems_configuration_get_idle_task();
    180180}
    181181
Note: See TracChangeset for help on using the changeset viewer.