<s> return ( int16x8_t ) __builtin_neon_vld1_lanev8hi ( ( const __builtin_neon_hi * ) __a , __b , __c ) ;


return ( int16x8_t ) __builtin_neon_vld1_lanev8hi ( ( const __builtin_neon_hi * ) __a , __b , __c ) ;


return ( int32x4_t ) __builtin_neon_vld1_lanev4si ( ( const __builtin_neon_si * ) __a , __b , __c ) ;


return ( int8x16_t ) __builtin_neon_vld1_lanev16qi ( ( const __builtin_neon_qi * ) __a , __b , __c ) ;


<s> return ( uint16x8_t ) __builtin_neon_vld1_lanev8hi ( ( const __builtin_neon_hi * ) __a , ( int16x8_t ) __b , __c ) ;


<s> vld1q_p16 ( const poly16_t * __a ) {

return ( poly16x8_t ) __builtin_neon_vld1v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> vld1q_p16 ( const poly16_t * __a ) { return ( poly16x8_t ) __builtin_neon_vld1v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> return ( poly64x2_t ) __builtin_neon_vld1v2di ( ( const __builtin_neon_di * ) __a ) ;


<s> vld1q_p64 ( const poly64_t * __a ) { return ( poly64x2_t ) __builtin_neon_vld1v2di ( ( const __builtin_neon_di * ) __a ) ;


return ( poly8x16_t ) __builtin_neon_vld1v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1q_s64 ( const int64_t * __a ) { return ( int64x2_t ) __builtin_neon_vld1v2di ( ( const __builtin_neon_di * ) __a ) ;


<s> vld1q_s8 ( const int8_t * __a ) { return ( int8x16_t ) __builtin_neon_vld1v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1q_u16 ( const uint16_t * __a ) {

return ( uint16x8_t ) __builtin_neon_vld1v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> vld1q_u16 ( const uint16_t * __a ) { return ( uint16x8_t ) __builtin_neon_vld1v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> vld1q_u32 ( const uint32_t * __a ) { return ( uint32x4_t ) __builtin_neon_vld1v4si ( ( const __builtin_neon_si * ) __a ) ;


<s> vld1q_u32 ( const uint32_t * __a ) {

return ( uint32x4_t ) __builtin_neon_vld1v4si ( ( const __builtin_neon_si * ) __a ) ;


<s> vld1q_u64 ( const uint64_t * __a ) { return ( uint64x2_t ) __builtin_neon_vld1v2di ( ( const __builtin_neon_di * ) __a ) ;


<s> return ( uint64x2_t ) __builtin_neon_vld1v2di ( ( const __builtin_neon_di * ) __a ) ;


return ( uint8x16_t ) __builtin_neon_vld1v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1q_u8 ( const uint8_t * __a ) { return ( uint8x16_t ) __builtin_neon_vld1v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1_dup_f16 ( const float16_t * __a ) {


<s> vld1_dup_f32 ( const float32_t * __a ) {

return ( float32x2_t ) __builtin_neon_vld1_dupv2sf ( ( const __builtin_neon_sf * ) __a ) ;


<s> vld1_dup_p64 ( const poly64_t * __a ) {

return ( poly64x1_t ) __builtin_neon_vld1_dupdi ( ( const __builtin_neon_di * ) __a ) ;


<s> return ( poly64x1_t ) __builtin_neon_vld1_dupdi ( ( const __builtin_neon_di * ) __a ) ;


<s> vld1_dup_s16 ( const int16_t * __a ) {

return ( int16x4_t ) __builtin_neon_vld1_dupv4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> return ( int64x1_t ) __builtin_neon_vld1_dupdi ( ( const __builtin_neon_di * ) __a ) ;


<s> vld1_dup_s8 ( const int8_t * __a ) {

return ( int8x8_t ) __builtin_neon_vld1_dupv8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> return ( uint16x4_t ) __builtin_neon_vld1_dupv4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> return ( uint32x2_t ) __builtin_neon_vld1_dupv2si ( ( const __builtin_neon_si * ) __a ) ;


<s> vld1_dup_u8 ( const uint8_t * __a ) { return ( uint8x8_t ) __builtin_neon_vld1_dupv8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1_dup_u8 ( const uint8_t * __a ) {

return ( uint8x8_t ) __builtin_neon_vld1_dupv8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld1_f16 ( const float16_t * __a ) { return __builtin_neon_vld1v4hf ( __a ) ;


<s> return ( float32x2_t ) __builtin_neon_vld1v2sf ( ( const __builtin_neon_sf * ) __a ) ;


<s> vld1_f32 ( const float32_t * __a ) { return ( float32x2_t ) __builtin_neon_vld1v2sf ( ( const __builtin_neon_sf * ) __a ) ;


<s> return vset_lane_f16 ( * __a , __b , __c ) ;


return ( poly16x4_t ) __builtin_neon_vld1_lanev4hi ( ( const __builtin_neon_hi * ) __a , ( int16x4_t ) __b , __c ) ;


return ( int16x4_t ) __builtin_neon_vld1_lanev4hi ( ( const __builtin_neon_hi * ) __a , __b , __c ) ;


<s> return ( int16x4_t ) __builtin_neon_vld1_lanev4hi ( ( const __builtin_neon_hi * ) __a , __b , __c ) ;


<s> return ( int8x8_t ) __builtin_neon_vld1_lanev8qi ( ( const __builtin_neon_qi * ) __a , __b , __c ) ;


return ( int8x8_t ) __builtin_neon_vld1_lanev8qi ( ( const __builtin_neon_qi * ) __a , __b , __c ) ;


return ( uint32x2_t ) __builtin_neon_vld1_lanev2si ( ( const __builtin_neon_si * ) __a , ( int32x2_t ) __b , __c ) ;


<s> return ( uint64x1_t ) __builtin_neon_vld1_lanedi ( ( const __builtin_neon_di * ) __a , ( int64x1_t ) __b , __c ) ;


<s> return ( uint8x8_t ) __builtin_neon_vld1_lanev8qi ( ( const __builtin_neon_qi * ) __a , ( int8x8_t ) __b , __c ) ;


<s> vld1_p16 ( const poly16_t * __a ) { return ( poly16x4_t ) __builtin_neon_vld1v4hi ( ( const __builtin_neon_hi * ) __a ) ;


return ( poly64x1_t ) __builtin_neon_vld1di ( ( const __builtin_neon_di * ) __a ) ;


<s> return ( poly64x1_t ) __builtin_neon_vld1di ( ( const __builtin_neon_di * ) __a ) ;


<s> return ( poly8x8_t ) __builtin_neon_vld1v8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vld1v2si ( ( const __builtin_neon_si * ) __a ) ;


<s> return ( int64x1_t ) __builtin_neon_vld1di ( ( const __builtin_neon_di * ) __a ) ;


<s> return ( int8x8_t ) __builtin_neon_vld1v8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> return ( uint16x4_t ) __builtin_neon_vld1v4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> return ( uint64x1_t ) __builtin_neon_vld1di ( ( const __builtin_neon_di * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld2v8bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> __rv . __o = __builtin_neon_vld2_dupv8bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> __rv . __o = __builtin_neon_vld2v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld2v4si ( ( const __builtin_neon_si * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld2v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> vld2q_u16 ( const uint16_t * __a ) {


<s> vld2_dup_p8 ( const poly8_t * __a ) {


<s> __rv . __o = __builtin_neon_vld2_dupv4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld2v8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3v8bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> __rv . __o = __builtin_neon_vld3v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3_dupv4bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> __rv . __o = __builtin_neon_vld3_dupdi ( ( const __builtin_neon_di * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3_dupv8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3_dupv4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> vld3_dup_u32 ( const uint32_t * __a ) {


<s> __rv . __o = __builtin_neon_vld3_dupv2si ( ( const __builtin_neon_si * ) __a ) ;


<s> vld3_dup_u64 ( const uint64_t * __a ) {


<s> __rv . __o = __builtin_neon_vld3v2sf ( ( const __builtin_neon_sf * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3v4hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld3v2si ( ( const __builtin_neon_si * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld4v8bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> __rv . __o = __builtin_neon_vld4v4si ( ( const __builtin_neon_si * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld4v16qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld4v8hi ( ( const __builtin_neon_hi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld4_dupv4bf ( ( const __builtin_neon_bf * ) __ptr ) ;


<s> vld4_dup_u16 ( const uint16_t * __a ) {


<s> __rv . __o = __builtin_neon_vld4_dupdi ( ( const __builtin_neon_di * ) __a ) ;


<s> vld4_f32 ( const float32_t * __a ) {


<s> __rv . __o = __builtin_neon_vld4v8qi ( ( const __builtin_neon_qi * ) __a ) ;


<s> __rv . __o = __builtin_neon_vld4v2si ( ( const __builtin_neon_si * ) __a ) ;


<s> vmaxnmq_f32 ( float32x4_t a , float32x4_t b ) { return ( float32x4_t ) __builtin_neon_vmaxnmv4sf ( a , b ) ;


<s> return __builtin_neon_vmaxnmv4hf ( __a , __b ) ;


<s> vmaxnm_f32 ( float32x2_t a , float32x2_t b ) { return ( float32x2_t ) __builtin_neon_vmaxnmv2sf ( a , b ) ;


<s> return __builtin_neon_vmaxfv8hf ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vmaxsv4si ( __a , __b ) ;


<s> return ( int8x16_t ) __builtin_neon_vmaxsv16qi ( __a , __b ) ;


<s> return __builtin_neon_vmaxfv4hf ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vmaxsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vmaxsv8qi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vmaxuv4hi ( ( int16x4_t ) __a , ( int16x4_t ) __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vmaxuv2si ( ( int32x2_t ) __a , ( int32x2_t ) __b ) ;


<s> return __builtin_neon_vminnmv4hf ( __a , __b ) ;


<s> return __builtin_neon_vminfv8hf ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vminsv4si ( __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vminuv16qi ( ( int8x16_t ) __a , ( int8x16_t ) __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vminsv4hi ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vmovlsv4hi ( __a ) ;


return ( int16x8_t ) __builtin_neon_vmovlsv8qi ( __a ) ;


<s> return ( uint32x4_t ) __builtin_neon_vmovluv4hi ( ( int16x4_t ) __a ) ;


<s> return ( uint64x2_t ) __builtin_neon_vmovluv2si ( ( int32x2_t ) __a ) ;


return ( uint16x8_t ) __builtin_neon_vmovluv8qi ( ( int8x8_t ) __a ) ;


return ( int8x8_t ) __builtin_neon_vmovnv8hi ( __a ) ;


return ( int16x4_t ) __builtin_neon_vmovnv4si ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vmovnv2di ( __a ) ;


<s> return ( uint8x8_t ) __builtin_neon_vmovnv8hi ( ( int16x8_t ) __a ) ;


<s> return ( uint16x4_t ) __builtin_neon_vmovnv4si ( ( int32x4_t ) __a ) ;


return ( uint32x2_t ) __builtin_neon_vmovnv2di ( ( int64x2_t ) __a ) ;


<s> return __builtin_neon_vdup_nv8hf ( __a ) ;


<s> return ( poly16x8_t ) __builtin_neon_vdup_nv8hi ( ( __builtin_neon_hi ) __a ) ;


return ( poly8x16_t ) __builtin_neon_vdup_nv16qi ( ( __builtin_neon_qi ) __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vdup_nv4si ( ( __builtin_neon_si ) __a ) ;


<s> return ( int8x16_t ) __builtin_neon_vdup_nv16qi ( ( __builtin_neon_qi ) __a ) ;


return ( uint16x8_t ) __builtin_neon_vdup_nv8hi ( ( __builtin_neon_hi ) __a ) ;


<s> return ( uint32x4_t ) __builtin_neon_vdup_nv4si ( ( __builtin_neon_si ) __a ) ;


return ( uint8x16_t ) __builtin_neon_vdup_nv16qi ( ( __builtin_neon_qi ) __a ) ;


<s> return ( uint8x16_t ) __builtin_neon_vdup_nv16qi ( ( __builtin_neon_qi ) __a ) ;


<s> return __builtin_neon_vdup_nv4hf ( __a ) ;


return ( float32x2_t ) __builtin_neon_vdup_nv2sf ( ( __builtin_neon_sf ) __a ) ;


<s> return ( poly16x4_t ) __builtin_neon_vdup_nv4hi ( ( __builtin_neon_hi ) __a ) ;


return ( poly8x8_t ) __builtin_neon_vdup_nv8qi ( ( __builtin_neon_qi ) __a ) ;


<s> return ( int16x4_t ) __builtin_neon_vdup_nv4hi ( ( __builtin_neon_hi ) __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vdup_nv2si ( ( __builtin_neon_si ) __a ) ;


<s> return ( int64x1_t ) __builtin_neon_vdup_ndi ( ( __builtin_neon_di ) __a ) ;


<s> return ( int8x8_t ) __builtin_neon_vdup_nv8qi ( ( __builtin_neon_qi ) __a ) ;


return ( uint16x4_t ) __builtin_neon_vdup_nv4hi ( ( __builtin_neon_hi ) __a ) ;


<s> return ( uint16x4_t ) __builtin_neon_vdup_nv4hi ( ( __builtin_neon_hi ) __a ) ;


return ( uint32x2_t ) __builtin_neon_vdup_nv2si ( ( __builtin_neon_si ) __a ) ;


<s> return ( uint8x8_t ) __builtin_neon_vdup_nv8qi ( ( __builtin_neon_qi ) __a ) ;


<s> return ( poly128_t ) __builtin_arm_crypto_vmullp64 ( ( uint64_t ) __t1 , ( uint64_t ) __t2 ) ;


<s> return ( uint32x4_t ) __builtin_neon_vmullu_nv4hi ( ( int16x4_t ) __a , ( __builtin_neon_hi ) __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vmullu_nv2si ( ( int32x2_t ) __a , ( __builtin_neon_si ) __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vmullsv2si ( __a , __b ) ;


<s> return __builtin_neon_vmulfv8hf ( __a , __b ) ;


<s> return ( float32x4_t ) __builtin_neon_vmulfv4sf ( __a , __b ) ;


<s> return ( float32x4_t ) __builtin_neon_vmul_nv4sf ( __a , ( __builtin_neon_sf ) __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vmul_nv4si ( __a , ( __builtin_neon_si ) __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vmul_nv8hi ( ( int16x8_t ) __a , ( __builtin_neon_hi ) __b ) ;


<s> return __builtin_neon_vmulfv4hf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_neon_vmulfv2sf ( __a , __b ) ;


<s> return __builtin_neon_vmul_nv4hf ( __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vmul_nv2si ( ( int32x2_t ) __a , ( __builtin_neon_si ) __b ) ;


<s> return ( poly8x8_t ) __builtin_neon_vmulpv8qi ( ( int8x8_t ) __a , ( int8x8_t ) __b ) ;


return ( int16x8_t ) __builtin_neon_vmvnv8hi ( __a ) ;


<s> return ( int16x8_t ) __builtin_neon_vmvnv8hi ( __a ) ;


return ( int8x16_t ) __builtin_neon_vmvnv16qi ( __a ) ;


<s> return ( uint16x8_t ) __builtin_neon_vmvnv8hi ( ( int16x8_t ) __a ) ;


return ( uint32x4_t ) __builtin_neon_vmvnv4si ( ( int32x4_t ) __a ) ;


<s> return ( uint8x16_t ) __builtin_neon_vmvnv16qi ( ( int8x16_t ) __a ) ;


<s> return ( poly8x8_t ) __builtin_neon_vmvnv8qi ( ( int8x8_t ) __a ) ;


<s> return ( int16x4_t ) __builtin_neon_vmvnv4hi ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vmvnv2si ( __a ) ;


return ( int8x8_t ) __builtin_neon_vmvnv8qi ( __a ) ;


return ( uint16x4_t ) __builtin_neon_vmvnv4hi ( ( int16x4_t ) __a ) ;


return ( uint32x2_t ) __builtin_neon_vmvnv2si ( ( int32x2_t ) __a ) ;


<s> return ( uint8x8_t ) __builtin_neon_vmvnv8qi ( ( int8x8_t ) __a ) ;


return __builtin_neon_vnegv8hf ( __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vnegv4si ( __a ) ;


<s> return ( int8x16_t ) __builtin_neon_vnegv16qi ( __a ) ;


<s> return __builtin_neon_vnegv4hf ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vnegv2si ( __a ) ;


return ( int8x8_t ) __builtin_neon_vnegv8qi ( __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vpadalsv8hi ( __a , __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vpadalsv16qi ( __a , __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vpadaluv4si ( ( int64x2_t ) __a , ( int32x4_t ) __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vpadalsv4hi ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vpadalsv2si ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vpadalsv8qi ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vpaddlsv8hi ( __a ) ;


return ( int64x2_t ) __builtin_neon_vpaddlsv4si ( __a ) ;


<s> return ( int64x2_t ) __builtin_neon_vpaddlsv4si ( __a ) ;


return ( uint32x4_t ) __builtin_neon_vpaddluv8hi ( ( int16x8_t ) __a ) ;


<s> return ( uint64x2_t ) __builtin_neon_vpaddluv4si ( ( int32x4_t ) __a ) ;


return ( uint16x8_t ) __builtin_neon_vpaddluv16qi ( ( int8x16_t ) __a ) ;


<s> return ( int64x1_t ) __builtin_neon_vpaddlsv2si ( __a ) ;


return ( int16x4_t ) __builtin_neon_vpaddlsv8qi ( __a ) ;


return ( uint32x2_t ) __builtin_neon_vpaddluv4hi ( ( int16x4_t ) __a ) ;


return ( uint16x4_t ) __builtin_neon_vpaddluv8qi ( ( int8x8_t ) __a ) ;


<s> return __builtin_neon_vpaddv4hf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_neon_vpaddv2sf ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vpaddv4hi ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vpaddv8qi ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vpaddv8qi ( ( int8x8_t ) __a , ( int8x8_t ) __b ) ;


<s> return __builtin_neon_vpmaxfv4hf ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vpmaxsv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vpmaxsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vpmaxsv8qi ( __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vpmaxuv2si ( ( int32x2_t ) __a , ( int32x2_t ) __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vpmaxuv8qi ( ( int8x8_t ) __a , ( int8x8_t ) __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vpminsv2si ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vpminuv4hi ( ( int16x4_t ) __a , ( int16x4_t ) __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vpminuv8qi ( ( int8x8_t ) __a , ( int8x8_t ) __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vqabsv8hi ( __a ) ;


return ( int16x8_t ) __builtin_neon_vqabsv8hi ( __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vqabsv4si ( __a ) ;


<s> return ( int8x16_t ) __builtin_neon_vqabsv16qi ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vqabsv2si ( __a ) ;


<s> return ( int8x8_t ) __builtin_neon_vqabsv8qi ( __a ) ;


<s> return ( int16x8_t ) __builtin_neon_vqaddsv8hi ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vqadduv8hi ( ( int16x8_t ) __a , ( int16x8_t ) __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqaddsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vqaddsv8qi ( __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vqadduv2si ( ( int32x2_t ) __a , ( int32x2_t ) __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vqaddudi ( ( int64x1_t ) __a , ( int64x1_t ) __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vqdmulhv8hi ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqdmulhv4si ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vqdmulh_nv4hi ( __a , ( __builtin_neon_hi ) __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqdmulh_nv2si ( __a , ( __builtin_neon_si ) __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vqdmulhv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqdmulhv2si ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqdmull_nv4hi ( __a , ( __builtin_neon_hi ) __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqdmullv4hi ( __a , __b ) ;


return ( int16x4_t ) __builtin_neon_vqmovnsv4si ( __a ) ;


<s> return ( int16x4_t ) __builtin_neon_vqmovnsv4si ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vqmovnsv2di ( __a ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqmovnuv4si ( ( int32x4_t ) __a ) ;


<s> return ( uint8x8_t ) __builtin_neon_vqmovunv8hi ( __a ) ;


return ( uint8x8_t ) __builtin_neon_vqmovunv8hi ( __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vqnegv4si ( __a ) ;


return ( int8x16_t ) __builtin_neon_vqnegv16qi ( __a ) ;


<s> return ( int8x16_t ) __builtin_neon_vqnegv16qi ( __a ) ;


<s> return ( int32x2_t ) __builtin_neon_vqnegv2si ( __a ) ;


<s> return ( int16x8_t ) __builtin_neon_vqrdmulh_nv8hi ( __a , ( __builtin_neon_hi ) __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqrdmulh_nv4si ( __a , ( __builtin_neon_si ) __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vqrdmulh_nv4hi ( __a , ( __builtin_neon_hi ) __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vqrshluv8hi ( ( int16x8_t ) __a , __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vqrshluv2di ( ( int64x2_t ) __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vqrshluv16qi ( ( int8x16_t ) __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqrshlsv2si ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vqrshlsdi ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vqrshlsv8qi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqrshluv4hi ( ( int16x4_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vqrshrns_nv4si ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqrshrns_nv2di ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqrshrnu_nv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vqshl_s_nv8hi ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqshl_s_nv4si ( __a , __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vqshl_s_nv2di ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vqshl_u_nv8hi ( ( int16x8_t ) __a , __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vqshl_u_nv2di ( ( int64x2_t ) __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vqshl_u_nv16qi ( ( int8x16_t ) __a , __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vqshluv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqshlu_nv4hi ( __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vqshlu_nv2si ( __a , __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vqshlu_ndi ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vqshlu_nv8qi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqshl_s_nv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vqshl_s_nv8qi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqshl_u_nv4hi ( ( int16x4_t ) __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vqshl_u_nv8qi ( ( int8x8_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vqshlsv4hi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqshluv4hi ( ( int16x4_t ) __a , __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vqshludi ( ( int64x1_t ) __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqshrnu_nv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vqsubsv8hi ( __a , __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vqsubsv4si ( __a , __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vqsubuv4si ( ( int32x4_t ) __a , ( int32x4_t ) __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vqsubuv2di ( ( int64x2_t ) __a , ( int64x2_t ) __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vqsubuv16qi ( ( int8x16_t ) __a , ( int8x16_t ) __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vqsubsv2si ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vqsubsdi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vqsubuv4hi ( ( int16x4_t ) __a , ( int16x4_t ) __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vqsubuv2si ( ( int32x2_t ) __a , ( int32x2_t ) __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vqsubudi ( ( int64x1_t ) __a , ( int64x1_t ) __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vraddhnv8hi ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vraddhnv4si ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vraddhnv8hi ( ( int16x8_t ) __a , ( int16x8_t ) __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vraddhnv4si ( ( int32x4_t ) __a , ( int32x4_t ) __b ) ;


<s> return __builtin_neon_vrecpev8hf ( __a ) ;


return ( float32x4_t ) __builtin_neon_vrecpev4sf ( __a ) ;


<s> return ( uint32x4_t ) __builtin_neon_vrecpev4si ( ( int32x4_t ) __a ) ;


return __builtin_neon_vrecpev4hf ( __a ) ;


return ( float32x2_t ) __builtin_neon_vrecpev2sf ( __a ) ;


<s> return ( uint32x2_t ) __builtin_neon_vrecpev2si ( ( int32x2_t ) __a ) ;


<s> return __builtin_neon_vrecpsv8hf ( __a , __b ) ;


<s> return ( float32x4_t ) __builtin_neon_vrecpsv4sf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_neon_vrecpsv2sf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_shuffle ( __a , ( uint32x2_t ) { <NUM_LIT> , <NUM_LIT> } ) ;


return ( int32x2_t ) __builtin_shuffle ( __a , ( uint32x2_t ) { <NUM_LIT> , <NUM_LIT> } ) ;


<s> return ( int32x2_t ) __builtin_shuffle ( __a , ( uint32x2_t ) { <NUM_LIT> , <NUM_LIT> } ) ;


<s> return ( uint16x8_t ) __builtin_neon_vrhadduv8hi ( ( int16x8_t ) __a , ( int16x8_t ) __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vrhadduv4si ( ( int32x4_t ) __a , ( int32x4_t ) __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vrhaddsv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vrhaddsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vrhaddsv8qi ( __a , __b ) ;


return __builtin_neon_vrndav8hf ( __a ) ;


<s> return __builtin_neon_vrndav8hf ( __a ) ;


return ( float32x4_t ) __builtin_neon_vrintav4sf ( __a ) ;


<s> return __builtin_neon_vrndav4hf ( __a ) ;


return ( float32x2_t ) __builtin_neon_vrintav2sf ( __a ) ;


<s> return ( float32x2_t ) __builtin_neon_vrintav2sf ( __a ) ;


<s> return ( float32x4_t ) __builtin_neon_vrintmv4sf ( __a ) ;


<s> return ( float32x4_t ) __builtin_neon_vrintnv4sf ( __a ) ;


<s> return __builtin_neon_vrndnv4hf ( __a ) ;


<s> return ( float32x2_t ) __builtin_neon_vrintnv2sf ( __a ) ;


return ( float32x2_t ) __builtin_neon_vrintnv2sf ( __a ) ;


<s> return __builtin_neon_vrndpv4hf ( __a ) ;


<s> return ( float32x2_t ) __builtin_neon_vrintpv2sf ( __a ) ;


<s> return __builtin_neon_vrndv8hf ( __a ) ;


<s> return ( float32x4_t ) __builtin_neon_vrintzv4sf ( __a ) ;


<s> return __builtin_neon_vrndxv8hf ( __a ) ;


return ( float32x4_t ) __builtin_neon_vrintxv4sf ( __a ) ;


<s> return ( float32x4_t ) __builtin_neon_vrintxv4sf ( __a ) ;


<s> return __builtin_neon_vrndxv4hf ( __a ) ;


<s> return ( float32x2_t ) __builtin_neon_vrintxv2sf ( __a ) ;


<s> return __builtin_neon_vrndv4hf ( __a ) ;


<s> return ( int32x4_t ) __builtin_neon_vrshlsv4si ( __a , __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vrshlsv2di ( __a , __b ) ;


<s> return ( int8x16_t ) __builtin_neon_vrshlsv16qi ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vrshluv8hi ( ( int16x8_t ) __a , __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vrshluv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vrshlsv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vrshlsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vrshlsv8qi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vrshluv4hi ( ( int16x4_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vrshrn_nv4si ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vrshrn_nv2di ( __a , __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vrshrs_nv8hi ( __a , __b ) ;


<s> return ( int8x16_t ) __builtin_neon_vrshrs_nv16qi ( __a , __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vrshru_nv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vrshru_nv2di ( ( int64x2_t ) __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vrshru_nv16qi ( ( int8x16_t ) __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vrshrs_nv2si ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vrshrs_ndi ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vrshrs_nv8qi ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vrshru_nv4hi ( ( int16x4_t ) __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vrshru_nv2si ( ( int32x2_t ) __a , __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vrshru_ndi ( ( int64x1_t ) __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vrshru_nv8qi ( ( int8x8_t ) __a , __b ) ;


return __builtin_neon_vrsqrtev8hf ( __a ) ;


<s> return __builtin_neon_vrsqrtev8hf ( __a ) ;


<s> return ( float32x4_t ) __builtin_neon_vrsqrtev4sf ( __a ) ;


return ( uint32x4_t ) __builtin_neon_vrsqrtev4si ( ( int32x4_t ) __a ) ;


return ( uint32x2_t ) __builtin_neon_vrsqrtev2si ( ( int32x2_t ) __a ) ;


<s> return __builtin_neon_vrsqrtsv8hf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_neon_vrsqrtsv2sf ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vrsubhnv8hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vrsubhnv2di ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vrsubhnv8hi ( ( int16x8_t ) __a , ( int16x8_t ) __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vrsubhnv4si ( ( int32x4_t ) __a , ( int32x4_t ) __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vrsubhnv2di ( ( int64x2_t ) __a , ( int64x2_t ) __b ) ;


<s> return vgetq_lane_u32 ( __builtin_arm_crypto_sha1h ( vdupq_n_u32 ( __hash_e ) ) , <NUM_LIT> ) ;


<s> return __builtin_arm_crypto_sha1su1 ( __tw0_3 , __w12_15 ) ;


<s> return __builtin_arm_crypto_sha256su0 ( __w0_3 , __w4_7 ) ;


<s> return ( int16x8_t ) __builtin_neon_vshlls_nv8qi ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vshllu_nv8qi ( ( int8x8_t ) __a , __b ) ;


<s> return ( uint64x2_t ) __builtin_neon_vshl_nv2di ( ( int64x2_t ) __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vshl_nv16qi ( ( int8x16_t ) __a , __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vshlsv2di ( __a , __b ) ;


<s> return ( uint8x16_t ) __builtin_neon_vshluv16qi ( ( int8x16_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vshl_nv4hi ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vshl_ndi ( __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vshl_nv2si ( ( int32x2_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vshlsv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vshlsv2si ( __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vshlsv8qi ( __a , __b ) ;


<s> return ( uint64x1_t ) __builtin_neon_vshludi ( ( int64x1_t ) __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vshluv8qi ( ( int8x8_t ) __a , __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vshrn_nv8hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vshrn_nv2di ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vshrn_nv8hi ( ( int16x8_t ) __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vshrn_nv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( uint32x2_t ) __builtin_neon_vshrn_nv2di ( ( int64x2_t ) __a , __b ) ;


<s> return ( int16x8_t ) __builtin_neon_vshrs_nv8hi ( __a , __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vshrs_nv2di ( __a , __b ) ;


<s> return ( int8x16_t ) __builtin_neon_vshrs_nv16qi ( __a , __b ) ;


<s> return ( uint32x4_t ) __builtin_neon_vshru_nv4si ( ( int32x4_t ) __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vshrs_nv4hi ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vshrs_nv2si ( __a , __b ) ;


<s> return ( int64x1_t ) __builtin_neon_vshrs_ndi ( __a , __b ) ;


<s> return ( uint8x8_t ) __builtin_neon_vshru_nv8qi ( ( int8x8_t ) __a , __b ) ;


<s> __builtin_neon_vst1v8hi ( ( __builtin_neon_hi * ) __a , __b ) ;


<s> __builtin_neon_vst1v2di ( ( __builtin_neon_di * ) __a , ( int64x2_t ) __b ) ;


<s> __builtin_neon_vst1v16qi ( ( __builtin_neon_qi * ) __a , ( int8x16_t ) __b ) ;


<s> __builtin_neon_vst1v8qi ( ( __builtin_neon_qi * ) __a , ( int8x8_t ) __b ) ;


<s> __builtin_neon_vst1v4hi ( ( __builtin_neon_hi * ) __a , __b ) ;


<s> __builtin_neon_vst1v2si ( ( __builtin_neon_si * ) __a , __b ) ;


<s> __builtin_neon_vst1di ( ( __builtin_neon_di * ) __a , __b ) ;


<s> __builtin_neon_vst1v2si ( ( __builtin_neon_si * ) __a , ( int32x2_t ) __b ) ;


<s> return ( int8x8_t ) __builtin_neon_vsubhnv8hi ( __a , __b ) ;


<s> return ( int16x4_t ) __builtin_neon_vsubhnv4si ( __a , __b ) ;


<s> return ( int32x2_t ) __builtin_neon_vsubhnv2di ( __a , __b ) ;


<s> return ( uint16x4_t ) __builtin_neon_vsubhnv4si ( ( int32x4_t ) __a , ( int32x4_t ) __b ) ;


<s> return ( int32x4_t ) __builtin_neon_vsublsv4hi ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vsubluv8qi ( ( int8x8_t ) __a , ( int8x8_t ) __b ) ;


<s> return ( int64x2_t ) __builtin_neon_vsubwsv2si ( __a , __b ) ;


<s> return ( uint16x8_t ) __builtin_neon_vsubwuv8qi ( ( int16x8_t ) __a , ( int8x8_t ) __b ) ;


<s> return __builtin_neon_vsubv4hf ( __a , __b ) ;


<s> return ( float32x2_t ) __builtin_neon_vsubv2sf ( __a , __b ) ;


<s> __rv . val [ <NUM_LIT> ] = __builtin_shuffle ( __a , __b , ( uint32x2_t ) { <NUM_LIT> , <NUM_LIT> } ) ;


<s> return ( uint8x16_t ) __builtin_neon_vtstv16qi ( ( int8x16_t ) __a , ( int8x16_t ) __b ) ;


<s> machine_mode mode = GET_MODE ( mem ) ; HOST_WIDE_INT offset = GET_MODE_SIZE ( mode ) ; rtx addr = plus_constant ( Pmode , XEXP ( mem , <NUM_LIT> ) , offset ) ; return adjust_automodify_address ( mem , mode , addr , offset ) ;


<s> const operand_alternative * op_alt = which_op_alt ( ) ; for ( opno = <NUM_LIT> ; opno < recog_data . n_operands ; opno ++ ) { if ( recog_data . operand_type [ opno ] != OP_IN ) continue ; if ( op_alt [ opno ] . memory_ok ) { rtx op = recog_data . operand [ opno ] ; if ( CONSTANT_P ( op ) ) { if ( do_pushes ) push_minipool_fix ( insn , address , recog_data . operand_loc [ opno ] , recog_data . operand_mode [ opno ] , op ) ; } else if ( MEM_P ( op ) && GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( XEXP ( op , <NUM_LIT> ) ) ) { if ( do_pushes ) { rtx cop = avoid_constant_pool_reference ( op ) ; if ( op == cop ) cop = get_pool_constant ( XEXP ( op , <NUM_LIT> ) ) ; push_minipool_fix ( insn , address , recog_data . operand_loc [ opno ] , recog_data . operand_mode [ opno ] , cop ) ;


<s> inline static int number_of_first_bit_set ( unsigned mask ) { return ctz_hwi ( mask ) ;


if ( TARGET_THUMB2 && ( ( offset & <NUM_LIT> ) != <NUM_LIT> ) ) return false ;


<s> HOST_WIDE_INT max_offset ; if ( TARGET_THUMB2 && ( ( offset & <NUM_LIT> ) != <NUM_LIT> ) ) return false ; if ( TARGET_THUMB2 ) max_offset = <NUM_LIT> ; else if ( TARGET_ARM ) max_offset = <NUM_LIT> ; else return false ; return ( ( offset <= max_offset ) && ( offset >= - max_offset ) ) ;


<s> t2 = REGNO ( rt2 ) ; n = REGNO ( rn ) ; if ( ( TARGET_THUMB2 ) && ( ( wback && ( n == t || n == t2 ) ) || ( t == SP_REGNUM ) || ( t == PC_REGNUM ) || ( t2 == SP_REGNUM ) || ( t2 == PC_REGNUM ) || ( ! load && ( n == PC_REGNUM ) ) || ( load && ( t == t2 ) ) || ( ! wback && load && fix_cm3_ldrd && ( n == t ) ) ) ) return false ;

if ( ( TARGET_ARM ) && ( ( wback && ( n == t || n == t2 ) ) || ( t2 == PC_REGNUM ) || ( t % <NUM_LIT> != <NUM_LIT> ) || ( t2 != t + <NUM_LIT> ) || ( n == PC_REGNUM ) ) ) return false ;


<s> int insns1 , insns2 ; struct four_ints tmp_sequence ; if ( TARGET_ARM ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i += <NUM_LIT> ) { int consecutive_zeros = <NUM_LIT> ; if ( ! ( val & ( <NUM_LIT> << i ) ) ) { while ( ( i < <NUM_LIT> ) && ! ( val & ( <NUM_LIT> << i ) ) ) { consecutive_zeros += <NUM_LIT> ; i += <NUM_LIT> ; } if ( consecutive_zeros > best_consecutive_zeros ) { best_consecutive_zeros = consecutive_zeros ; best_start = i - consecutive_zeros ; } i -= <NUM_LIT> ; } } } insns1 = optimal_immediate_sequence_1 ( code , val , return_sequence , best_start ) ; if ( best_start != <NUM_LIT> && ( ( HOST_WIDE_INT_1U << best_start ) < val ) ) { insns2 = optimal_immediate_sequence_1 ( code , val , & tmp_sequence , <NUM_LIT> ) ; if ( insns2 <= insns1 ) { * return_sequence = tmp_sequence ; insns1 = insns2 ; }


<s> b4 = remainder & <NUM_LIT> ; if ( loc > <NUM_LIT> ) { unsigned int tmp = b1 & b2 & b3 & b4 ; unsigned int tmp2 = tmp + ( tmp << <NUM_LIT> ) + ( tmp << <NUM_LIT> ) + ( tmp << <NUM_LIT> ) ; unsigned int matching_bytes = ( tmp == b1 ) + ( tmp == b2 ) + ( tmp == b3 ) + ( tmp == b4 ) ; if ( tmp && ( matching_bytes >= <NUM_LIT> || ( matching_bytes == <NUM_LIT> && const_ok_for_op ( remainder & ~ tmp2 , code ) ) ) ) { result = tmp2 ; i = tmp != b1 ? <NUM_LIT> : tmp != b2 ? <NUM_LIT> : tmp != b3 ? <NUM_LIT> : <NUM_LIT> ; } else if ( b1 == b3 && ( ! b2 || ! b4 || ( remainder & <NUM_LIT> & ~ result ) ) ) { result = remainder & <NUM_LIT> ; i = <NUM_LIT> ; } } else if ( loc > <NUM_LIT> ) { if ( b2 == b4 ) { result = remainder & <NUM_LIT> ; i = <NUM_LIT> ; } } } return_sequence -> i [ insns ++ ] = result ; remainder &= ~ result ; if ( code == SET || code == MINUS ) code = PLUS ; } while ( remainder ) ; return insns ;


<s> if ( i <= <NUM_LIT> && TARGET_THUMB2 && code == PLUS ) result = remainder ; else { end = i - <NUM_LIT> ; if ( end < <NUM_LIT> ) end += <NUM_LIT> ; result = remainder & ( ( <NUM_LIT> << end ) | ( ( i < end ) ? ( <NUM_LIT> >> ( <NUM_LIT> - end ) ) : <NUM_LIT> ) ) ; i -= <NUM_LIT> ; } } else { i -= TARGET_ARM ? <NUM_LIT> : <NUM_LIT> ; continue ; } if ( TARGET_THUMB2 ) { b1 = ( remainder & <NUM_LIT> ) >> <NUM_LIT> ; b2 = ( remainder & <NUM_LIT> ) >> <NUM_LIT> ; b3 = ( remainder & <NUM_LIT> ) >> <NUM_LIT> ; b4 = remainder & <NUM_LIT> ; if ( loc > <NUM_LIT> ) { unsigned int tmp = b1 & b2 & b3 & b4 ; unsigned int tmp2 = tmp + ( tmp << <NUM_LIT> ) + ( tmp << <NUM_LIT> ) + ( tmp << <NUM_LIT> ) ; unsigned int matching_bytes = ( tmp == b1 ) + ( tmp == b2 ) + ( tmp == b3 ) + ( tmp == b4 ) ; if ( tmp && ( matching_bytes >= <NUM_LIT> || ( matching_bytes == <NUM_LIT> && const_ok_for_op ( remainder & ~ tmp2 , code ) ) ) ) { result = tmp2 ; i = tmp != b1 ? <NUM_LIT> : tmp != b2 ? <NUM_LIT> : tmp != b3 ? <NUM_LIT> : <NUM_LIT> ; } else if ( b1 == b3 && ( ! b2 || ! b4 || ( remainder & <NUM_LIT> & ~ result ) ) ) { result = remainder & <NUM_LIT> ;


<s> if ( n != <NUM_LIT> || REGNO ( operands [ <NUM_LIT> ] ) != REGNO ( operands [ <NUM_LIT> ] ) ) { if ( n < <NUM_LIT> ) output_multi_immediate ( operands , <STR_LIT> , <STR_LIT> , <NUM_LIT> , - n ) ; else output_multi_immediate ( operands , <STR_LIT> , <STR_LIT> , <NUM_LIT> , n ) ; } return <STR_LIT> ;


<s> const char * output_add_immediate ( rtx * operands ) { HOST_WIDE_INT n = INTVAL ( operands [ <NUM_LIT> ] ) ; if ( n != <NUM_LIT> || REGNO ( operands [ <NUM_LIT> ] ) != REGNO ( operands [ <NUM_LIT> ] ) ) {

if ( n < <NUM_LIT> ) output_multi_immediate ( operands , <STR_LIT> , <STR_LIT> , <NUM_LIT> , - n ) ;


<s> int len_so_far = <NUM_LIT> ; fputs ( <STR_LIT> , stream ) ; for ( i = <NUM_LIT> ; i < len ; i ++ ) { int c = p [ i ] ; if ( len_so_far >= MAX_ASCII_LEN ) { fputs ( <STR_LIT> , stream ) ; len_so_far = <NUM_LIT> ; } if ( ISPRINT ( c ) ) { if ( c == '\\' || c == '\"' ) { putc ( '\\' , stream ) ; len_so_far ++ ; } putc ( c , stream ) ; len_so_far ++ ; }


<s> for ( i = <NUM_LIT> ; i < len ; i ++ ) { int c = p [ i ] ; if ( len_so_far >= MAX_ASCII_LEN ) { fputs ( <STR_LIT> , stream ) ; len_so_far = <NUM_LIT> ; } if ( ISPRINT ( c ) ) { if ( c == '\\' || c == '\"' ) { putc ( '\\' , stream ) ; len_so_far ++ ; }


<s> } output_asm_insn ( <STR_LIT> , operands ) ; if ( TARGET_INTERWORK || arm_arch4t ) output_asm_insn ( <STR_LIT> , operands ) ; else output_asm_insn ( <STR_LIT> , operands ) ; return <STR_LIT> ;


<s> case POST_MODIFY : gcc_unreachable ( ) ; case REG : if ( nregs > <NUM_LIT> ) { if ( nregs > <NUM_LIT> || ( TARGET_HAVE_MVE && nregs >= <NUM_LIT> ) ) templ = <STR_LIT> ; else templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; ops [ <NUM_LIT> ] = reg ; break ; } case PLUS : if ( GET_CODE ( addr ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; case LABEL_REF : { int i ; int overlap = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nregs ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( reg ) + <NUM_LIT> * i ) ; ops [ <NUM_LIT> ] = adjust_address ( mem , DImode , <NUM_LIT> * i ) ; if ( reg_overlap_mentioned_p ( ops [ <NUM_LIT> ] , mem ) ) { gcc_assert ( overlap == - <NUM_LIT> ) ; overlap = i ; } else { if ( TARGET_HAVE_MVE && LABEL_REF_P ( addr ) ) sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; else sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ; } } if ( overlap != - <NUM_LIT> ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( reg ) + <NUM_LIT> * overlap ) ; ops [ <NUM_LIT> ] = adjust_address ( mem , SImode , <NUM_LIT> * overlap ) ; if ( TARGET_HAVE_MVE && LABEL_REF_P ( addr ) ) sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; else sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ; } return <STR_LIT> ; } default : gcc_unreachable ( ) ; } sprintf ( buff , templ , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ;


<s> if ( GET_CODE ( addr ) == CONST && GET_CODE ( XEXP ( addr , <NUM_LIT> ) ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case POST_INC : if ( nregs > <NUM_LIT> || ( TARGET_HAVE_MVE && nregs >= <NUM_LIT> ) ) { templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; } else { templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; } ops [ <NUM_LIT> ] = reg ; break ; case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_MODIFY : gcc_unreachable ( ) ; case REG : if ( nregs > <NUM_LIT> ) { if ( nregs > <NUM_LIT> || ( TARGET_HAVE_MVE && nregs >= <NUM_LIT> ) ) templ = <STR_LIT> ; else templ = <STR_LIT> ; ops [ <NUM_LIT> ] = mem ; ops [ <NUM_LIT> ] = reg ; break ; } case PLUS : if ( GET_CODE ( addr ) == PLUS ) addr = XEXP ( addr , <NUM_LIT> ) ; case LABEL_REF : { int i ; int overlap = - <NUM_LIT> ; for ( i = <NUM_LIT> ; i < nregs ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( DImode , REGNO ( reg ) + <NUM_LIT> * i ) ; ops [ <NUM_LIT> ] = adjust_address ( mem , DImode , <NUM_LIT> * i ) ; if ( reg_overlap_mentioned_p ( ops [ <NUM_LIT> ] , mem ) ) { gcc_assert ( overlap == - <NUM_LIT> ) ; overlap = i ; } else { if ( TARGET_HAVE_MVE && LABEL_REF_P ( addr ) ) sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; else sprintf ( buff , <STR_LIT> , load ? <STR_LIT> : <STR_LIT> ) ; output_asm_insn ( buff , ops ) ;


<s> } else { rtx ops [ <NUM_LIT> ] ; int dest , src , i ; gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; dest = REGNO ( operands [ <NUM_LIT> ] ) ; src = REGNO ( operands [ <NUM_LIT> ] ) ; if ( dest < src ) for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; } else for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; } } } else { gcc_assert ( MEM_P ( operands [ <NUM_LIT> ] ) ) ;


<s> gcc_assert ( MEM_P ( mem ) ) ; addr = XEXP ( mem , <NUM_LIT> ) ; switch ( GET_CODE ( addr ) ) { case PRE_DEC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; case POST_INC : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = XEXP ( addr , <NUM_LIT> ) ; ops [ <NUM_LIT> ] = reg ; break ; default : templ = <STR_LIT> ; ops [ <NUM_LIT> ] = reg ; ops [ <NUM_LIT> ] = mem ; break ; } sprintf ( buff , templ , load ? <STR_LIT> : <STR_LIT> , dp ? <STR_LIT> : sp ? <STR_LIT> : <STR_LIT> , dp ? <STR_LIT> : <STR_LIT> , integer_p ? <STR_LIT> : <STR_LIT> ) ;


<s> int i ; if ( dest_start < src_start ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest_start + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src_start + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; } } else {

for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) {


<s> int src_start = REGNO ( operands [ <NUM_LIT> ] ) ; rtx ops [ <NUM_LIT> ] ; int i ; if ( dest_start < src_start ) { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest_start + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src_start + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; } } else { for ( i = <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , dest_start + i ) ; ops [ <NUM_LIT> ] = gen_rtx_REG ( SImode , src_start + i ) ; output_asm_insn ( <STR_LIT> , ops ) ; }


<s> char loop_lab [ <NUM_LIT> ] ; rtx xops [ <NUM_LIT> ] ; ASM_GENERATE_INTERNAL_LABEL ( loop_lab , <STR_LIT> , labelno ++ ) ; ASM_OUTPUT_INTERNAL_LABEL ( asm_out_file , loop_lab ) ; xops [ <NUM_LIT> ] = reg1 ; xops [ <NUM_LIT> ] = GEN_INT ( PROBE_INTERVAL ) ; output_asm_insn ( <STR_LIT> , xops ) ; output_asm_insn ( <STR_LIT> , xops ) ; xops [ <NUM_LIT> ] = reg2 ; output_asm_insn ( <STR_LIT> , xops ) ;


<s> char * p ; int first = <NUM_LIT> ; if ( live_regs_mask & ( <NUM_LIT> << SP_REGNUM ) ) { unsigned HOST_WIDE_INT stack_adjust ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; gcc_assert ( stack_adjust == <NUM_LIT> || stack_adjust == <NUM_LIT> ) ; if ( stack_adjust && arm_arch5t && TARGET_ARM ) sprintf ( instr , <STR_LIT> , conditional ) ; else { if ( stack_adjust ) live_regs_mask |= <NUM_LIT> << <NUM_LIT> ; sprintf ( instr , <STR_LIT> , conditional ) ; } } else if ( IS_INTERRUPT ( func_type ) ) sprintf ( instr , <STR_LIT> , conditional ) ; else sprintf ( instr , <STR_LIT> , conditional ) ; p = instr + strlen ( instr ) ; for ( reg = <NUM_LIT> ; reg <= SP_REGNUM ; reg ++ ) if ( live_regs_mask & ( <NUM_LIT> << reg ) ) { int l = strlen ( reg_names [ reg ] ) ; if ( first ) first = <NUM_LIT> ; else { memcpy ( p , <STR_LIT> , <NUM_LIT> ) ; p += <NUM_LIT> ; } memcpy ( p , <STR_LIT> , <NUM_LIT> ) ; memcpy ( p + <NUM_LIT> , reg_names [ reg ] , l ) ; p += l + <NUM_LIT> ; } if ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) { sprintf ( p , <STR_LIT> , first ? <STR_LIT> : <STR_LIT> , return_reg ) ; if ( IS_INTERRUPT ( func_type ) ) strcat ( p , <STR_LIT> ) ; } else strcpy ( p , <STR_LIT> ) ; } output_asm_insn ( instr , & operand ) ; if ( really_return && func_type != ARM_FT_INTERWORKED && ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ) { return <STR_LIT> ; } } if ( really_return ) { switch ( ( int ) ARM_FUNC_TYPE ( func_type ) ) { case ARM_FT_ISR : case ARM_FT_FIQ : sprintf ( instr , <STR_LIT> , conditional ) ; break ; case ARM_FT_INTERWORKED : gcc_assert ( arm_arch5t || arm_arch4t ) ; sprintf ( instr , <STR_LIT> , conditional ) ; break ; case ARM_FT_EXCEPTION : sprintf ( instr , <STR_LIT> , conditional ) ; break ; default : if ( IS_CMSE_ENTRY ( func_type ) ) { if ( ! TARGET_HAVE_FPCXT_CMSE ) { if ( TARGET_INT_SIMD ) snprintf ( instr , sizeof ( instr ) , <STR_LIT> , conditional ) ; else snprintf ( instr , sizeof ( instr ) , <STR_LIT> , conditional ) ; output_asm_insn ( instr , & operand ) ; if ( TARGET_HARD_FLOAT ) { output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; output_asm_insn ( <STR_LIT> , & operand ) ; } } snprintf ( instr , sizeof ( instr ) , <STR_LIT> ) ; }

else if ( arm_arch5t || arm_arch4t ) sprintf ( instr , <STR_LIT> , conditional ) ;


<s> if ( GET_CODE ( x ) == MINUS ) return symbol_mentioned_p ( XEXP ( x , <NUM_LIT> ) ) && label_mentioned_p ( XEXP ( x , <NUM_LIT> ) ) ;


<s> fix -> backwards = get_attr_neg_pool_range ( insn ) ; fix -> minipool = NULL ; gcc_assert ( fix -> forwards || fix -> backwards ) ; if ( ARM_DOUBLEWORD_ALIGN && fix -> fix_size >= <NUM_LIT> ) minipool_pad = <NUM_LIT> ; if ( dump_file ) { fprintf ( dump_file , <STR_LIT> , GET_MODE_NAME ( mode ) , INSN_UID ( insn ) , ( unsigned long ) address , - <NUM_LIT> * ( long ) fix -> backwards , ( long ) fix -> forwards ) ; arm_print_value ( dump_file , fix -> value ) ; fprintf ( dump_file , <STR_LIT> ) ; } fix -> next = NULL ;

if ( minipool_fix_head != NULL ) minipool_fix_tail -> next = fix ;


<s> else return false ; else if ( ! df_regs_ever_live_p ( reg ) || call_used_or_fixed_reg_p ( reg ) ) return false ;


<s> rtx insn = emit_set_insn ( sr -> reg , gen_frame_mem ( SImode , addr ) ) ; rtx x = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> ) ) ;

RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ;


<s> start_sequence ( ) ; if ( TARGET_THUMB1 && arm_pic_register != INVALID_REGNUM && arm_pic_register > LAST_LO_REGNUM && ! compute_now ) emit_move_insn ( cfun -> machine -> pic_reg , gen_rtx_REG ( Pmode , arm_pic_register ) ) ; else arm_load_pic_register ( <NUM_LIT> , pic_reg ) ; seq = get_insns ( ) ; end_sequence ( ) ; for ( insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) INSN_LOCATION ( insn ) = prologue_location ; if ( currently_expanding_to_rtl ) insert_insn_on_edge ( seq , single_succ_edge ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ) ; else emit_insn ( seq ) ; } }


<s> gcc_assert ( compute_now == ( pic_reg != NULL_RTX ) ) ; if ( ! crtl -> uses_pic_offset_table || compute_now ) { gcc_assert ( can_create_pseudo_p ( ) || ( pic_reg != NULL_RTX && REG_P ( pic_reg ) && GET_MODE ( pic_reg ) == Pmode ) ) ; if ( arm_pic_register != INVALID_REGNUM && ! compute_now && ! ( TARGET_THUMB1 && arm_pic_register > LAST_LO_REGNUM ) ) { if ( ! cfun -> machine -> pic_reg ) cfun -> machine -> pic_reg = gen_rtx_REG ( Pmode , arm_pic_register ) ; if ( current_ir_type ( ) != IR_GIMPLE || currently_expanding_to_rtl ) crtl -> uses_pic_offset_table = <NUM_LIT> ; } else { rtx_insn * seq , * insn ; if ( pic_reg == NULL_RTX ) pic_reg = gen_reg_rtx ( Pmode ) ; if ( ! cfun -> machine -> pic_reg ) cfun -> machine -> pic_reg = pic_reg ; if ( current_ir_type ( ) != IR_GIMPLE || currently_expanding_to_rtl ) { crtl -> uses_pic_offset_table = <NUM_LIT> ; start_sequence ( ) ; if ( TARGET_THUMB1 && arm_pic_register != INVALID_REGNUM && arm_pic_register > LAST_LO_REGNUM && ! compute_now ) emit_move_insn ( cfun -> machine -> pic_reg , gen_rtx_REG ( Pmode , arm_pic_register ) ) ; else arm_load_pic_register ( <NUM_LIT> , pic_reg ) ; seq = get_insns ( ) ; end_sequence ( ) ;

for ( insn = seq ; insn ; insn = NEXT_INSN ( insn ) ) if ( INSN_P ( insn ) ) INSN_LOCATION ( insn ) = prologue_location ;


<s> else if ( new_tree == target_option_default_node ) restore_target_globals ( & default_target_globals ) ; else { TREE_TARGET_GLOBALS ( new_tree ) = save_target_globals_default_opts ( ) ;


<s> if ( code == MULT && CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) && exact_log2 ( INTVAL ( XEXP ( op , <NUM_LIT> ) ) ) > <NUM_LIT> ) return XEXP ( op , <NUM_LIT> ) ; else if ( code == ROTATE && CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) return XEXP ( op , <NUM_LIT> ) ; else if ( code == ROTATERT || code == ASHIFT || code == LSHIFTRT || code == ASHIFTRT ) { if ( ! CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) * shift_reg = XEXP ( op , <NUM_LIT> ) ; return XEXP ( op , <NUM_LIT> ) ; }


<s> code = ROTATERT ; * amountp = <NUM_LIT> - INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; mnem = <STR_LIT> ; break ; case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATERT : mnem = arm_shift_nmem ( code ) ; if ( CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; } else if ( REG_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = - <NUM_LIT> ; return mnem ; }


<s> case ASHIFTRT : case LSHIFTRT : case ROTATERT : mnem = arm_shift_nmem ( code ) ; if ( CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = INTVAL ( XEXP ( op , <NUM_LIT> ) ) ; } else if ( REG_P ( XEXP ( op , <NUM_LIT> ) ) ) { * amountp = - <NUM_LIT> ; return mnem ; } else { output_operand_lossage ( <STR_LIT> ) ; return NULL ; } break ; case MULT : if ( ! CONST_INT_P ( XEXP ( op , <NUM_LIT> ) ) ) { output_operand_lossage ( <STR_LIT> ) ; return NULL ; } * amountp = INTVAL ( XEXP ( op , <NUM_LIT> ) ) & <NUM_LIT> ; if ( * amountp & ( * amountp - <NUM_LIT> ) ) { output_operand_lossage ( <STR_LIT> ) ; return NULL ; } * amountp = exact_log2 ( * amountp ) ; gcc_assert ( IN_RANGE ( * amountp , <NUM_LIT> , <NUM_LIT> ) ) ; return ARM_LSL_NAME ; default : output_operand_lossage ( <STR_LIT> ) ; return NULL ; } if ( code == ROTATERT ) * amountp &= <NUM_LIT> ; else if ( * amountp != ( * amountp & <NUM_LIT> ) ) { if ( code == ASHIFT ) mnem = <STR_LIT> ; * amountp = <NUM_LIT> ; }

if ( * amountp == <NUM_LIT> ) return NULL ;


<s> int tmpwidth ; int retval = simd_valid_immediate ( op , mode , <NUM_LIT> , & tmpconst , & tmpwidth ) ; if ( retval == - <NUM_LIT> ) return <NUM_LIT> ; if ( modconst ) * modconst = tmpconst ; if ( elementwidth ) * elementwidth = tmpwidth ;


<s> rtx tmpconst ; int tmpwidth ; int retval = simd_valid_immediate ( op , mode , <NUM_LIT> , & tmpconst , & tmpwidth ) ; if ( retval == - <NUM_LIT> ) return <NUM_LIT> ; if ( modconst ) * modconst = tmpconst ; if ( elementwidth ) * elementwidth = tmpwidth ;


<s> if ( ! compute_offset_order ( nops , unsorted_offsets , order , check_regs ? unsorted_regs : NULL ) ) return <NUM_LIT> ; if ( saved_order ) memcpy ( saved_order , order , sizeof order ) ; if ( base ) { * base = base_reg ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { regs [ i ] = unsorted_regs [ check_regs ? order [ i ] : i ] ; if ( reg_rtxs ) reg_rtxs [ i ] = unsorted_reg_rtxs [ check_regs ? order [ i ] : i ] ; } * load_offset = unsorted_offsets [ order [ <NUM_LIT> ] ] ; } if ( TARGET_THUMB1 && ! peep2_reg_dead_p ( nops_total , base_reg_rtx ) ) return <NUM_LIT> ; if ( unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) stm_case = <NUM_LIT> ; else if ( TARGET_ARM && unsorted_offsets [ order [ <NUM_LIT> ] ] == <NUM_LIT> ) stm_case = <NUM_LIT> ; else if ( TARGET_ARM && unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == <NUM_LIT> ) stm_case = <NUM_LIT> ; else if ( TARGET_32BIT && unsorted_offsets [ order [ nops - <NUM_LIT> ] ] == - <NUM_LIT> ) stm_case = <NUM_LIT> ; else return <NUM_LIT> ; if ( ! multiple_operation_profitable_p ( false , nops , <NUM_LIT> ) ) return <NUM_LIT> ; return stm_case ;


<s> if ( arm_carry_operation ( XEXP ( op , <NUM_LIT> ) , GET_MODE ( op ) ) ) return XEXP ( op , <NUM_LIT> ) ; else if ( arm_carry_operation ( XEXP ( op , <NUM_LIT> ) , GET_MODE ( op ) ) ) return XEXP ( op , <NUM_LIT> ) ; return op ;


<s> else if ( arm_carry_operation ( XEXP ( op , <NUM_LIT> ) , GET_MODE ( op ) ) ) return XEXP ( op , <NUM_LIT> ) ;


<s> const char * fmt ; int i ; if ( SYMBOL_REF_P ( x ) ) return <NUM_LIT> ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ; for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbol_mentioned_p ( XVECEXP ( x , i , j ) ) ) return <NUM_LIT> ; }

else if ( fmt [ i ] == 'e' && symbol_mentioned_p ( XEXP ( x , i ) ) ) return <NUM_LIT> ;


<s> const char * fmt ; int i ; if ( SYMBOL_REF_P ( x ) ) return <NUM_LIT> ; if ( GET_CODE ( x ) == UNSPEC && XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; fmt = GET_RTX_FORMAT ( GET_CODE ( x ) ) ; for ( i = GET_RTX_LENGTH ( GET_CODE ( x ) ) - <NUM_LIT> ; i >= <NUM_LIT> ; i -- ) { if ( fmt [ i ] == 'E' ) { int j ;

for ( j = XVECLEN ( x , i ) - <NUM_LIT> ; j >= <NUM_LIT> ; j -- ) if ( symbol_mentioned_p ( XVECEXP ( x , i , j ) ) ) return <NUM_LIT> ;


<s> if ( ! REG_P ( x ) ) return <NUM_LIT> ; regno = REGNO ( x ) ;

if ( strict_p ) return THUMB1_REGNO_MODE_OK_FOR_BASE_P ( regno , mode ) ;


<s> int regno ; if ( ! REG_P ( x ) ) return <NUM_LIT> ; regno = REGNO ( x ) ; if ( strict_p ) return THUMB1_REGNO_MODE_OK_FOR_BASE_P ( regno , mode ) ;

return ( regno <= LAST_LO_REGNUM || regno > LAST_VIRTUAL_REGISTER || regno == FRAME_POINTER_REGNUM || ( GET_MODE_SIZE ( mode ) >= <NUM_LIT> && ( regno == STACK_POINTER_REGNUM || regno >= FIRST_PSEUDO_REGISTER || x == hard_frame_pointer_rtx || x == arg_pointer_rtx ) ) ) ;


<s> thumb1_const_print ( FILE * f , int regno ) {


<s> thumb1_const_rtl ( rtx dst ) : dst ( dst ) {


<s> regno = ctz_hwi ( real_regs ) ; reg = gen_rtx_REG ( SImode , regno ) ; tmp = plus_constant ( Pmode , stack_pointer_rtx , j * <NUM_LIT> ) ; tmp = gen_frame_mem ( SImode , tmp ) ; tmp = gen_rtx_SET ( tmp , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; par [ j + <NUM_LIT> ] = tmp ; } if ( j == <NUM_LIT> ) tmp = par [ <NUM_LIT> ] ; else { RTX_FRAME_RELATED_P ( par [ <NUM_LIT> ] ) = <NUM_LIT> ; tmp = gen_rtx_SEQUENCE ( VOIDmode , gen_rtvec_v ( j + <NUM_LIT> , par ) ) ;


<s> unsigned long mask = <NUM_LIT> ; bitmap epilogue_live_in = df_get_live_in ( EXIT_BLOCK_PTR_FOR_FN ( cfun ) ) ;

for ( int reg = FIRST_LO_REGNUM ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( ! callee_saved_reg_p ( reg ) && ! REGNO_REG_SET_P ( epilogue_live_in , reg ) ) mask |= <NUM_LIT> << ( reg - FIRST_LO_REGNUM ) ;


<s> for ( int reg = FIRST_LO_REGNUM ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( ! callee_saved_reg_p ( reg ) && ! REGNO_REG_SET_P ( epilogue_live_in , reg ) ) mask |= <NUM_LIT> << ( reg - FIRST_LO_REGNUM ) ; return mask ;


<s> } } emit_insn ( gen_force_register_use ( stack_pointer_rtx ) ) ; if ( crtl -> profile || ! TARGET_SCHED_PROLOG ) emit_insn ( gen_blockage ( ) ) ; for ( regno = <NUM_LIT> ; regno < <NUM_LIT> ; regno ++ ) if ( reg_needs_saving_p ( regno ) ) emit_clobber ( gen_rtx_REG ( SImode , regno ) ) ; if ( ! df_regs_ever_live_p ( LR_REGNUM ) ) emit_use ( gen_rtx_REG ( SImode , LR_REGNUM ) ) ;


<s> amount = offsets -> outgoing_args - offsets -> saved_regs ; if ( frame_pointer_needed ) { emit_insn ( gen_movsi ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; amount = offsets -> locals_base - offsets -> saved_regs ; } amount -= <NUM_LIT> * thumb1_extra_regs_pushed ( offsets , false ) ; gcc_assert ( amount >= <NUM_LIT> ) ; if ( amount ) { emit_insn ( gen_blockage ( ) ) ;

if ( amount < <NUM_LIT> ) emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ;


<s> if ( cfun -> machine -> thumb1_cc_insn ) { if ( modified_in_p ( cfun -> machine -> thumb1_cc_op0 , insn ) || modified_in_p ( cfun -> machine -> thumb1_cc_op1 , insn ) ) CC_STATUS_INIT ; } conds = get_attr_conds ( insn ) ; if ( conds == CONDS_SET ) { rtx set = single_set ( insn ) ; cfun -> machine -> thumb1_cc_insn = insn ; cfun -> machine -> thumb1_cc_op0 = SET_DEST ( set ) ;

cfun -> machine -> thumb1_cc_op1 = const0_rtx ;


<s> int i ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { int byte = ( op1 >> ( <NUM_LIT> * ( <NUM_LIT> - i ) ) ) & <NUM_LIT> ; if ( byte ) { emit_set_insn ( op0 , mov_done_p ? gen_rtx_PLUS ( SImode , op0 , GEN_INT ( byte ) ) : GEN_INT ( byte ) ) ; mov_done_p = true ; } if ( mov_done_p ) emit_set_insn ( op0 , gen_rtx_ASHIFT ( SImode , op0 , GEN_INT ( <NUM_LIT> ) ) ) ; } if ( ! mov_done_p ) emit_set_insn ( op0 , GEN_INT ( op1 & <NUM_LIT> ) ) ;


<s> if ( byte ) { emit_set_insn ( op0 , mov_done_p ? gen_rtx_PLUS ( SImode , op0 , GEN_INT ( byte ) ) : GEN_INT ( byte ) ) ; mov_done_p = true ; } if ( mov_done_p ) emit_set_insn ( op0 , gen_rtx_ASHIFT ( SImode , op0 , GEN_INT ( <NUM_LIT> ) ) ) ; } if ( ! mov_done_p ) emit_set_insn ( op0 , GEN_INT ( op1 & <NUM_LIT> ) ) ; else if ( op1 & <NUM_LIT> ) emit_set_insn ( op0 , gen_rtx_PLUS ( SImode , op0 , GEN_INT ( op1 & <NUM_LIT> ) ) ) ;


<s> dst . neg ( ) ; return ; } int final_shift = number_of_first_bit_set ( val ) ; int leading_zeroes = clz_hwi ( val ) ; int number_of_bytes_needed = ( ( HOST_BITS_PER_WIDE_INT - <NUM_LIT> - leading_zeroes ) / BITS_PER_UNIT ) + <NUM_LIT> ; int number_of_bytes_needed2 = ( ( HOST_BITS_PER_WIDE_INT - <NUM_LIT> - leading_zeroes - final_shift ) / BITS_PER_UNIT ) + <NUM_LIT> ; if ( number_of_bytes_needed2 < number_of_bytes_needed ) val >>= final_shift ; else final_shift = <NUM_LIT> ; if ( val <= <NUM_LIT> ) { if ( val > <NUM_LIT> ) { unsigned HOST_WIDE_INT high = val - <NUM_LIT> ; dst . mov ( high ) ; dst . add ( <NUM_LIT> ) ; } else dst . mov ( val ) ; if ( final_shift > <NUM_LIT> ) dst . ashift ( final_shift ) ; } else { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { unsigned HOST_WIDE_INT byte = ( val >> ( <NUM_LIT> * ( <NUM_LIT> - i ) ) ) & <NUM_LIT> ; if ( byte ) { if ( mov_done_p ) { dst . ashift ( shift ) ; dst . add ( byte ) ; } else dst . mov ( byte ) ; shift = <NUM_LIT> ; mov_done_p = true ; } if ( mov_done_p ) shift += <NUM_LIT> ; } if ( ! mov_done_p ) dst . mov ( val & <NUM_LIT> ) ; else { dst . ashift ( shift ) ; if ( val & <NUM_LIT> ) dst . add ( val & <NUM_LIT> ) ; } if ( final_shift > <NUM_LIT> ) dst . ashift ( final_shift ) ; }


<s> return ; } int final_shift = number_of_first_bit_set ( val ) ; int leading_zeroes = clz_hwi ( val ) ; int number_of_bytes_needed = ( ( HOST_BITS_PER_WIDE_INT - <NUM_LIT> - leading_zeroes ) / BITS_PER_UNIT ) + <NUM_LIT> ; int number_of_bytes_needed2 = ( ( HOST_BITS_PER_WIDE_INT - <NUM_LIT> - leading_zeroes - final_shift ) / BITS_PER_UNIT ) + <NUM_LIT> ; if ( number_of_bytes_needed2 < number_of_bytes_needed ) val >>= final_shift ; else final_shift = <NUM_LIT> ; if ( val <= <NUM_LIT> ) { if ( val > <NUM_LIT> ) { unsigned HOST_WIDE_INT high = val - <NUM_LIT> ; dst . mov ( high ) ; dst . add ( <NUM_LIT> ) ; } else dst . mov ( val ) ; if ( final_shift > <NUM_LIT> ) dst . ashift ( final_shift ) ; } else { for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) { unsigned HOST_WIDE_INT byte = ( val >> ( <NUM_LIT> * ( <NUM_LIT> - i ) ) ) & <NUM_LIT> ;


<s> thumb1_gen_const_int_1 ( t , op1 ) ;


<s> void thumb1_gen_const_int_rtl ( rtx dst , HOST_WIDE_INT op1 ) { thumb1_const_rtl t ( dst ) ;


<s> return thumb1_base_register_rtx_p ( x , QImode , strict_p ) ;


<s> else if ( ( thumb1_index_register_rtx_p ( XEXP ( x , <NUM_LIT> ) , strict_p ) || XEXP ( x , <NUM_LIT> ) == arg_pointer_rtx ) && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && thumb_legitimate_offset_p ( mode , INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) ) return <NUM_LIT> ; else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && REGNO ( XEXP ( x , <NUM_LIT> ) ) == STACK_POINTER_REGNUM && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && INTVAL ( XEXP ( x , <NUM_LIT> ) ) >= <NUM_LIT> && INTVAL ( XEXP ( x , <NUM_LIT> ) ) + GET_MODE_SIZE ( mode ) <= <NUM_LIT> && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; else if ( REG_P ( XEXP ( x , <NUM_LIT> ) ) && ( REGNO ( XEXP ( x , <NUM_LIT> ) ) == FRAME_POINTER_REGNUM || REGNO ( XEXP ( x , <NUM_LIT> ) ) == ARG_POINTER_REGNUM || ( REGNO ( XEXP ( x , <NUM_LIT> ) ) >= FIRST_VIRTUAL_REGISTER && REGNO ( XEXP ( x , <NUM_LIT> ) ) <= LAST_VIRTUAL_POINTER_REGISTER ) ) && GET_MODE_SIZE ( mode ) >= <NUM_LIT> && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) & <NUM_LIT> ) == <NUM_LIT> ) return <NUM_LIT> ; } else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && GET_MODE_SIZE ( mode ) == <NUM_LIT> && SYMBOL_REF_P ( x ) && CONSTANT_POOL_ADDRESS_P ( x ) && ! arm_disable_literal_pool && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return <NUM_LIT> ;


<s> rtx_insn * thumb1_md_asm_adjust ( vec < rtx > & outputs , vec < rtx > & , vec < machine_mode > & , vec < const char * > & constraints , vec < rtx > & , HARD_REG_SET & , location_t ) { for ( unsigned i = <NUM_LIT> , n = outputs . length ( ) ; i < n ; ++ i ) if ( startswith ( constraints [ i ] , <STR_LIT> ) ) {


<s> const char * thumb1_output_casesi ( rtx * operands ) { rtx diff_vec = PATTERN ( NEXT_INSN ( as_a < rtx_insn * > ( operands [ <NUM_LIT> ] ) ) ) ; gcc_assert ( GET_CODE ( diff_vec ) == ADDR_DIFF_VEC ) ; switch ( GET_MODE ( diff_vec ) ) { case E_QImode : return ( ADDR_DIFF_VEC_FLAGS ( diff_vec ) . offset_unsigned ? <STR_LIT> : <STR_LIT> ) ; case E_HImode : return ( ADDR_DIFF_VEC_FLAGS ( diff_vec ) . offset_unsigned ? <STR_LIT> : <STR_LIT> ) ; case E_SImode : return <STR_LIT> ; default : gcc_unreachable ( ) ;


<s> const char * name ; FILE * f = asm_out_file ; gcc_assert ( MEM_P ( DECL_RTL ( current_function_decl ) ) ) ; gcc_assert ( GET_CODE ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) ) == SYMBOL_REF ) ;

name = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> name = XSTR ( XEXP ( DECL_RTL ( current_function_decl ) , <NUM_LIT> ) , <NUM_LIT> ) ; asm_fprintf ( f , <STR_LIT> , IP_REGNUM , PC_REGNUM ) ; asm_fprintf ( f , <STR_LIT> , IP_REGNUM ) ; fprintf ( f , <STR_LIT> ) ; if ( arm_dllexport_name_p ( name ) ) name = arm_strip_name_encoding ( name ) ;

asm_fprintf ( f , <STR_LIT> , STUB_NAME , name ) ;


<s> for ( int reg = FIRST_LO_REGNUM ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( ! callee_saved_reg_p ( reg ) && ! REGNO_REG_SET_P ( prologue_live_out , reg ) ) mask |= <NUM_LIT> << ( reg - FIRST_LO_REGNUM ) ;


<s> unsigned long mask = <NUM_LIT> ; bitmap prologue_live_out = df_get_live_out ( ENTRY_BLOCK_PTR_FOR_FN ( cfun ) ) ; for ( int reg = FIRST_LO_REGNUM ; reg <= LAST_LO_REGNUM ; reg ++ ) if ( ! callee_saved_reg_p ( reg ) && ! REGNO_REG_SET_P ( prologue_live_out , reg ) ) mask |= <NUM_LIT> << ( reg - FIRST_LO_REGNUM ) ;


<s> while ( insn != BB_HEAD ( bb ) && ! NONDEBUG_INSN_P ( insn ) ) insn = PREV_INSN ( insn ) ; if ( insn == BB_HEAD ( bb ) || INSN_CODE ( insn ) != CODE_FOR_cbranchsi4_insn ) continue ; cmp = XEXP ( SET_SRC ( PATTERN ( insn ) ) , <NUM_LIT> ) ; op0 = XEXP ( cmp , <NUM_LIT> ) ; op1 = XEXP ( cmp , <NUM_LIT> ) ; if ( ! CONST_INT_P ( op1 ) || INTVAL ( op1 ) != <NUM_LIT> ) continue ; gcc_assert ( insn != BB_HEAD ( bb ) ) ; for ( prev = PREV_INSN ( insn ) ; ( ! insn_clobbered && prev != BB_HEAD ( bb ) && ( NOTE_P ( prev ) || DEBUG_INSN_P ( prev ) || ( ( set = single_set ( prev ) ) != NULL && get_attr_conds ( prev ) == CONDS_NOCOND ) ) ) ; prev = PREV_INSN ( prev ) ) { if ( reg_set_p ( op0 , prev ) ) insn_clobbered = true ; }


<s> } else if ( outer == ASHIFT || outer == ASHIFTRT || outer == LSHIFTRT ) return <NUM_LIT> ; return COSTS_N_INSNS ( <NUM_LIT> ) ; case CONST : case CONST_DOUBLE : case LABEL_REF : case SYMBOL_REF : return COSTS_N_INSNS ( <NUM_LIT> ) ; case UDIV : case UMOD : case DIV : case MOD : return <NUM_LIT> ; case TRUNCATE : return <NUM_LIT> ; case AND : case XOR : case IOR : return COSTS_N_INSNS ( <NUM_LIT> ) ; case MEM : return ( COSTS_N_INSNS ( <NUM_LIT> ) + COSTS_N_INSNS ( <NUM_LIT> ) * ( ( GET_MODE_SIZE ( mode ) - <NUM_LIT> ) / UNITS_PER_WORD ) + ( ( SYMBOL_REF_P ( x ) && CONSTANT_POOL_ADDRESS_P ( x ) ) ? COSTS_N_INSNS ( <NUM_LIT> ) : <NUM_LIT> ) ) ; case IF_THEN_ELSE : if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PC ) return <NUM_LIT> ; return <NUM_LIT> ; case ZERO_EXTEND : switch ( GET_MODE ( XEXP ( x , <NUM_LIT> ) ) ) { case E_QImode : return ( <NUM_LIT> + ( mode == DImode ? <NUM_LIT> : <NUM_LIT> ) + ( MEM_P ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) ) ; case E_HImode : return ( <NUM_LIT> + ( mode == DImode ? <NUM_LIT> : <NUM_LIT> ) + ( MEM_P ( XEXP ( x , <NUM_LIT> ) ) ? <NUM_LIT> : <NUM_LIT> ) ) ;


<s> machine_mode mode = GET_MODE ( x ) ; int words , cost ; switch ( code ) { case ASHIFT : case ASHIFTRT : case LSHIFTRT : case ROTATERT : return ( mode == SImode ) ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; case PLUS : case MINUS : if ( ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && power_of_two_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) ) || ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == MULT && power_of_two_operand ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) , SImode ) ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; case COMPARE : case NEG : case NOT : return COSTS_N_INSNS ( <NUM_LIT> ) ; case MULT : if ( CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) ) { int const_size = thumb1_size_rtx_costs ( XEXP ( x , <NUM_LIT> ) , CONST_INT , SET ) ; if ( arm_arch6m && arm_m_profile_small_mul ) return COSTS_N_INSNS ( <NUM_LIT> ) ; else return COSTS_N_INSNS ( <NUM_LIT> ) + const_size ; } return COSTS_N_INSNS ( <NUM_LIT> ) ; case SET : words = ARM_NUM_INTS ( GET_MODE_SIZE ( GET_MODE ( SET_DEST ( x ) ) ) ) ; cost = COSTS_N_INSNS ( words ) ; if ( satisfies_constraint_J ( SET_SRC ( x ) ) || satisfies_constraint_K ( SET_SRC ( x ) ) || ( CONST_INT_P ( SET_SRC ( x ) ) && UINTVAL ( SET_SRC ( x ) ) >= <NUM_LIT> && TARGET_HAVE_MOVT && satisfies_constraint_j ( SET_SRC ( x ) ) ) || ( ( words > <NUM_LIT> ) && MEM_P ( SET_SRC ( x ) ) ) ) cost += COSTS_N_INSNS ( <NUM_LIT> ) ; return cost ; case CONST_INT : if ( outer == SET ) { if ( UINTVAL ( x ) < <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( TARGET_HAVE_MOVT && ! ( INTVAL ( x ) & <NUM_LIT> ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( INTVAL ( x ) >= - <NUM_LIT> && INTVAL ( x ) <= - <NUM_LIT> ) return COSTS_N_INSNS ( <NUM_LIT> ) ; if ( thumb_shiftable_const ( INTVAL ( x ) ) ) return COSTS_N_INSNS ( <NUM_LIT> ) ; return arm_disable_literal_pool ? COSTS_N_INSNS ( <NUM_LIT> ) : COSTS_N_INSNS ( <NUM_LIT> ) ; }

else if ( ( outer == PLUS || outer == COMPARE ) && INTVAL ( x ) < <NUM_LIT> && INTVAL ( x ) > - <NUM_LIT> ) return <NUM_LIT> ;


<s> } } live_regs_mask &= ~ <NUM_LIT> ; } had_to_push_lr = ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) != <NUM_LIT> ; live_regs_mask &= <NUM_LIT> ; if ( crtl -> args . pretend_args_size == <NUM_LIT> || TARGET_BACKTRACE ) { if ( had_to_push_lr ) live_regs_mask |= <NUM_LIT> << PC_REGNUM ; if ( live_regs_mask ) thumb_pop ( asm_out_file , live_regs_mask ) ; if ( ! had_to_push_lr ) thumb_exit ( asm_out_file , LR_REGNUM ) ; } else { if ( live_regs_mask ) thumb_pop ( asm_out_file , live_regs_mask ) ; if ( had_to_push_lr ) { if ( size > <NUM_LIT> ) { asm_fprintf ( asm_out_file , <STR_LIT> , IP_REGNUM , LAST_ARG_REGNUM ) ; } thumb_pop ( asm_out_file , <NUM_LIT> << LAST_ARG_REGNUM ) ; if ( size > <NUM_LIT> ) { asm_fprintf ( asm_out_file , <STR_LIT> , LR_REGNUM , LAST_ARG_REGNUM ) ; asm_fprintf ( asm_out_file , <STR_LIT> , LAST_ARG_REGNUM , IP_REGNUM ) ; regno = LR_REGNUM ; }


<s> if ( arm_condexec_mask ) { for ( n = <NUM_LIT> ; n < arm_condexec_masklen ; n ++ ) buff [ n ] = ( arm_condexec_mask & ( <NUM_LIT> << n ) ) ? 't' : 'e' ; buff [ n ] = <NUM_LIT> ; asm_fprintf ( stream , <STR_LIT> , buff , arm_condition_codes [ arm_current_cc ] ) ; arm_condexec_mask = <NUM_LIT> ;


<s> REG_NOTES ( par ) = dwarf ; RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ; } i ++ ; } tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; tmp = emit_insn ( tmp ) ; if ( ! return_in_pc ) { arm_add_cfa_adjust_cfa_note ( tmp , UNITS_PER_WORD * i , stack_pointer_rtx , stack_pointer_rtx ) ; } dwarf = NULL_RTX ; if ( ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && ! return_in_pc ) || ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && return_in_pc ) ) { for ( ; ( saved_regs_mask & ( <NUM_LIT> << j ) ) == <NUM_LIT> ; j ++ ) ; tmp1 = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( tmp1 , get_frame_alias_set ( ) ) ; reg = gen_rtx_REG ( SImode , j ) ; tmp = gen_rtx_SET ( reg , tmp1 ) ;


<s> RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; if ( i % <NUM_LIT> == <NUM_LIT> ) { par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; dwarf = NULL_RTX ; } XVECEXP ( par , <NUM_LIT> , ( i % <NUM_LIT> ) ) = tmp ; dwarf = alloc_reg_note ( REG_CFA_RESTORE , reg , dwarf ) ; if ( ( i % <NUM_LIT> ) == <NUM_LIT> ) { par = emit_insn ( par ) ; REG_NOTES ( par ) = dwarf ; RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ; } i ++ ; } tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; tmp = emit_insn ( tmp ) ; if ( ! return_in_pc ) { arm_add_cfa_adjust_cfa_note ( tmp , UNITS_PER_WORD * i , stack_pointer_rtx , stack_pointer_rtx ) ; } dwarf = NULL_RTX ; if ( ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && ! return_in_pc ) || ( ( num_regs % <NUM_LIT> ) == <NUM_LIT> && return_in_pc ) ) {

for ( ; ( saved_regs_mask & ( <NUM_LIT> << j ) ) == <NUM_LIT> ; j ++ ) ;


<s> i = <NUM_LIT> ; if ( ( num_regs & <NUM_LIT> ) != <NUM_LIT> ) { rtx reg , mem , insn ; reg = gen_rtx_REG ( SImode , regno ) ; if ( num_regs == <NUM_LIT> ) mem = gen_frame_mem ( Pmode , gen_rtx_PRE_DEC ( Pmode , stack_pointer_rtx ) ) ; else mem = gen_frame_mem ( Pmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ) ; tmp = gen_rtx_SET ( mem , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; insn = emit_insn ( tmp ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ; tmp = gen_rtx_SET ( gen_frame_mem ( Pmode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; i ++ ; regno ++ ; XVECEXP ( dwarf , <NUM_LIT> , i ) = tmp ; first = false ; } while ( i < num_regs ) if ( saved_regs_mask & ( <NUM_LIT> << regno ) ) { rtx reg1 , reg2 , mem1 , mem2 ; rtx tmp0 , tmp1 , tmp2 ; int regno2 ; for ( regno2 = regno + <NUM_LIT> ; ( saved_regs_mask & ( <NUM_LIT> << regno2 ) ) == <NUM_LIT> ; regno2 ++ ) ; reg1 = gen_rtx_REG ( SImode , regno ) ; reg2 = gen_rtx_REG ( SImode , regno2 ) ; if ( first ) { rtx insn ;


<s> for ( regno2 = regno + <NUM_LIT> ; ( saved_regs_mask & ( <NUM_LIT> << regno2 ) ) == <NUM_LIT> ; regno2 ++ ) ; reg1 = gen_rtx_REG ( SImode , regno ) ; reg2 = gen_rtx_REG ( SImode , regno2 ) ; if ( first ) { rtx insn ; first = false ; mem1 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * num_regs ) ) ; mem2 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * ( num_regs - <NUM_LIT> ) ) ) ; tmp0 = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - <NUM_LIT> * ( num_regs ) ) ) ; tmp1 = gen_rtx_SET ( mem1 , reg1 ) ; tmp2 = gen_rtx_SET ( mem2 , reg2 ) ; RTX_FRAME_RELATED_P ( tmp0 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp2 ) = <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp0 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp1 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp2 ; insn = emit_insn ( par ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; add_reg_note ( insn , REG_FRAME_RELATED_EXPR , dwarf ) ; } else { mem1 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) ; mem2 = gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * ( i + <NUM_LIT> ) ) ) ; tmp1 = gen_rtx_SET ( mem1 , reg1 ) ; tmp2 = gen_rtx_SET ( mem2 , reg2 ) ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ; RTX_FRAME_RELATED_P ( tmp2 ) = <NUM_LIT> ; par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp1 ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = tmp2 ; emit_insn ( par ) ; } tmp1 = gen_rtx_SET ( gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * i ) ) , reg1 ) ; tmp2 = gen_rtx_SET ( gen_frame_mem ( Pmode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * ( i + <NUM_LIT> ) ) ) , reg2 ) ; RTX_FRAME_RELATED_P ( tmp1 ) = <NUM_LIT> ;


<s> arm_stack_offsets * offsets ; offsets = arm_get_frame_offsets ( ) ; saved_regs_mask = offsets -> saved_regs_mask ; for ( i = <NUM_LIT> , num_regs = <NUM_LIT> ; i <= LAST_ARM_REGNUM ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) num_regs ++ ; if ( ! simple_return && saved_regs_mask ) { gcc_assert ( ! IS_CMSE_ENTRY ( arm_current_func_type ( ) ) ) ; if ( num_regs == <NUM_LIT> ) { rtx par = gen_rtx_PARALLEL ( VOIDmode , rtvec_alloc ( <NUM_LIT> ) ) ;

rtx reg = gen_rtx_REG ( SImode , PC_REGNUM ) ;


<s> rtx addr = gen_rtx_MEM ( SImode , gen_rtx_POST_INC ( SImode , stack_pointer_rtx ) ) ; set_mem_alias_set ( addr , get_frame_alias_set ( ) ) ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( reg , addr ) ; RTX_FRAME_RELATED_P ( XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) ) = <NUM_LIT> ; emit_jump_insn ( par ) ; } else { saved_regs_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; saved_regs_mask |= ( <NUM_LIT> << PC_REGNUM ) ; arm_emit_multi_reg_pop ( saved_regs_mask ) ; }


<s> int n ; int mask ; int max ; max = MAX_INSN_PER_IT_BLOCK ; if ( arm_condexec_count ) arm_condexec_count -- ; if ( arm_condexec_count ) return ; if ( GET_CODE ( body ) != COND_EXEC ) return ; if ( JUMP_P ( insn ) ) return ; predicate = COND_EXEC_TEST ( body ) ; arm_current_cc = get_arm_condition_code ( predicate ) ; n = get_attr_ce_count ( insn ) ; arm_condexec_count = <NUM_LIT> ; arm_condexec_mask = ( <NUM_LIT> << n ) - <NUM_LIT> ; arm_condexec_masklen = n ; for ( ; ; ) { insn = next_nonnote_insn ( insn ) ; if ( ! NONJUMP_INSN_P ( insn ) && ! JUMP_P ( insn ) ) break ; body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == USE || GET_CODE ( body ) == CLOBBER ) continue ; if ( GET_CODE ( body ) != COND_EXEC ) break ; n = get_attr_ce_count ( insn ) ; if ( arm_condexec_masklen + n > max ) break ; predicate = COND_EXEC_TEST ( body ) ; code = get_arm_condition_code ( predicate ) ; mask = ( <NUM_LIT> << n ) - <NUM_LIT> ; if ( arm_current_cc == code ) arm_condexec_mask |= ( mask << arm_condexec_masklen ) ; else if ( arm_current_cc != ARM_INVERSE_CONDITION_CODE ( code ) ) break ;


<s> max = MAX_INSN_PER_IT_BLOCK ; if ( arm_condexec_count ) arm_condexec_count -- ; if ( arm_condexec_count ) return ; if ( GET_CODE ( body ) != COND_EXEC ) return ; if ( JUMP_P ( insn ) ) return ; predicate = COND_EXEC_TEST ( body ) ; arm_current_cc = get_arm_condition_code ( predicate ) ; n = get_attr_ce_count ( insn ) ; arm_condexec_count = <NUM_LIT> ; arm_condexec_mask = ( <NUM_LIT> << n ) - <NUM_LIT> ; arm_condexec_masklen = n ; for ( ; ; ) { insn = next_nonnote_insn ( insn ) ; if ( ! NONJUMP_INSN_P ( insn ) && ! JUMP_P ( insn ) ) break ; body = PATTERN ( insn ) ; if ( GET_CODE ( body ) == USE || GET_CODE ( body ) == CLOBBER ) continue ; if ( GET_CODE ( body ) != COND_EXEC ) break ; n = get_attr_ce_count ( insn ) ; if ( arm_condexec_masklen + n > max ) break ; predicate = COND_EXEC_TEST ( body ) ; code = get_arm_condition_code ( predicate ) ; mask = ( <NUM_LIT> << n ) - <NUM_LIT> ; if ( arm_current_cc == code ) arm_condexec_mask |= ( mask << arm_condexec_masklen ) ; else if ( arm_current_cc != ARM_INVERSE_CONDITION_CODE ( code ) ) break ; arm_condexec_count ++ ; arm_condexec_masklen += n ;


<s> if ( ! CONST_INT_P ( op ) ) return false ; val = INTVAL ( op ) ; return ( val == <NUM_LIT> || val == <NUM_LIT> || val == <NUM_LIT> || val == <NUM_LIT> ) ;


<s> if ( ! CONST_INT_P ( op ) ) return false ; val = INTVAL ( op ) ;

return ( val == <NUM_LIT> || val == <NUM_LIT> || val == <NUM_LIT> || val == <NUM_LIT> ) ;


<s> rtx addend = XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ; HOST_WIDE_INT offset ; if ( ! CONST_INT_P ( addend ) ) return <NUM_LIT> ; offset = INTVAL ( addend ) ; if ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) return ( offset > - <NUM_LIT> && offset < <NUM_LIT> ) ; return ( use_ldrd && offset > - <NUM_LIT> && offset < <NUM_LIT> && ( offset & <NUM_LIT> ) == <NUM_LIT> ) ; } else if ( reload_completed && ( code == LABEL_REF || ( code == CONST && GET_CODE ( XEXP ( x , <NUM_LIT> ) ) == PLUS && GET_CODE ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) == LABEL_REF && CONST_INT_P ( XEXP ( XEXP ( x , <NUM_LIT> ) , <NUM_LIT> ) ) ) ) ) return <NUM_LIT> ; else if ( mode == TImode || ( TARGET_NEON && VALID_NEON_STRUCT_MODE ( mode ) ) || ( TARGET_HAVE_MVE && VALID_MVE_STRUCT_MODE ( mode ) ) ) return <NUM_LIT> ; else if ( code == PLUS ) { rtx xop0 = XEXP ( x , <NUM_LIT> ) ; rtx xop1 = XEXP ( x , <NUM_LIT> ) ; return ( ( arm_address_register_rtx_p ( xop0 , strict_p ) && ( thumb2_legitimate_index_p ( mode , xop1 , strict_p ) || ( ! strict_p && will_be_in_index_register ( xop1 ) ) ) ) || ( arm_address_register_rtx_p ( xop1 , strict_p ) && thumb2_legitimate_index_p ( mode , xop0 , strict_p ) ) ) ; } else if ( can_avoid_literal_pool_for_label_p ( x ) ) return <NUM_LIT> ; else if ( GET_MODE_CLASS ( mode ) != MODE_FLOAT && code == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P ( x ) && ! ( flag_pic && symbol_mentioned_p ( get_pool_constant ( x ) ) && ! pcrel_constant_p ( get_pool_constant ( x ) ) ) ) return <NUM_LIT> ;


<s> if ( TARGET_NEON && VALID_NEON_QREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( TARGET_NEON && VALID_NEON_DREG_MODE ( mode ) ) return ( code == CONST_INT && INTVAL ( index ) < <NUM_LIT> && INTVAL ( index ) > - <NUM_LIT> && ( INTVAL ( index ) & <NUM_LIT> ) == <NUM_LIT> ) ; if ( arm_address_register_rtx_p ( index , strict_p ) && ( GET_MODE_SIZE ( mode ) <= <NUM_LIT> ) ) return <NUM_LIT> ; if ( mode == DImode || mode == DFmode ) { if ( code == CONST_INT ) { HOST_WIDE_INT val = INTVAL ( index ) ; if ( TARGET_LDRD ) return IN_RANGE ( val , - <NUM_LIT> , <NUM_LIT> ) && ( val & <NUM_LIT> ) == <NUM_LIT> ; else return IN_RANGE ( val , - <NUM_LIT> , <NUM_LIT> - <NUM_LIT> ) ; } else return <NUM_LIT> ; } if ( code == MULT ) { rtx xiop0 = XEXP ( index , <NUM_LIT> ) ;

rtx xiop1 = XEXP ( index , <NUM_LIT> ) ;


<s> gcc_assert ( GET_CODE ( diff_vec ) == ADDR_DIFF_VEC ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; switch ( GET_MODE ( diff_vec ) ) { case E_QImode : return <STR_LIT> ; case E_HImode : return <STR_LIT> ; case E_SImode : if ( flag_pic ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; return <STR_LIT> ; } else { output_asm_insn ( <STR_LIT> , operands ) ; return <STR_LIT> ; } default : gcc_unreachable ( ) ; }


<s> rtx * labelp ; gcc_assert ( regno < LR_REGNUM ) ; if ( in_section == text_section ) { thumb_call_reg_needed = <NUM_LIT> ; if ( thumb_call_via_label [ regno ] == NULL ) thumb_call_via_label [ regno ] = gen_label_rtx ( ) ; labelp = thumb_call_via_label + regno ;


<s> return offsets -> outgoing_args - offsets -> soft_frame ; case ARM_HARD_FRAME_POINTER_REGNUM : return offsets -> saved_regs - offsets -> soft_frame ; case THUMB_HARD_FRAME_POINTER_REGNUM : return offsets -> locals_base - offsets -> soft_frame ; default : gcc_unreachable ( ) ; } break ; default : gcc_unreachable ( ) ; }


<s> } if ( len >= <NUM_LIT> ) { emit_insn ( gen_cpymem8b ( out , in , out , in ) ) ; len -= <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( SImode ) ; emit_insn ( gen_movsi ( reg , gen_rtx_MEM ( SImode , in ) ) ) ; emit_insn ( gen_movsi ( gen_rtx_MEM ( SImode , out ) , reg ) ) ; len -= <NUM_LIT> ; offset += <NUM_LIT> ; } if ( len >= <NUM_LIT> ) { rtx reg = gen_reg_rtx ( HImode ) ;

emit_insn ( gen_movhi ( reg , gen_rtx_MEM ( HImode , plus_constant ( Pmode , in , offset ) ) ) ) ;


<s> for ( reg = LAST_LO_REGNUM ; reg > LAST_ARG_REGNUM ; reg -- ) if ( pushed_regs_mask & ( <NUM_LIT> << reg ) ) return reg ; if ( TARGET_THUMB2 ) { for ( reg = FIRST_HI_REGNUM ; reg < <NUM_LIT> ; reg ++ ) if ( pushed_regs_mask & ( <NUM_LIT> << reg ) ) return reg ;


<s> static bool thumb_force_lr_save ( void ) { return ! cfun -> machine -> lr_save_eliminated && ( ! crtl -> is_leaf || thumb_far_jump_used_p ( ) || df_regs_ever_live_p ( LR_REGNUM ) ) ;


<s> return ! cfun -> machine -> lr_save_eliminated && ( ! crtl -> is_leaf || thumb_far_jump_used_p ( ) || df_regs_ever_live_p ( LR_REGNUM ) ) ;


<s> default : return ( val >= <NUM_LIT> && ( val + GET_MODE_SIZE ( mode ) ) <= <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ) ;


<s> switch ( GET_MODE_SIZE ( mode ) ) { case <NUM_LIT> : return val >= <NUM_LIT> && val < <NUM_LIT> ; case <NUM_LIT> :

return val >= <NUM_LIT> && val < <NUM_LIT> && ( val & <NUM_LIT> ) == <NUM_LIT> ;


<s> case PLUS : arg1 = XEXP ( addr , <NUM_LIT> ) ; arg2 = XEXP ( addr , <NUM_LIT> ) ; if ( CONSTANT_P ( arg1 ) ) base = arg2 , offset = arg1 ; else base = arg1 , offset = arg2 ; gcc_assert ( REG_P ( base ) ) ; if ( REG_P ( offset ) ) { int reg_offset = REGNO ( offset ) ; int reg_base = REGNO ( base ) ; int reg_dest = REGNO ( operands [ <NUM_LIT> ] ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_base , reg_offset ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest , reg_dest + <NUM_LIT> ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_dest + <NUM_LIT> ) ; } else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; if ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( base ) ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } else { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; } } break ;


<s> break ; case CONST : operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case PLUS : arg1 = XEXP ( addr , <NUM_LIT> ) ; arg2 = XEXP ( addr , <NUM_LIT> ) ; if ( CONSTANT_P ( arg1 ) ) base = arg2 , offset = arg1 ; else base = arg1 , offset = arg2 ; gcc_assert ( REG_P ( base ) ) ; if ( REG_P ( offset ) ) { int reg_offset = REGNO ( offset ) ; int reg_base = REGNO ( base ) ; int reg_dest = REGNO ( operands [ <NUM_LIT> ] ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_base , reg_offset ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest , reg_dest + <NUM_LIT> ) ; asm_fprintf ( asm_out_file , <STR_LIT> , reg_dest + <NUM_LIT> , reg_dest + <NUM_LIT> ) ; } else { operands [ <NUM_LIT> ] = adjust_address ( operands [ <NUM_LIT> ] , SImode , <NUM_LIT> ) ; if ( REGNO ( operands [ <NUM_LIT> ] ) == REGNO ( base ) ) { output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ;


<s> case <NUM_LIT> : if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; break ; case <NUM_LIT> : if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; if ( REGNO ( operands [ <NUM_LIT> ] ) > REGNO ( operands [ <NUM_LIT> ] ) ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ; output_asm_insn ( <STR_LIT> , operands ) ; output_asm_insn ( <STR_LIT> , operands ) ; break ;


<s> static void thumb_pop ( FILE * f , unsigned long mask ) { int regno ; int lo_mask = mask & <NUM_LIT> ; gcc_assert ( mask ) ; if ( lo_mask == <NUM_LIT> && ( mask & ( <NUM_LIT> << PC_REGNUM ) ) ) { thumb_exit ( f , - <NUM_LIT> ) ; return ; } fprintf ( f , <STR_LIT> ) ; for ( regno = <NUM_LIT> ; regno <= LAST_LO_REGNUM ; regno ++ , lo_mask >>= <NUM_LIT> ) { if ( lo_mask & <NUM_LIT> ) { asm_fprintf ( f , <STR_LIT> , regno ) ; if ( ( lo_mask & ~ <NUM_LIT> ) != <NUM_LIT> ) fprintf ( f , <STR_LIT> ) ; }


<s> emit_insn ( gen_thumb_movhi_clobber ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> rtx insn , dwarf ; amount = offsets -> outgoing_args - offsets -> locals_base ; if ( amount < <NUM_LIT> ) insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , GEN_INT ( amount ) ) ) ; else { emit_insn ( gen_movsi ( hard_frame_pointer_rtx , GEN_INT ( amount ) ) ) ; if ( TARGET_THUMB2 ) { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } else { insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , hard_frame_pointer_rtx , stack_pointer_rtx ) ) ; }

dwarf = gen_rtx_SET ( hard_frame_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , amount ) ) ;


<s> mask = offsets -> saved_regs_mask ; if ( mask & ( <NUM_LIT> << LR_REGNUM ) ) { limit = <NUM_LIT> ; if ( frame_pointer_needed ) { delta = offsets -> soft_frame - offsets -> saved_args ; reg = THUMB_HARD_FRAME_POINTER_REGNUM ; if ( TARGET_THUMB1 ) limit = <NUM_LIT> ; } else { delta = offsets -> outgoing_args - offsets -> saved_args ; reg = SP_REGNUM ; } if ( TARGET_THUMB1 && TARGET_BACKTRACE ) delta -= <NUM_LIT> ; delta -= <NUM_LIT> ; addr = gen_rtx_REG ( SImode , reg ) ; if ( delta > limit ) { emit_insn ( gen_movsi ( scratch , GEN_INT ( delta ) ) ) ; emit_insn ( gen_addsi3 ( scratch , scratch , stack_pointer_rtx ) ) ; addr = scratch ; } else addr = plus_constant ( Pmode , addr , delta ) ; mem = gen_frame_mem ( Pmode , addr ) ; MEM_VOLATILE_P ( mem ) = true ; emit_move_insn ( mem , source ) ; }

else emit_move_insn ( gen_rtx_REG ( Pmode , LR_REGNUM ) , source ) ;


<s> delta = offsets -> outgoing_args - offsets -> saved_args ; reg = SP_REGNUM ; } if ( TARGET_THUMB1 && TARGET_BACKTRACE ) delta -= <NUM_LIT> ; delta -= <NUM_LIT> ; addr = gen_rtx_REG ( SImode , reg ) ; if ( delta > limit ) { emit_insn ( gen_movsi ( scratch , GEN_INT ( delta ) ) ) ; emit_insn ( gen_addsi3 ( scratch , scratch , stack_pointer_rtx ) ) ; addr = scratch ;


<s> int thumb_shiftable_const ( unsigned HOST_WIDE_INT val ) { unsigned HOST_WIDE_INT mask = <NUM_LIT> ; int i ; val = val & ( unsigned HOST_WIDE_INT ) <NUM_LIT> ; if ( val == <NUM_LIT> ) return <NUM_LIT> ; for ( i = <NUM_LIT> ; i < <NUM_LIT> ; i ++ ) if ( ( val & ( mask << i ) ) == val ) return <NUM_LIT> ;


<s> if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; default :


<s> if ( XINT ( x , <NUM_LIT> ) == UNSPEC_TLS ) return <NUM_LIT> ; default : return <NUM_LIT> ; }


<s> if ( IS_INTERRUPT ( func_type ) && ( frame_pointer_needed || TARGET_THUMB ) ) return <NUM_LIT> ; if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) return <NUM_LIT> ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( crtl -> args . pretend_args_size || cfun -> machine -> uses_anonymous_args || crtl -> calls_eh_return || cfun -> calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( TARGET_APCS_FRAME && frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) || ( ! ( TARGET_APCS_FRAME && frame_pointer_needed ) && arm_compute_static_chain_stack_bytes ( ) != <NUM_LIT> ) ) return <NUM_LIT> ; saved_int_regs = offsets -> saved_regs_mask ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5t && TARGET_ARM ) { if ( ! call_used_or_fixed_reg_p ( <NUM_LIT> ) ) return <NUM_LIT> ; if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ;


<s> int regno ; unsigned int func_type ; unsigned long saved_int_regs ; unsigned HOST_WIDE_INT stack_adjust ; arm_stack_offsets * offsets ; if ( ! reload_completed ) return <NUM_LIT> ; func_type = arm_current_func_type ( ) ; if ( func_type & ( ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN ) ) return <NUM_LIT> ; if ( IS_INTERRUPT ( func_type ) && ( frame_pointer_needed || TARGET_THUMB ) ) return <NUM_LIT> ; if ( TARGET_LDRD && current_tune -> prefer_ldrd_strd && ! optimize_function_for_size_p ( cfun ) ) return <NUM_LIT> ; offsets = arm_get_frame_offsets ( ) ; stack_adjust = offsets -> outgoing_args - offsets -> saved_regs ; if ( crtl -> args . pretend_args_size || cfun -> machine -> uses_anonymous_args || crtl -> calls_eh_return || cfun -> calls_alloca || ! ( stack_adjust == <NUM_LIT> || ( TARGET_APCS_FRAME && frame_pointer_needed && stack_adjust == <NUM_LIT> ) ) || ( ! ( TARGET_APCS_FRAME && frame_pointer_needed ) && arm_compute_static_chain_stack_bytes ( ) != <NUM_LIT> ) ) return <NUM_LIT> ; saved_int_regs = offsets -> saved_regs_mask ; if ( stack_adjust == <NUM_LIT> && ! arm_arch5t && TARGET_ARM ) { if ( ! call_used_or_fixed_reg_p ( <NUM_LIT> ) ) return <NUM_LIT> ; if ( arm_size_return_regs ( ) >= ( <NUM_LIT> * UNITS_PER_WORD ) ) return <NUM_LIT> ;


<s> offsets = arm_get_frame_offsets ( ) ; return offsets -> outgoing_args != <NUM_LIT> ;


<s> seen_thumb1_vfp = true ; } return true ; } if ( pcs_variant != ARM_PCS_AAPCS_LOCAL ) return false ; return ( TARGET_32BIT && TARGET_HARD_FLOAT && ( TARGET_VFP_DOUBLE || ! is_double ) ) ;


<s> static bool seen_thumb1_vfp = false ; if ( TARGET_THUMB1 && ! seen_thumb1_vfp ) { sorry ( <STR_LIT> ) ; seen_thumb1_vfp = true ; } return true ;


<s> HOST_WIDE_INT offsets [ <NUM_LIT> ] , offset , align [ <NUM_LIT> ] ; rtx base = NULL_RTX ; rtx cur_base , cur_offset ; int i , gap ; for ( i = <NUM_LIT> ; i < nops ; i ++ ) { if ( ! mem_ok_for_ldrd_strd ( operands [ nops + i ] , & cur_base , & cur_offset , & align [ i ] ) ) return false ; if ( i == <NUM_LIT> ) base = cur_base ; else if ( REGNO ( base ) != REGNO ( cur_base ) ) return false ; offsets [ i ] = INTVAL ( cur_offset ) ; if ( GET_CODE ( operands [ i ] ) == SUBREG ) return false ; } if ( offsets [ <NUM_LIT> ] > offsets [ <NUM_LIT> ] ) return false ; gap = offsets [ <NUM_LIT> ] - offsets [ <NUM_LIT> ] ; offset = offsets [ <NUM_LIT> ] ; if ( gap != GET_MODE_SIZE ( SImode ) ) return false ;

if ( ! align_ok_ldrd_strd ( align [ <NUM_LIT> ] , offset ) ) return false ;


<s> const REAL_VALUE_TYPE * r ; if ( ! CONST_DOUBLE_P ( x ) ) return - <NUM_LIT> ; r = CONST_DOUBLE_REAL_VALUE ( x ) ; if ( REAL_VALUE_NEGATIVE ( * r ) || REAL_VALUE_ISNAN ( * r ) || REAL_VALUE_ISINF ( * r ) || ! real_isinteger ( r , SFmode ) ) return - <NUM_LIT> ; HOST_WIDE_INT hwint = exact_log2 ( real_to_integer ( r ) ) ; if ( ! IN_RANGE ( hwint , <NUM_LIT> , <NUM_LIT> ) ) return - <NUM_LIT> ;


<s> HOST_WIDE_INT value = real_to_integer ( & r0 ) ; value = value & <NUM_LIT> ;

if ( ( value != <NUM_LIT> ) && ( ( value & ( value - <NUM_LIT> ) ) == <NUM_LIT> ) ) {


<s> static int vfp3_const_double_index ( rtx x ) { REAL_VALUE_TYPE r , m ; int sign , exponent ; unsigned HOST_WIDE_INT mantissa , mant_hi ; unsigned HOST_WIDE_INT mask ; int point_pos = <NUM_LIT> * HOST_BITS_PER_WIDE_INT - <NUM_LIT> ; bool fail ; if ( ! TARGET_VFP3 || ! CONST_DOUBLE_P ( x ) ) return - <NUM_LIT> ; r = * CONST_DOUBLE_REAL_VALUE ( x ) ; if ( REAL_VALUE_ISINF ( r ) || REAL_VALUE_ISNAN ( r ) || REAL_VALUE_MINUS_ZERO ( r ) ) return - <NUM_LIT> ; sign = REAL_VALUE_NEGATIVE ( r ) ? <NUM_LIT> : <NUM_LIT> ; r = real_value_abs ( & r ) ; exponent = REAL_EXP ( & r ) ; real_ldexp ( & m , & r , point_pos - exponent ) ; wide_int w = real_to_integer ( & m , & fail , HOST_BITS_PER_WIDE_INT * <NUM_LIT> ) ; mantissa = w . elt ( <NUM_LIT> ) ; mant_hi = w . elt ( <NUM_LIT> ) ;

if ( mantissa != <NUM_LIT> ) return - <NUM_LIT> ;


<s> mant_hi = w . elt ( <NUM_LIT> ) ; if ( mantissa != <NUM_LIT> ) return - <NUM_LIT> ; point_pos -= HOST_BITS_PER_WIDE_INT ; mantissa = mant_hi ; mask = ( HOST_WIDE_INT_1U << ( point_pos - <NUM_LIT> ) ) - <NUM_LIT> ; if ( ( mantissa & mask ) != <NUM_LIT> ) return - <NUM_LIT> ; mantissa >>= point_pos - <NUM_LIT> ; if ( mantissa == <NUM_LIT> ) return - <NUM_LIT> ; gcc_assert ( mantissa >= <NUM_LIT> && mantissa <= <NUM_LIT> ) ; exponent = <NUM_LIT> - exponent ; if ( exponent < <NUM_LIT> || exponent > <NUM_LIT> ) return - <NUM_LIT> ;

return ( sign << <NUM_LIT> ) | ( ( exponent ^ <NUM_LIT> ) << <NUM_LIT> ) | ( mantissa - <NUM_LIT> ) ;


<s> int vfp3_const_double_rtx ( rtx x ) {


<s> return vfp3_const_double_index ( x ) != - <NUM_LIT> ;


<s> reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = gen_rtx_SET ( gen_frame_mem ( BLKmode , gen_rtx_PRE_MODIFY ( Pmode , stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( count * <NUM_LIT> ) ) ) ) , gen_rtx_UNSPEC ( BLKmode , gen_rtvec ( <NUM_LIT> , reg ) , UNSPEC_PUSH_MULT ) ) ; tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , - ( count * <NUM_LIT> ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; tmp = gen_rtx_SET ( gen_frame_mem ( DFmode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ;


<s> XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; tmp = gen_rtx_SET ( gen_frame_mem ( DFmode , stack_pointer_rtx ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , <NUM_LIT> ) = tmp ; for ( i = <NUM_LIT> ; i < count ; i ++ ) { reg = gen_rtx_REG ( DFmode , base_reg ) ; base_reg += <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , i ) = gen_rtx_USE ( VOIDmode , reg ) ; tmp = gen_rtx_SET ( gen_frame_mem ( DFmode , plus_constant ( Pmode , stack_pointer_rtx , i * <NUM_LIT> ) ) , reg ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( dwarf , <NUM_LIT> , i + <NUM_LIT> ) = tmp ; } par = emit_insn ( par ) ; add_reg_note ( par , REG_FRAME_RELATED_EXPR , dwarf ) ;

RTX_FRAME_RELATED_P ( par ) = <NUM_LIT> ;


<s> int p ; int base ; int i ; rtx addr_reg = REG_P ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ) ? XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) : XEXP ( XEXP ( operands [ <NUM_LIT> ] , <NUM_LIT> ) , <NUM_LIT> ) ; bool push_p = REGNO ( addr_reg ) == SP_REGNUM ; if ( push_p ) strcpy ( pattern , <STR_LIT> ) ; else strcpy ( pattern , <STR_LIT> ) ;


<s> gcc_assert ( REG_P ( operands [ <NUM_LIT> ] ) ) ; base = ( REGNO ( operands [ <NUM_LIT> ] ) - FIRST_VFP_REGNUM ) / <NUM_LIT> ; for ( i = <NUM_LIT> ; i < XVECLEN ( operands [ <NUM_LIT> ] , <NUM_LIT> ) ; i ++ ) { p += sprintf ( & pattern [ p ] , <STR_LIT> , base + i ) ; } strcpy ( & pattern [ p ] , <STR_LIT> ) ;

output_asm_insn ( pattern , operands ) ;


<s> return GET_CODE ( x ) == UNSPEC && ( XINT ( x , <NUM_LIT> ) == UNSPEC_PIC_SYM ) ;


<s> static bool will_be_in_index_register ( const_rtx x ) {

return GET_CODE ( x ) == UNSPEC && ( XINT ( x , <NUM_LIT> ) == UNSPEC_PIC_SYM ) ;


<s> rtx shifted_operand ; int opno ; extract_insn ( insn ) ; shifted_operand = recog_data . operand [ shift_opnum ] ; extract_insn ( dep ) ; preprocess_constraints ( dep ) ; for ( opno = <NUM_LIT> ; opno < recog_data . n_operands ; opno ++ ) { if ( recog_data . operand_type [ opno ] == OP_IN ) continue ; if ( reg_overlap_mentioned_p ( recog_data . operand [ opno ] , shifted_operand ) ) { * cost = <NUM_LIT> ; return false ; } } } }


<s> int shift_opnum = get_attr_shift ( insn ) ; enum attr_type attr_type = get_attr_type ( dep ) ; if ( shift_opnum != <NUM_LIT> && ( attr_type == TYPE_ALU_SHIFT_IMM_LSL_1TO4 || attr_type == TYPE_ALU_SHIFT_IMM_OTHER || attr_type == TYPE_ALUS_SHIFT_IMM || attr_type == TYPE_LOGIC_SHIFT_IMM || attr_type == TYPE_LOGICS_SHIFT_IMM || attr_type == TYPE_ALU_SHIFT_REG || attr_type == TYPE_ALUS_SHIFT_REG || attr_type == TYPE_LOGIC_SHIFT_REG || attr_type == TYPE_LOGICS_SHIFT_REG || attr_type == TYPE_MOV_SHIFT || attr_type == TYPE_MVN_SHIFT || attr_type == TYPE_MOV_SHIFT_REG || attr_type == TYPE_MVN_SHIFT_REG ) ) { rtx shifted_operand ; int opno ; extract_insn ( insn ) ; shifted_operand = recog_data . operand [ shift_opnum ] ; extract_insn ( dep ) ; preprocess_constraints ( dep ) ; for ( opno = <NUM_LIT> ; opno < recog_data . n_operands ; opno ++ ) { if ( recog_data . operand_type [ opno ] == OP_IN ) continue ; if ( reg_overlap_mentioned_p ( recog_data . operand [ opno ] , shifted_operand ) ) { * cost = <NUM_LIT> ; return false ;


<s> if ( fcpu_info ) f = fopen ( fcpu_info , <STR_LIT> ) ; else f = fopen ( <STR_LIT> , <STR_LIT> ) ; if ( f == NULL ) goto not_found ; while ( fgets ( buf , sizeof ( buf ) , f ) != NULL ) { if ( strncmp ( buf , <STR_LIT> , sizeof ( <STR_LIT> ) - <NUM_LIT> ) == <NUM_LIT> ) { int i ; for ( i = <NUM_LIT> ; vendors_table [ i ] . vendor_no != NULL ; i ++ ) if ( strstr ( buf , vendors_table [ i ] . vendor_no ) != NULL ) { cpu_table = vendors_table [ i ] . vendor_parts ; break ; } } if ( strncmp ( buf , <STR_LIT> , sizeof ( <STR_LIT> ) - <NUM_LIT> ) == <NUM_LIT> ) { int i ; if ( cpu_table == NULL ) goto not_found ;

for ( i = <NUM_LIT> ; cpu_table [ i ] . part_no != NULL ; i ++ ) if ( strstr ( buf , cpu_table [ i ] . part_no ) != NULL ) {


<s> break ; } break ; } } fclose ( f ) ; if ( val == NULL ) goto not_found ; return concat ( <STR_LIT> , argv [ <NUM_LIT> ] , <STR_LIT> , val , NULL ) ; not_found : { unsigned int i ; unsigned int opt ; const char * search [ ] = { NULL , <STR_LIT> } ; if ( f ) fclose ( f ) ; search [ <NUM_LIT> ] = argv [ <NUM_LIT> ] ; for ( opt = <NUM_LIT> ; opt < ARRAY_SIZE ( search ) ; opt ++ ) for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( configure_default_options ) ; i ++ ) if ( strcmp ( configure_default_options [ i ] . name , search [ opt ] ) == <NUM_LIT> ) return concat ( <STR_LIT> , search [ opt ] , <STR_LIT> , configure_default_options [ i ] . value , NULL ) ; return NULL ; }


<s> int i ; if ( cpu_table == NULL ) goto not_found ; for ( i = <NUM_LIT> ; cpu_table [ i ] . part_no != NULL ; i ++ ) if ( strstr ( buf , cpu_table [ i ] . part_no ) != NULL ) { val = arch ? cpu_table [ i ] . arch_name : cpu_table [ i ] . cpu_name ; break ; } break ; } } if ( val ) { fclose ( f ) ; return concat ( <STR_LIT> , argv [ <NUM_LIT> ] , <STR_LIT> , val , NULL ) ; } not_found : { unsigned int i ; unsigned int opt ; const char * search [ ] = { NULL , <STR_LIT> } ; if ( f ) fclose ( f ) ;

search [ <NUM_LIT> ] = argv [ <NUM_LIT> ] ;