Mirrors_Framework/rtems
1
0
Fork 0
mirror of https://gitlab.rtems.org/rtems/rtos/rtems.git synced 2026-09-02 02:46:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

score: Delete dead copy and paste code

Browse Source
This commit is contained in:
Sebastian Huber
2016-06-08 15:48:02 +02:00
parent 4c19e59b5e
commit ec5d7f92fd
10 changed files with 5 additions and 1064 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpukit/score/cpu/bfin/rtems/score/cpu.h
-136
View File
@@ -849,146 +849,10 @@ void _CPU_Context_Initialize(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/**
* @defgroup CPUBitfield Processor Dependent Bitfield Manipulation
*
* This set of routines are used to implement fast searches for
* the most important ready task.
*/
/**@{**/
/**
* This definition is set to TRUE if the port uses the generic bitfield
* manipulation implementation.
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
/**
* This definition is set to TRUE if the port uses the data tables provided
* by the generic bitfield manipulation implementation.
* This can occur when actually using the generic bitfield manipulation
* implementation or when implementing the same algorithm in assembly
* language for improved performance. It is unlikely that a port will use
* the data if it has a bitfield scan instruction.
*/
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
/**
* This routine sets @a _output to the bit number of the first bit
* set in @a _value. @a _value is of CPU dependent type
* @a Priority_bit_map_Word. This type may be either 16 or 32 bits
* wide although only the 16 least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* -# What happens when run on a value of zero?
* -# Bits may be numbered from MSB to LSB or vice-versa.
* -# The numbering may be zero or one based.
* -# The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros @ref _CPU_Priority_Mask and
* @ref _CPU_Priority_bits_index. These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by @ref _CPU_Priority_Mask.
* The basic major and minor values calculated by @ref _Priority_Major
* and @ref _Priority_Minor are "massaged" by @ref _CPU_Priority_bits_index
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for @ref _Priority_Get_highest to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
@verbatim
- a series of 16 bit test instructions
- a "binary search using if's"
- _number = 0
if _value > 0x00ff
_value >>=8
_number = 8;
if _value > 0x0000f
_value >=8
_number += 4
_number += bit_set_table[ _value ]
@endverbatim
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
* @param[in] _value is the value to be scanned
* @param[in] _output is the first bit set
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
__asm__ ("bit(1);"):
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/** @} */
/**
* This routine builds the mask which corresponds to the bit fields
* as searched by @ref _CPU_Bitfield_Find_first_bit. See the discussion
* for that routine.
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/**
* @ingroup CPUBitfield
* This routine translates the bit numbers returned by
* @ref _CPU_Bitfield_Find_first_bit into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
* @param[in] _priority is the major or minor number to translate
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/* functions */
/**
cpukit/score/cpu/epiphany/rtems/score/cpu.h
+1 -98
View File
@@ -678,107 +678,10 @@ void _CPU_Context_Initialize(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/*
* This routine sets _output to the bit number of the first bit
* set in _value. _value is of CPU dependent type Priority_Bit_map_control.
* This type may be either 16 or 32 bits wide although only the 16
* least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* (1) What happens when run on a value of zero?
* (2) Bits may be numbered from MSB to LSB or vice-versa.
* (3) The numbering may be zero or one based.
* (4) The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
* _CPU_Priority_bits_index(). These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by _CPU_Priority_mask().
* The basic major and minor values calculated by _Priority_Major()
* and _Priority_Minor() are "massaged" by _CPU_Priority_bits_index()
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for _Priority_Get_highest() to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
* - a series of 16 bit test instructions
* - a "binary search using if's"
* - _number = 0
* if _value > 0x00ff
* _value >>=8
* _number = 8;
*
* if _value > 0x0000f
* _value >=8
* _number += 4
*
* _number += bit_set_table[ _value ]
*
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
*/
/* #define CPU_USE_GENERIC_BITFIELD_CODE FALSE */
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/*
* This routine builds the mask which corresponds to the bit fields
* as searched by _CPU_Bitfield_Find_first_bit(). See the discussion
* for that routine.
*
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
(1 << _bit_number)
#endif
/*
* This routine translates the bit numbers returned by
* _CPU_Bitfield_Find_first_bit() into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
typedef struct {
/* There is no CPU specific per-CPU state */
} CPU_Per_CPU_control;
cpukit/score/cpu/lm32/rtems/score/cpu.h
-135
View File
@@ -881,145 +881,10 @@ extern char _gp[];
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/**
* @defgroup CPUBitfield Processor Dependent Bitfield Manipulation
*
* This set of routines are used to implement fast searches for
* the most important ready task.
*/
/**@{**/
/**
* This definition is set to TRUE if the port uses the generic bitfield
* manipulation implementation.
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
/**
* This definition is set to TRUE if the port uses the data tables provided
* by the generic bitfield manipulation implementation.
* This can occur when actually using the generic bitfield manipulation
* implementation or when implementing the same algorithm in assembly
* language for improved performance. It is unlikely that a port will use
* the data if it has a bitfield scan instruction.
*/
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
/**
* This routine sets @a _output to the bit number of the first bit
* set in @a _value. @a _value is of CPU dependent type
* @a Priority_bit_map_Word. This type may be either 16 or 32 bits
* wide although only the 16 least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* -# What happens when run on a value of zero?
* -# Bits may be numbered from MSB to LSB or vice-versa.
* -# The numbering may be zero or one based.
* -# The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros @ref _CPU_Priority_Mask and
* @ref _CPU_Priority_bits_index. These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by @ref _CPU_Priority_Mask.
* The basic major and minor values calculated by @ref _Priority_Major
* and @ref _Priority_Minor are "massaged" by @ref _CPU_Priority_bits_index
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for @ref _Priority_Get_highest to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
@verbatim
- a series of 16 bit test instructions
- a "binary search using if's"
- _number = 0
if _value > 0x00ff
_value >>=8
_number = 8;
if _value > 0x0000f
_value >=8
_number += 4
_number += bit_set_table[ _value ]
@endverbatim
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
* @param[in] _value is the value to be scanned
* @param[in] _output is the first bit set
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/** @} */
/**
* This routine builds the mask which corresponds to the bit fields
* as searched by @ref _CPU_Bitfield_Find_first_bit. See the discussion
* for that routine.
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/**
* @ingroup CPUBitfield
* This routine translates the bit numbers returned by
* @ref _CPU_Bitfield_Find_first_bit into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
* @param[in] _priority is the major or minor number to translate
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/* functions */
/**
cpukit/score/cpu/m32c/rtems/score/cpu.h
-134
View File
@@ -869,144 +869,10 @@ void _CPU_Context_Restart_self(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/**
* @defgroup CPUBitfield Processor Dependent Bitfield Manipulation
*
* This set of routines are used to implement fast searches for
* the most important ready task.
*/
/**@{**/
/**
* This definition is set to TRUE if the port uses the generic bitfield
* manipulation implementation.
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
/**
* This definition is set to TRUE if the port uses the data tables provided
* by the generic bitfield manipulation implementation.
* This can occur when actually using the generic bitfield manipulation
* implementation or when implementing the same algorithm in assembly
* language for improved performance. It is unlikely that a port will use
* the data if it has a bitfield scan instruction.
*/
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
/**
* This routine sets @a _output to the bit number of the first bit
* set in @a _value. @a _value is of CPU dependent type
* @a Priority_bit_map_Word. This type may be either 16 or 32 bits
* wide although only the 16 least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* -# What happens when run on a value of zero?
* -# Bits may be numbered from MSB to LSB or vice-versa.
* -# The numbering may be zero or one based.
* -# The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros @ref _CPU_Priority_Mask and
* @ref _CPU_Priority_bits_index. These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by @ref _CPU_Priority_Mask.
* The basic major and minor values calculated by @ref _Priority_Major
* and @ref _Priority_Minor are "massaged" by @ref _CPU_Priority_bits_index
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for @ref _Priority_Get_highest to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
@verbatim
- a series of 16 bit test instructions
- a "binary search using if's"
- _number = 0
if _value > 0x00ff
_value >>=8
_number = 8;
if _value > 0x0000f
_value >=8
_number += 4
_number += bit_set_table[ _value ]
@endverbatim
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
* @param[in] _value is the value to be scanned
* @param[in] _output is the first bit set
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/**
* This routine builds the mask which corresponds to the bit fields
* as searched by @ref _CPU_Bitfield_Find_first_bit. See the discussion
* for that routine.
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/**
* This routine translates the bit numbers returned by
* @ref _CPU_Bitfield_Find_first_bit into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
* @param[in] _priority is the major or minor number to translate
*
* Port Specific Information:
*
* XXX document implementation including references if appropriate
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/** @} */
/* end of Priority handler macros */
/* functions */
/**
cpukit/score/cpu/mips/rtems/score/cpu.h
+1 -97
View File
@@ -882,106 +882,10 @@ void _CPU_Context_Initialize(
extern void mips_break( int error );
/* Bitfield handler macros */
/*
* This routine sets _output to the bit number of the first bit
* set in _value. _value is of CPU dependent type Priority_bit_map_Word.
* This type may be either 16 or 32 bits wide although only the 16
* least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* (1) What happens when run on a value of zero?
* (2) Bits may be numbered from MSB to LSB or vice-versa.
* (3) The numbering may be zero or one based.
* (4) The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
* _CPU_Priority_bits_index(). These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by _CPU_Priority_mask().
* The basic major and minor values calculated by _Priority_Major()
* and _Priority_Minor() are "massaged" by _CPU_Priority_bits_index()
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for _Priority_Get_highest() to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
* - a series of 16 bit test instructions
* - a "binary search using if's"
* - _number = 0
* if _value > 0x00ff
* _value >>=8
* _number = 8;
*
* if _value > 0x0000f
* _value >=8
* _number += 4
*
* _number += bit_set_table[ _value ]
*
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/*
* This routine builds the mask which corresponds to the bit fields
* as searched by _CPU_Bitfield_Find_first_bit(). See the discussion
* for that routine.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/*
* This routine translates the bit numbers returned by
* _CPU_Bitfield_Find_first_bit() into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/* functions */
/*
cpukit/score/cpu/moxie/rtems/score/cpu.h
+1 -106
View File
@@ -678,115 +678,10 @@ uint32_t _CPU_ISR_Get_level( void );
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/*
* This routine sets _output to the bit number of the first bit
* set in _value. _value is of CPU dependent type Priority_Bit_map_control.
* This type may be either 16 or 32 bits wide although only the 16
* least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* (1) What happens when run on a value of zero?
* (2) Bits may be numbered from MSB to LSB or vice-versa.
* (3) The numbering may be zero or one based.
* (4) The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
* _CPU_Priority_bits_index(). These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by _CPU_Priority_mask().
* The basic major and minor values calculated by _Priority_Major()
* and _Priority_Minor() are "massaged" by _CPU_Priority_bits_index()
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for _Priority_Get_highest() to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
* - a series of 16 bit test instructions
* - a "binary search using if's"
* - _number = 0
* if _value > 0x00ff
* _value >>=8
* _number = 8;
*
* if _value > 0x0000f
* _value >=8
* _number += 4
*
* _number += bit_set_table[ _value ]
*
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
* MOXIE Specific Information:
*
* XXX
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/*
* This routine builds the mask which corresponds to the bit fields
* as searched by _CPU_Bitfield_Find_first_bit(). See the discussion
* for that routine.
*
* MOXIE Specific Information:
*
* XXX
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/*
* This routine translates the bit numbers returned by
* _CPU_Bitfield_Find_first_bit() into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
* MOXIE Specific Information:
*
* XXX
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/* functions */
/*
cpukit/score/cpu/or1k/rtems/score/cpu.h
+1 -104
View File
@@ -673,113 +673,10 @@ void _CPU_Context_Initialize(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/*
* This routine sets _output to the bit number of the first bit
* set in _value. _value is of CPU dependent type Priority_Bit_map_control.
* This type may be either 16 or 32 bits wide although only the 16
* least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* (1) What happens when run on a value of zero?
* (2) Bits may be numbered from MSB to LSB or vice-versa.
* (3) The numbering may be zero or one based.
* (4) The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
* _CPU_Priority_bits_index(). These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by _CPU_Priority_mask().
* The basic major and minor values calculated by _Priority_Major()
* and _Priority_Minor() are "massaged" by _CPU_Priority_bits_index()
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for _Priority_Get_highest() to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
* - a series of 16 bit test instructions
* - a "binary search using if's"
* - _number = 0
* if _value > 0x00ff
* _value >>=8
* _number = 8;
*
* if _value > 0x0000f
* _value >=8
* _number += 4
*
* _number += bit_set_table[ _value ]
*
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
*/
/* #define CPU_USE_GENERIC_BITFIELD_CODE FALSE */
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
/* Get a value between 0 and N where N is the bit size */
/* This routine makes use of the fact that CPUCFGR defines
OB32S to have value 32, and OB64S to have value 64. If
this ever changes then this routine will fail. */
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
asm volatile ("l.mfspr %0,r0,0x2 \n\t"\
"l.andi %0,%0,0x60 \n\t"\
"l.ff1 %1,%1,r0 \n\t"\
"l.sub %0,%0,%1 \n\t" : "=&r" (_output), "+r" (_value));
#endif
/* end of Bitfield handler macros */
/*
* This routine builds the mask which corresponds to the bit fields
* as searched by _CPU_Bitfield_Find_first_bit(). See the discussion
* for that routine.
*
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
(1 << _bit_number)
#endif
/*
* This routine translates the bit numbers returned by
* _CPU_Bitfield_Find_first_bit() into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
typedef struct {
/* There is no CPU specific per-CPU state */
} CPU_Per_CPU_control;
cpukit/score/cpu/sh/cpu.c
-8
View File
@@ -203,14 +203,6 @@ void *_CPU_Thread_Idle_body( uintptr_t ignored )
}
#endif
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
uint8_t _bit_set_table[16] =
{ 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 2, 2, 1,0};
#endif
void _CPU_Context_Initialize(
Context_Control *_the_context,
void *_stack_base,
cpukit/score/cpu/sh/rtems/score/cpu.h
+1 -103
View File
@@ -650,112 +650,10 @@ void _CPU_Context_Initialize(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/*
* This routine sets _output to the bit number of the first bit
* set in _value. _value is of CPU dependent type Priority_bit_map_Word.
* This type may be either 16 or 32 bits wide although only the 16
* least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* (1) What happens when run on a value of zero?
* (2) Bits may be numbered from MSB to LSB or vice-versa.
* (3) The numbering may be zero or one based.
* (4) The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros _CPU_Priority_mask() and
* _CPU_Priority_bits_index(). These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by _CPU_Priority_mask().
* The basic major and minor values calculated by _Priority_Major()
* and _Priority_Minor() are "massaged" by _CPU_Priority_bits_index()
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for _Priority_Get_highest() to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
* - a series of 16 bit test instructions
* - a "binary search using if's"
* - _number = 0
* if _value > 0x00ff
* _value >>=8
* _number = 8;
*
* if _value > 0x0000f
* _value >=8
* _number += 4
*
* _number += bit_set_table[ _value ]
*
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
extern uint8_t _bit_set_table[];
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
_output = 0;\
if(_value > 0x00ff) \
{ _value >>= 8; _output = 8; } \
if(_value > 0x000f) \
{ _output += 4; _value >>= 4; } \
_output += _bit_set_table[ _value]; }
#endif
/* end of Bitfield handler macros */
/*
* This routine builds the mask which corresponds to the bit fields
* as searched by _CPU_Bitfield_Find_first_bit(). See the discussion
* for that routine.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/*
* This routine translates the bit numbers returned by
* _CPU_Bitfield_Find_first_bit() into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/* functions */
/*
cpukit/score/cpu/v850/rtems/score/cpu.h
-143
View File
@@ -833,153 +833,10 @@ void _CPU_Context_Initialize(
/* end of Fatal Error manager macros */
/* Bitfield handler macros */
/**
* @defgroup CPUBitfield Processor Dependent Bitfield Manipulation
*
* This set of routines are used to implement fast searches for
* the most important ready task.
*/
/**@{**/
/**
* This definition is set to TRUE if the port uses the generic bitfield
* manipulation implementation.
*/
#define CPU_USE_GENERIC_BITFIELD_CODE TRUE
/**
* This definition is set to TRUE if the port uses the data tables provided
* by the generic bitfield manipulation implementation.
* This can occur when actually using the generic bitfield manipulation
* implementation or when implementing the same algorithm in assembly
* language for improved performance. It is unlikely that a port will use
* the data if it has a bitfield scan instruction.
*
* Port Specific Information:
*
* There is no single v850 instruction to do a bit scan so there is
* no CPU specific implementation of bit field scanning. The empty
* stub routines are left as a place holder in case someone figures
* out how to do a v850 implementation better than the generic algorithm.
*/
#define CPU_USE_GENERIC_BITFIELD_DATA TRUE
/**
* This routine sets @a _output to the bit number of the first bit
* set in @a _value. @a _value is of CPU dependent type
* @a Priority_bit_map_Word. This type may be either 16 or 32 bits
* wide although only the 16 least significant bits will be used.
*
* There are a number of variables in using a "find first bit" type
* instruction.
*
* -# What happens when run on a value of zero?
* -# Bits may be numbered from MSB to LSB or vice-versa.
* -# The numbering may be zero or one based.
* -# The "find first bit" instruction may search from MSB or LSB.
*
* RTEMS guarantees that (1) will never happen so it is not a concern.
* (2),(3), (4) are handled by the macros @ref _CPU_Priority_Mask and
* @ref _CPU_Priority_bits_index. These three form a set of routines
* which must logically operate together. Bits in the _value are
* set and cleared based on masks built by @ref _CPU_Priority_Mask.
* The basic major and minor values calculated by @ref _Priority_Major
* and @ref _Priority_Minor are "massaged" by @ref _CPU_Priority_bits_index
* to properly range between the values returned by the "find first bit"
* instruction. This makes it possible for @ref _Priority_Get_highest to
* calculate the major and directly index into the minor table.
* This mapping is necessary to ensure that 0 (a high priority major/minor)
* is the first bit found.
*
* This entire "find first bit" and mapping process depends heavily
* on the manner in which a priority is broken into a major and minor
* components with the major being the 4 MSB of a priority and minor
* the 4 LSB. Thus (0 << 4) + 0 corresponds to priority 0 -- the highest
* priority. And (15 << 4) + 14 corresponds to priority 254 -- the next
* to the lowest priority.
*
* If your CPU does not have a "find first bit" instruction, then
* there are ways to make do without it. Here are a handful of ways
* to implement this in software:
*
@verbatim
- a series of 16 bit test instructions
- a "binary search using if's"
- _number = 0
if _value > 0x00ff
_value >>=8
_number = 8;
if _value > 0x0000f
_value >=8
_number += 4
_number += bit_set_table[ _value ]
@endverbatim
* where bit_set_table[ 16 ] has values which indicate the first
* bit set
*
* @param[in] _value is the value to be scanned
* @param[in] _output is the first bit set
*
* Port Specific Information:
*
* There is no single v850 instruction to do a bit scan so there is
* no CPU specific implementation of bit field scanning.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Bitfield_Find_first_bit( _value, _output ) \
{ \
(_output) = 0; /* do something to prevent warnings */ \
}
#endif
/* end of Bitfield handler macros */
/**
* This routine builds the mask which corresponds to the bit fields
* as searched by @ref _CPU_Bitfield_Find_first_bit. See the discussion
* for that routine.
*
* Port Specific Information:
*
* There is no single v850 instruction to do a bit scan so there is
* no CPU specific implementation of bit field scanning.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_Mask( _bit_number ) \
( 1 << (_bit_number) )
#endif
/**
* This routine translates the bit numbers returned by
* @ref _CPU_Bitfield_Find_first_bit into something suitable for use as
* a major or minor component of a priority. See the discussion
* for that routine.
*
* @param[in] _priority is the major or minor number to translate
*
* Port Specific Information:
*
* There is no single v850 instruction to do a bit scan so there is
* no CPU specific implementation of bit field scanning.
*/
#if (CPU_USE_GENERIC_BITFIELD_CODE == FALSE)
#define _CPU_Priority_bits_index( _priority ) \
(_priority)
#endif
/* end of Priority handler macros */
/** @} */
/* functions */
/**