Changeset 527


Ignore:
Timestamp:
Aug 30, 2018, 10:26:27 PM (3 years ago)
Author:
viala@…
Message:

Rewrite if-then-else return function into switch case.

For safety reason and performance:

1) Safety: GCC complain with a warning if you forgot an enum variant.
2) code-gen just outperform naive if-then-else.

Location:
trunk
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/boot/tsar_mips32/boot.c

    r524 r527  
    670670 * It returns the number of CP0s actually activated.
    671671 ********************************************************************************/
    672 static uint32_t boot_wake_all_cp0s()
     672static uint32_t boot_wake_all_cp0s( void )
    673673{
    674674    archinfo_header_t*  header;         // Pointer on ARCHINFO header
  • trunk/hal/tsar_mips32/core/hal_exception.c

    r505 r527  
    103103char * hal_mmu_exception_str( uint32_t code )
    104104{
    105     if     ( code == MMU_WRITE_PT1_UNMAPPED        ) return "WRITE_PT1_UNMAPPED";
    106     else if( code == MMU_WRITE_PT2_UNMAPPED        ) return "WRITE_PT2_UNMAPPED";
    107     else if( code == MMU_WRITE_PRIVILEGE_VIOLATION ) return "WRITE_PRIVILEGE_VIOLATION";
    108     else if( code == MMU_WRITE_ACCESS_VIOLATION    ) return "WRITE_ACCESS_VIOLATION";
    109     else if( code == MMU_WRITE_UNDEFINED_XTN       ) return "WRITE_UNDEFINED_XTN";
    110     else if( code == MMU_WRITE_PT1_ILLEGAL_ACCESS  ) return "WRITE_PT1_ILLEGAL_ACCESS";
    111     else if( code == MMU_WRITE_PT2_ILLEGAL_ACCESS  ) return "WRITE_PT2_ILLEGAL_ACCESS";
    112     else if( code == MMU_WRITE_DATA_ILLEGAL_ACCESS ) return "WRITE_DATA_ILLEGAL_ACCESS";
    113     else if( code == MMU_READ_PT1_UNMAPPED         ) return "READ_PT1_UNMAPPED";
    114     else if( code == MMU_READ_PT2_UNMAPPED         ) return "READ_PT2_UNMAPPED";
    115     else if( code == MMU_READ_PRIVILEGE_VIOLATION  ) return "READ_PRIVILEGE_VIOLATION";
    116     else if( code == MMU_READ_EXEC_VIOLATION       ) return "READ_EXEC_VIOLATION";
    117     else if( code == MMU_READ_UNDEFINED_XTN        ) return "READ_UNDEFINED_XTN";
    118     else if( code == MMU_READ_PT1_ILLEGAL_ACCESS   ) return "READ_PT1_ILLEGAL_ACCESS";
    119     else if( code == MMU_READ_PT2_ILLEGAL_ACCESS   ) return "READ_PT2_ILLEGAL_ACCESS";
    120     else if( code == MMU_READ_DATA_ILLEGAL_ACCESS  ) return "READ_DATA_ILLEGAL_ACCESS";
    121     else                                             return "undefined";
     105  switch (code) {
     106    case (MMU_WRITE_PT1_UNMAPPED):        return "WRITE_PT1_UNMAPPED";
     107    case (MMU_WRITE_PT2_UNMAPPED):        return "WRITE_PT2_UNMAPPED";
     108    case (MMU_WRITE_PRIVILEGE_VIOLATION): return "WRITE_PRIVILEGE_VIOLATION";
     109    case (MMU_WRITE_ACCESS_VIOLATION):    return "WRITE_ACCESS_VIOLATION";
     110    case (MMU_WRITE_UNDEFINED_XTN):       return "WRITE_UNDEFINED_XTN";
     111    case (MMU_WRITE_PT1_ILLEGAL_ACCESS):  return "WRITE_PT1_ILLEGAL_ACCESS";
     112    case (MMU_WRITE_PT2_ILLEGAL_ACCESS):  return "WRITE_PT2_ILLEGAL_ACCESS";
     113    case (MMU_WRITE_DATA_ILLEGAL_ACCESS): return "WRITE_DATA_ILLEGAL_ACCESS";
     114    case (MMU_READ_PT1_UNMAPPED):         return "READ_PT1_UNMAPPED";
     115    case (MMU_READ_PT2_UNMAPPED):         return "READ_PT2_UNMAPPED";
     116    case (MMU_READ_PRIVILEGE_VIOLATION):  return "READ_PRIVILEGE_VIOLATION";
     117    case (MMU_READ_EXEC_VIOLATION):       return "READ_EXEC_VIOLATION";
     118    case (MMU_READ_UNDEFINED_XTN):        return "READ_UNDEFINED_XTN";
     119    case (MMU_READ_PT1_ILLEGAL_ACCESS):   return "READ_PT1_ILLEGAL_ACCESS";
     120    case (MMU_READ_PT2_ILLEGAL_ACCESS):   return "READ_PT2_ILLEGAL_ACCESS";
     121    case (MMU_READ_DATA_ILLEGAL_ACCESS):  return "READ_DATA_ILLEGAL_ACCESS";
     122    default:                              return "undefined";
     123  }
    122124}
    123125
  • trunk/kernel/devices/dev_txt.c

    r492 r527  
    4949
    5050////////////////////////////////////////
    51 char * dev_txt_type_str( uint32_t type )
    52 {
    53     if     ( type == TXT_SYNC_WRITE ) return "TXT_SYNC_WRITE";
    54     else if( type == TXT_READ       ) return "TXT_READ";
    55     else if( type == TXT_WRITE      ) return "TXT_WRITE";
    56     else                              return "undefined";
     51const char * dev_txt_type_str( dev_txt_cmd_t type )
     52{
     53  switch (type) {
     54    case (TXT_SYNC_WRITE): return "TXT_SYNC_WRITE";
     55    case (TXT_READ):       return "TXT_READ";
     56    case (TXT_WRITE):      return "TXT_WRITE";
     57    default:               return "undefined";
     58  }
    5759}
    5860
  • trunk/kernel/devices/dev_txt.h

    r457 r527  
    7878 *****************************************************************************************/
    7979
    80 enum
     80typedef enum
    8181{
    8282    TXT_READ       = 0,
    8383    TXT_WRITE      = 1,
    8484    TXT_SYNC_WRITE = 2,
    85 };
     85} dev_txt_cmd_t;
    8686
    8787typedef struct txt_command_s
     
    113113 * @ type     : command type (TXT_READ / TXT_WRITE / TXT_SYNC_WRITE)
    114114 *****************************************************************************************/
    115 char * dev_txt_type_str( uint32_t type );
     115const char * dev_txt_type_str( dev_txt_cmd_t type );
    116116
    117117/******************************************************************************************
  • trunk/kernel/fs/vfs.c

    r492 r527  
    127127//////////////////////////////////////////////////////////////////////////////////////////
    128128
    129 char * vfs_inode_type_str( uint32_t type )
    130 {
    131     if     ( type == INODE_TYPE_FILE ) return "FILE";
    132     else if( type == INODE_TYPE_DIR  ) return "DIR ";
    133     else if( type == INODE_TYPE_FIFO ) return "FIFO";
    134     else if( type == INODE_TYPE_PIPE ) return "PIPE";
    135     else if( type == INODE_TYPE_SOCK ) return "SOCK";
    136     else if( type == INODE_TYPE_DEV  ) return "DEV ";
    137     else if( type == INODE_TYPE_SYML ) return "SYML";
    138     else                               return "undefined";
     129static const char * vfs_inode_type_str( vfs_inode_type_t type )
     130{
     131    switch ( type ) {
     132    case INODE_TYPE_FILE: return "FILE";
     133    case INODE_TYPE_DIR:  return "DIR ";
     134    case INODE_TYPE_FIFO: return "FIFO";
     135    case INODE_TYPE_PIPE: return "PIPE";
     136    case INODE_TYPE_SOCK: return "SOCK";
     137    case INODE_TYPE_DEV:  return "DEV ";
     138    case INODE_TYPE_SYML: return "SYML";
     139    default:              return "undefined";
     140    }
    139141}
    140142
  • trunk/kernel/kern/chdev.c

    r516 r527  
    5757char * chdev_func_str( uint32_t func_type )
    5858{
    59         if     ( func_type == DEV_FUNC_RAM ) return "RAM";
    60         else if( func_type == DEV_FUNC_ROM ) return "ROM";
    61         else if( func_type == DEV_FUNC_FBF ) return "FBF";
    62         else if( func_type == DEV_FUNC_IOB ) return "IOB";
    63         else if( func_type == DEV_FUNC_IOC ) return "IOC";
    64         else if( func_type == DEV_FUNC_MMC ) return "MMC";
    65         else if( func_type == DEV_FUNC_DMA ) return "DMA";
    66         else if( func_type == DEV_FUNC_NIC ) return "NIC";
    67         else if( func_type == DEV_FUNC_TIM ) return "TIM";
    68         else if( func_type == DEV_FUNC_TXT ) return "TXT";
    69         else if( func_type == DEV_FUNC_ICU ) return "ICU";
    70         else if( func_type == DEV_FUNC_PIC ) return "PIC";
    71     else                                 return "undefined";
     59  switch ( func_type ) {
     60    case DEV_FUNC_RAM: return "RAM";
     61    case DEV_FUNC_ROM: return "ROM";
     62    case DEV_FUNC_FBF: return "FBF";
     63    case DEV_FUNC_IOB: return "IOB";
     64    case DEV_FUNC_IOC: return "IOC";
     65    case DEV_FUNC_MMC: return "MMC";
     66    case DEV_FUNC_DMA: return "DMA";
     67    case DEV_FUNC_NIC: return "NIC";
     68    case DEV_FUNC_TIM: return "TIM";
     69    case DEV_FUNC_TXT: return "TXT";
     70    case DEV_FUNC_ICU: return "ICU";
     71    case DEV_FUNC_PIC: return "PIC";
     72    default:           return "undefined";
     73    }
    7274}
    7375
  • trunk/kernel/kern/do_syscall.c

    r503 r527  
    3030#include <syscalls.h>
    3131#include <shared_syscalls.h>
     32#include <syscalls_numbers.h>
    3233
    3334///////////////////////////////////////////////////////////////////////////////////////
     
    106107
    107108////////////////////////////////////
    108 const char * syscall_str( uint32_t index )
    109 {
    110         if     ( index == SYS_THREAD_EXIT    ) return "THREAD_EXIT";      // 0
    111         else if( index == SYS_THREAD_YIELD   ) return "THREAD_YIELD";     // 1
    112         else if( index == SYS_THREAD_CREATE  ) return "THREAD_CREATE";    // 2
    113         else if( index == SYS_THREAD_JOIN    ) return "THREAD_JOIN";      // 3
    114         else if( index == SYS_THREAD_DETACH  ) return "THREAD_DETACH";    // 4
    115         else if( index == SYS_THREAD_CANCEL  ) return "THREAD_CANCEL";    // 5
    116         else if( index == SYS_SEM            ) return "SEM";              // 6
    117         else if( index == SYS_CONDVAR        ) return "CONDVAR";          // 7
    118         else if( index == SYS_BARRIER        ) return "BARRIER";          // 8
    119         else if( index == SYS_MUTEX          ) return "MUTEX";            // 9
    120 
    121     else if( index == SYS_EXIT           ) return "EXIT";             // 10
    122     else if( index == SYS_MUNMAP         ) return "MUNMAP";           // 11
    123         else if( index == SYS_OPEN           ) return "OPEN";             // 12
    124         else if( index == SYS_MMAP           ) return "MMAP";             // 13
    125         else if( index == SYS_READ           ) return "READ";             // 14
    126         else if( index == SYS_WRITE          ) return "WRITE";            // 15
    127         else if( index == SYS_LSEEK          ) return "LSEEK";            // 16
    128         else if( index == SYS_CLOSE          ) return "CLOSE";            // 17
    129         else if( index == SYS_UNLINK         ) return "UNLINK";           // 18
    130         else if( index == SYS_PIPE           ) return "PIPE";             // 19
    131 
    132         else if( index == SYS_CHDIR          ) return "CHDIR";            // 20
    133         else if( index == SYS_MKDIR          ) return "MKDIR";            // 21
    134         else if( index == SYS_MKFIFO         ) return "MKFIFO";           // 22   
    135         else if( index == SYS_OPENDIR        ) return "OPENDIR";          // 23
    136         else if( index == SYS_READDIR        ) return "READDIR";          // 24
    137         else if( index == SYS_CLOSEDIR       ) return "CLOSEDIR";         // 25
    138         else if( index == SYS_GETCWD         ) return "GETCWD";           // 26
    139         else if( index == SYS_ISATTY         ) return "ISATTY";           // 27
    140         else if( index == SYS_ALARM          ) return "ALARM";            // 28
    141         else if( index == SYS_RMDIR          ) return "RMDIR";            // 29
    142 
    143         else if( index == SYS_UTLS           ) return "UTLS";             // 30
    144         else if( index == SYS_CHMOD          ) return "CHMOD";            // 31
    145         else if( index == SYS_SIGNAL         ) return "SIGNAL";           // 32
    146         else if( index == SYS_TIMEOFDAY      ) return "TIMEOFDAY";        // 33
    147         else if( index == SYS_KILL           ) return "KILL";             // 34
    148         else if( index == SYS_GETPID         ) return "GETPID";           // 35
    149         else if( index == SYS_FORK           ) return "FORK";             // 36
    150         else if( index == SYS_EXEC           ) return "EXEC";             // 37
    151         else if( index == SYS_STAT           ) return "STAT";             // 38
    152         else if( index == SYS_WAIT           ) return "WAIT";             // 39
    153 
    154     else if( index == SYS_GET_CONFIG     ) return "GET_CONFIG";       // 40
    155     else if( index == SYS_GET_CORE       ) return "GET_CORE";         // 41
    156     else if( index == SYS_GET_CYCLE      ) return "GET_CYCLE";        // 42
    157     else if( index == SYS_DISPLAY        ) return "DISPLAY";          // 43
    158         else if( index == SYS_THREAD_SLEEP   ) return "THREAD_SLEEP";     // 45
    159         else if( index == SYS_THREAD_WAKEUP  ) return "THREAD_WAKEUP";    // 46
    160         else if( index == SYS_TRACE          ) return "TRACE";            // 47
    161         else if( index == SYS_FG             ) return "FG";               // 48
    162         else if( index == SYS_IS_FG          ) return "IS_FG";            // 49
    163 
    164     else                                   return "undefined";   
     109const char * syscall_str( syscalls_t index )
     110{
     111    switch (index) {
     112    case SYS_THREAD_EXIT:                  return "THREAD_EXIT";      // 0
     113    case SYS_THREAD_YIELD:                 return "THREAD_YIELD";     // 1
     114    case SYS_THREAD_CREATE:                return "THREAD_CREATE";    // 2
     115    case SYS_THREAD_JOIN:                  return "THREAD_JOIN";      // 3
     116    case SYS_THREAD_DETACH:                return "THREAD_DETACH";    // 4
     117    case SYS_THREAD_CANCEL:                return "THREAD_CANCEL";    // 5
     118    case SYS_SEM :                         return "SEM";              // 6
     119    case SYS_CONDVAR:                      return "CONDVAR";          // 7
     120    case SYS_BARRIER:                      return "BARRIER";          // 8
     121    case SYS_MUTEX :                       return "MUTEX";            // 9
     122
     123    case SYS_EXIT:                         return "EXIT";             // 10
     124    case SYS_MUNMAP:                       return "MUNMAP";           // 11
     125    case SYS_OPEN:                         return "OPEN";             // 12
     126    case SYS_MMAP:                         return "MMAP";             // 13
     127    case SYS_READ:                         return "READ";             // 14
     128    case SYS_WRITE:                        return "WRITE";            // 15
     129    case SYS_LSEEK:                        return "LSEEK";            // 16
     130    case SYS_CLOSE:                        return "CLOSE";            // 17
     131    case SYS_UNLINK:                       return "UNLINK";           // 18
     132    case SYS_PIPE:                         return "PIPE";             // 19
     133
     134    case SYS_CHDIR:                        return "CHDIR";            // 20
     135    case SYS_MKDIR:                        return "MKDIR";            // 21
     136    case SYS_MKFIFO:                       return "MKFIFO";           // 22
     137    case SYS_OPENDIR:                      return "OPENDIR";          // 23
     138    case SYS_READDIR:                      return "READDIR";          // 24
     139    case SYS_CLOSEDIR:                     return "CLOSEDIR";         // 25
     140    case SYS_GETCWD:                       return "GETCWD";           // 26
     141    case SYS_ISATTY:                       return "ISATTY";           // 27
     142    case SYS_ALARM :                       return "ALARM";            // 28
     143    case SYS_RMDIR :                       return "RMDIR";            // 29
     144
     145    case SYS_UTLS:                         return "UTLS";             // 30
     146    case SYS_CHMOD :                       return "CHMOD";            // 31
     147    case SYS_SIGNAL:                       return "SIGNAL";           // 32
     148    case SYS_TIMEOFDAY:                    return "TIMEOFDAY";        // 33
     149    case SYS_KILL:                         return "KILL";             // 34
     150    case SYS_GETPID:                       return "GETPID";           // 35
     151    case SYS_FORK:                         return "FORK";             // 36
     152    case SYS_EXEC:                         return "EXEC";             // 37
     153    case SYS_STAT:                         return "STAT";             // 38
     154    case SYS_WAIT:                         return "WAIT";             // 39
     155
     156    case SYS_GET_CONFIG:                   return "GET_CONFIG";       // 40
     157    case SYS_GET_CORE:                     return "GET_CORE";         // 41
     158    case SYS_GET_CYCLE:                    return "GET_CYCLE";        // 42
     159    case SYS_DISPLAY:                      return "DISPLAY";          // 43
     160    case SYS_THREAD_SLEEP:                 return "THREAD_SLEEP";     // 45
     161    case SYS_THREAD_WAKEUP:                return "THREAD_WAKEUP";    // 46
     162    case SYS_TRACE:                        return "TRACE";            // 47
     163    case SYS_FG:                           return "FG";               // 48
     164    case SYS_IS_FG:                        return "IS_FG";            // 49
     165
     166    case SYS_UNDEFINED:
     167    default:                               return "undefined";
     168  }
    165169}
    166170
  • trunk/kernel/kern/process.c

    r514 r527  
    456456
    457457/////////////////////////////////////////////////
    458 char * process_action_str( uint32_t action_type )
    459 {
    460     if     ( action_type == BLOCK_ALL_THREADS   ) return "BLOCK";
    461     else if( action_type == UNBLOCK_ALL_THREADS ) return "UNBLOCK";
    462     else if( action_type == DELETE_ALL_THREADS  ) return "DELETE";
    463     else                                          return "undefined";
     458const char * process_action_str( process_sigactions_t action_type )
     459{
     460  switch ( action_type ) {
     461  case BLOCK_ALL_THREADS:   return "BLOCK";
     462  case UNBLOCK_ALL_THREADS: return "UNBLOCK";
     463  case DELETE_ALL_THREADS:  return "DELETE";
     464  default:                  return "undefined";
     465  }
    464466}
    465467
  • trunk/kernel/kern/process.h

    r503 r527  
    5656 ********************************************************************************************/
    5757
    58 enum process_sigactions
     58typedef enum process_sigactions
    5959{
    6060    BLOCK_ALL_THREADS    = 0x11,
    6161    UNBLOCK_ALL_THREADS  = 0x22,
    6262    DELETE_ALL_THREADS   = 0x33,
    63 };
     63} process_sigactions_t;
    6464
    6565/*********************************************************************************************
     
    275275 * @ return a string pointer.
    276276 ********************************************************************************************/
    277 char * process_action_str( uint32_t sigaction_type );
     277const char * process_action_str( process_sigactions_t sigaction_type );
    278278
    279279/*********************************************************************************************
  • trunk/kernel/kern/thread.c

    r518 r527  
    5353// This function returns a printable string for the thread type.
    5454//////////////////////////////////////////////////////////////////////////////////////
    55 char * thread_type_str( uint32_t type )
    56 {
    57     if     ( type == THREAD_USER   ) return "USR";
    58     else if( type == THREAD_RPC    ) return "RPC";
    59     else if( type == THREAD_DEV    ) return "DEV";
    60     else if( type == THREAD_IDLE   ) return "IDL";
    61     else                             return "undefined";
     55const char * thread_type_str( thread_type_t type )
     56{
     57  switch ( type ) {
     58  case THREAD_USER:   return "USR";
     59  case THREAD_RPC:    return "RPC";
     60  case THREAD_DEV:    return "DEV";
     61  case THREAD_IDLE:   return "IDL";
     62  default:            return "undefined";
     63  }
    6264}
    6365
  • trunk/kernel/kern/thread.h

    r503 r527  
    205205 * returns pointer on string.
    206206 **************************************************************************************/
    207 char * thread_type_str( uint32_t type );
     207const char * thread_type_str( thread_type_t type );
    208208
    209209/***************************************************************************************
  • trunk/kernel/syscalls/syscalls.h

    r506 r527  
    3737
    3838// debug:
    39 const char * syscall_str( uint32_t index );
     39const char * syscall_str( syscalls_t index );
    4040
    4141/******************************************************************************************
Note: See TracChangeset for help on using the changeset viewer.