<s> virtual unsigned int execute ( function * ) { return rest_of_insert_bti ( ) ;


<s> insn = NEXT_INSN ( insn ) ) { if ( LABEL_P ( insn ) && ( LABEL_PRESERVE_P ( insn ) || bb -> flags & BB_NON_LOCAL_GOTO_TARGET ) ) { bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , insn ) ; continue ; } if ( JUMP_P ( insn ) ) { rtx_jump_table_data * table ; if ( tablejump_p ( insn , NULL , & table ) ) { rtvec vec = table -> get_labels ( ) ; int j ; rtx_insn * label ; for ( j = GET_NUM_ELEM ( vec ) - <NUM_LIT> ; j >= <NUM_LIT> ; -- j ) { label = as_a < rtx_insn * > ( XEXP ( RTVEC_ELT ( vec , j ) , <NUM_LIT> ) ) ; rtx_insn * next = next_nonnote_nondebug_insn ( label ) ; if ( aarch_bti_j_insn_p ( next ) ) continue ; bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , label ) ; } } } if ( CALL_P ( insn ) && ( find_reg_note ( insn , REG_SETJMP , NULL ) ) ) { bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , insn ) ; continue ; }


<s> virtual bool gate ( function * ) { if ( aarch_bti_enabled ( ) ) { aarch_bti_arch_check ( ) ; return true ; }


<s> rtl_opt_pass * make_pass_insert_bti ( gcc :: context * ctxt ) {


<s> pass_insert_bti ( gcc :: context * ctxt ) : rtl_opt_pass ( pass_data_insert_bti , ctxt ) {


<s> if ( LABEL_P ( insn ) && ( LABEL_PRESERVE_P ( insn ) || bb -> flags & BB_NON_LOCAL_GOTO_TARGET ) ) { bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , insn ) ; continue ; } if ( JUMP_P ( insn ) ) { rtx_jump_table_data * table ; if ( tablejump_p ( insn , NULL , & table ) ) { rtvec vec = table -> get_labels ( ) ; int j ; rtx_insn * label ; for ( j = GET_NUM_ELEM ( vec ) - <NUM_LIT> ; j >= <NUM_LIT> ; -- j ) { label = as_a < rtx_insn * > ( XEXP ( RTVEC_ELT ( vec , j ) , <NUM_LIT> ) ) ; rtx_insn * next = next_nonnote_nondebug_insn ( label ) ; if ( aarch_bti_j_insn_p ( next ) ) continue ; bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , label ) ; } } } if ( CALL_P ( insn ) && ( find_reg_note ( insn , REG_SETJMP , NULL ) ) ) { bti_insn = aarch_gen_bti_j ( ) ; emit_insn_after ( bti_insn , insn ) ; continue ; } } } if ( ! cgraph_node :: get ( cfun -> decl ) -> only_called_directly_p ( ) ) { bb = ENTRY_BLOCK_PTR_FOR_FN ( cfun ) -> next_bb ; insn = BB_HEAD ( bb ) ; if ( ! aarch_pac_insn_p ( get_first_nonnote_insn ( ) ) ) {


<s> static enum aarch_parse_opt_result aarch_handle_bti_protection ( char * str ATTRIBUTE_UNUSED , char * rest ATTRIBUTE_UNUSED ) { aarch_enable_bti = <NUM_LIT> ; return AARCH_PARSE_OK ;


<s> aarch_ra_sign_scope = AARCH_FUNCTION_NONE ; aarch_enable_bti = <NUM_LIT> ; if ( rest ) { error ( <STR_LIT> , rest , str ) ;


<s> static enum aarch_parse_opt_result aarch_handle_pac_ret_protection ( char * str ATTRIBUTE_UNUSED , char * rest ATTRIBUTE_UNUSED ) { aarch_ra_sign_scope = AARCH_FUNCTION_NON_LEAF ;


<s> error ( <STR_LIT> , rest , str ) ; return AARCH_PARSE_INVALID_FEATURE ; } return AARCH_PARSE_OK ;


<s> next_str = strtok_r ( NULL , <STR_LIT> , & token_save ) ; } else type ++ ; } if ( found && res == AARCH_PARSE_OK ) { bool found_subtype = true ; while ( found_subtype ) { found_subtype = false ; const aarch_branch_protect_type * subtype = type -> subtypes ; while ( str && subtype && subtype -> name && ! found_subtype && res == AARCH_PARSE_OK ) { if ( strcmp ( str , subtype -> name ) == <NUM_LIT> ) { found_subtype = true ; res = subtype -> handler ( str , next_str ) ; str = next_str ; next_str = strtok_r ( NULL , <STR_LIT> , & token_save ) ; } else subtype ++ ; } } } else if ( ! found ) res = AARCH_PARSE_INVALID_ARG ; } } if ( last_str ) { if ( str ) strcpy ( * last_str , str ) ; else * last_str = NULL ; } if ( res == AARCH_PARSE_OK ) { if ( ! accepted_branch_protection_string ) accepted_branch_protection_string = ( char * ) xmalloc ( BRANCH_PROTECT_STR_MAX + <NUM_LIT> ) ; strncpy ( accepted_branch_protection_string , const_str , BRANCH_PROTECT_STR_MAX + <NUM_LIT> ) ; accepted_branch_protection_string [ BRANCH_PROTECT_STR_MAX ] = '\0' ;


<s> const aarch_branch_protect_type * subtype = type -> subtypes ; while ( str && subtype && subtype -> name && ! found_subtype && res == AARCH_PARSE_OK ) { if ( strcmp ( str , subtype -> name ) == <NUM_LIT> ) { found_subtype = true ; res = subtype -> handler ( str , next_str ) ; str = next_str ; next_str = strtok_r ( NULL , <STR_LIT> , & token_save ) ; } else subtype ++ ; } } } else if ( ! found ) res = AARCH_PARSE_INVALID_ARG ; } } if ( last_str ) { if ( str ) strcpy ( * last_str , str ) ; else * last_str = NULL ; } if ( res == AARCH_PARSE_OK ) { if ( ! accepted_branch_protection_string ) accepted_branch_protection_string = ( char * ) xmalloc ( BRANCH_PROTECT_STR_MAX + <NUM_LIT> ) ; strncpy ( accepted_branch_protection_string , const_str , BRANCH_PROTECT_STR_MAX + <NUM_LIT> ) ;


<s> char * str = ( char * ) xmalloc ( strlen ( const_str ) ) ; enum aarch_parse_opt_result res = aarch_parse_branch_protection ( const_str , & str ) ;

if ( res == AARCH_PARSE_INVALID_ARG ) error ( <STR_LIT> , str ) ;


<s> if ( res == AARCH_PARSE_INVALID_ARG ) error ( <STR_LIT> , str ) ;

else if ( res == AARCH_PARSE_MISSING_ARG ) error ( <STR_LIT> ) ;


<s> break ; case C ( 'g' , 't' ) : mode = CCmode , code = GT ; break ; case C ( 'h' , 'i' ) : mode = CCmode , code = GTU ; break ; case C ( 'l' , 'e' ) : mode = CCmode , code = LE ; break ; case C ( 'l' , 's' ) : mode = CCmode , code = LEU ; break ; case C ( 'l' , 't' ) : mode = CCmode , code = LT ; break ; case C ( 'm' , 'i' ) : mode = CC_NZmode , code = LT ; break ; case C ( 'n' , 'e' ) : mode = CC_NZmode , code = NE ; break ; case C ( 'p' , 'l' ) : mode = CC_NZmode , code = GE ; break ; case C ( 'v' , 'c' ) : mode = CC_Vmode , code = EQ ; break ; case C ( 'v' , 's' ) : mode = CC_Vmode , code = NE ; break ; default : error ( <STR_LIT> , constraints [ i ] ) ; continue ; } rtx dest = outputs [ i ] ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! SCALAR_INT_MODE_P ( dest_mode ) ) { error ( <STR_LIT> ) ; continue ; } if ( ! saw_asm_flag ) { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_REG ( CCmode , CC_REGNUM ) ; saw_asm_flag = true ; }


unsigned int regno = REGNO ( SET_DEST ( producer_set ) ) ;


<s> rtx value , op ; rtx early_op ; if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return <NUM_LIT> ; if ( ( early_op = arm_find_shift_sub_rtx ( op ) ) ) {

if ( REG_P ( early_op ) ) early_op = op ;


if ( producer_src && consumer_src && GET_CODE ( producer_src ) == UNSPEC && GET_CODE ( consumer_src ) == UNSPEC && ( ( XINT ( producer_src , <NUM_LIT> ) == UNSPEC_AESE && XINT ( consumer_src , <NUM_LIT> ) == UNSPEC_AESMC ) || ( XINT ( producer_src , <NUM_LIT> ) == UNSPEC_AESD && XINT ( consumer_src , <NUM_LIT> ) == UNSPEC_AESIMC ) ) ) {


if ( GET_CODE ( early_op ) == ASHIFT ) return ( ! REG_P ( XEXP ( early_op , <NUM_LIT> ) ) || ! REG_P ( XEXP ( early_op , <NUM_LIT> ) ) ) ;


<s> if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return <NUM_LIT> ; if ( ( early_op = arm_find_shift_sub_rtx ( op ) ) ) { if ( REG_P ( early_op ) ) early_op = op ; if ( GET_CODE ( early_op ) == ASHIFT ) return ( ! REG_P ( XEXP ( early_op , <NUM_LIT> ) ) || ! REG_P ( XEXP ( early_op , <NUM_LIT> ) ) ) ; else return <NUM_LIT> ;


<s> int aarch_accumulator_forwarding ( rtx_insn * producer , rtx_insn * consumer ) { rtx producer_set = single_set ( producer ) ; rtx consumer_set = single_set ( consumer ) ; if ( ! producer_set || ! consumer_set ) return <NUM_LIT> ; rtx dest = SET_DEST ( producer_set ) ; rtx mla = SET_SRC ( consumer_set ) ; if ( ! REG_P ( dest ) ) return <NUM_LIT> ; rtx accumulator ; if ( GET_CODE ( mla ) == ZERO_EXTEND ) mla = XEXP ( mla , <NUM_LIT> ) ; switch ( GET_CODE ( mla ) ) { case PLUS : if ( GET_CODE ( XEXP ( mla , <NUM_LIT> ) ) == MULT ) accumulator = XEXP ( mla , <NUM_LIT> ) ; else return <NUM_LIT> ; break ; case MINUS : if ( GET_CODE ( XEXP ( mla , <NUM_LIT> ) ) == MULT ) accumulator = XEXP ( mla , <NUM_LIT> ) ; else return <NUM_LIT> ; break ; case FMA : { if ( REG_P ( XEXP ( mla , <NUM_LIT> ) ) && REG_P ( XEXP ( mla , <NUM_LIT> ) ) && ( REG_P ( XEXP ( mla , <NUM_LIT> ) ) || GET_CODE ( XEXP ( mla , <NUM_LIT> ) ) == NEG ) ) { accumulator = XEXP ( mla , <NUM_LIT> ) ; } else if ( REG_P ( XEXP ( mla , <NUM_LIT> ) ) && GET_CODE ( XEXP ( mla , <NUM_LIT> ) ) == NEG && ( REG_P ( XEXP ( mla , <NUM_LIT> ) ) || GET_CODE ( XEXP ( mla , <NUM_LIT> ) ) == NEG ) ) { accumulator = XEXP ( XEXP ( mla , <NUM_LIT> ) , <NUM_LIT> ) ; } else return <NUM_LIT> ; break ; } default : return <NUM_LIT> ; } if ( SUBREG_P ( accumulator ) ) accumulator = SUBREG_REG ( accumulator ) ; if ( ! REG_P ( accumulator ) ) return <NUM_LIT> ; return ( REGNO ( dest ) == REGNO ( accumulator ) ) ;


<s> enum memmodel model = memmodel_from_int ( INTVAL ( const_int ) ) ; return ! ( is_mm_relaxed ( model ) || is_mm_consume ( model ) || is_mm_acquire ( model ) ) ;


<s> rtx left_sub_rtx , right_sub_rtx ; bool is_rev = false ; if ( GET_CODE ( x ) != IOR ) return false ; left_sub_rtx = XEXP ( x , <NUM_LIT> ) ; right_sub_rtx = XEXP ( x , <NUM_LIT> ) ; is_rev = aarch_rev16_p_1 ( left_sub_rtx , right_sub_rtx , GET_MODE ( x ) ) ; if ( ! is_rev ) is_rev = aarch_rev16_p_1 ( right_sub_rtx , left_sub_rtx , GET_MODE ( x ) ) ; return is_rev ;


<s> is_rev = aarch_rev16_p_1 ( left_sub_rtx , right_sub_rtx , GET_MODE ( x ) ) ; if ( ! is_rev ) is_rev = aarch_rev16_p_1 ( right_sub_rtx , left_sub_rtx , GET_MODE ( x ) ) ; return is_rev ;


<s> static bool aarch_rev16_p_1 ( rtx lhs , rtx rhs , machine_mode mode ) { if ( GET_CODE ( lhs ) == AND && GET_CODE ( XEXP ( lhs , <NUM_LIT> ) ) == ASHIFT && CONST_INT_P ( XEXP ( XEXP ( lhs , <NUM_LIT> ) , <NUM_LIT> ) ) && INTVAL ( XEXP ( XEXP ( lhs , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> && REG_P ( XEXP ( XEXP ( lhs , <NUM_LIT> ) , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( lhs , <NUM_LIT> ) ) && GET_CODE ( rhs ) == AND && GET_CODE ( XEXP ( rhs , <NUM_LIT> ) ) == LSHIFTRT && REG_P ( XEXP ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) ) && CONST_INT_P ( XEXP ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) ) && INTVAL ( XEXP ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) ) == <NUM_LIT> && CONST_INT_P ( XEXP ( rhs , <NUM_LIT> ) ) && REGNO ( XEXP ( XEXP ( rhs , <NUM_LIT> ) , <NUM_LIT> ) ) == REGNO ( XEXP ( XEXP ( lhs , <NUM_LIT> ) , <NUM_LIT> ) ) ) {

rtx lhs_mask = XEXP ( lhs , <NUM_LIT> ) ;


<s> return CONST_INT_P ( val ) && INTVAL ( val ) == trunc_int_for_mode ( HOST_WIDE_INT_C ( <NUM_LIT> ) , mode ) ;


<s> bool aarch_rev16_shright_mask_imm_p ( rtx val , machine_mode mode ) {

return CONST_INT_P ( val ) && INTVAL ( val ) == trunc_int_for_mode ( HOST_WIDE_INT_C ( <NUM_LIT> ) , mode ) ;


<s> if ( ! arm_get_set_operands ( producer , consumer , & value , & addr ) ) return <NUM_LIT> ;

return reg_overlap_mentioned_p ( value , addr ) ;


<s> int arm_early_load_addr_dep_ptr ( rtx producer , rtx consumer ) { rtx value = arm_find_sub_rtx_with_code ( PATTERN ( producer ) , SET , false ) ; rtx addr = arm_find_sub_rtx_with_code ( PATTERN ( consumer ) , SET , false ) ;

if ( ! value || ! addr || ! MEM_P ( SET_SRC ( value ) ) ) return <NUM_LIT> ;


<s> return ! arm_no_early_store_addr_dep ( producer , consumer ) ;


<s> value = SET_DEST ( value ) ; addr = SET_DEST ( addr ) ; return GET_MODE ( value ) == Pmode && reg_overlap_mentioned_p ( value , addr ) ;


<s> rtx value = arm_find_sub_rtx_with_code ( PATTERN ( producer ) , SET , false ) ; rtx addr = arm_find_sub_rtx_with_code ( PATTERN ( consumer ) , SET , false ) ; if ( ! value || ! addr || ! MEM_P ( SET_SRC ( value ) ) ) return <NUM_LIT> ; value = SET_DEST ( value ) ;


<s> static rtx arm_find_shift_sub_rtx ( rtx pattern ) {

return arm_find_sub_rtx_with_code ( pattern , ASHIFT , true ) ;


<s> if ( arm_rtx_shift_left_p ( x ) ) return x ; else for ( unsigned int i = <NUM_LIT> ; i < ARRAY_SIZE ( shift_rtx_codes ) ; i ++ ) if ( GET_CODE ( x ) == shift_rtx_codes [ i ] ) return x ; }

if ( GET_CODE ( x ) == code ) return x ;


<s> if ( set_producer && set_consumer ) { * set_source = SET_DEST ( set_producer ) ; * set_destination = SET_SRC ( set_consumer ) ;


<s> mac_op0 = XEXP ( XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; mac_op1 = XEXP ( XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; mac_acc = XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> if ( GET_CODE ( mac ) == COND_EXEC ) mac = COND_EXEC_CODE ( mac ) ; if ( ( GET_CODE ( mul ) != SET || GET_CODE ( XEXP ( mul , <NUM_LIT> ) ) != MULT ) || ( GET_CODE ( mac ) != SET || GET_CODE ( XEXP ( mac , <NUM_LIT> ) ) != PLUS || GET_CODE ( XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) ) != MULT ) ) return <NUM_LIT> ; mul_result = XEXP ( mul , <NUM_LIT> ) ; mac_op0 = XEXP ( XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; mac_op1 = XEXP ( XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; mac_acc = XEXP ( XEXP ( mac , <NUM_LIT> ) , <NUM_LIT> ) ; return ( reg_overlap_mentioned_p ( mul_result , mac_acc ) && ! reg_overlap_mentioned_p ( mul_result , mac_op0 ) && ! reg_overlap_mentioned_p ( mul_result , mac_op1 ) ) ;


<s> rtx result ; rtx op0 , op1 , acc ; producer = PATTERN ( producer ) ; consumer = PATTERN ( consumer ) ; if ( GET_CODE ( producer ) == COND_EXEC ) producer = COND_EXEC_CODE ( producer ) ; if ( GET_CODE ( consumer ) == COND_EXEC ) consumer = COND_EXEC_CODE ( consumer ) ; if ( GET_CODE ( producer ) != SET ) return <NUM_LIT> ; result = XEXP ( producer , <NUM_LIT> ) ; if ( GET_CODE ( consumer ) != SET ) return <NUM_LIT> ; if ( GET_CODE ( XEXP ( consumer , <NUM_LIT> ) ) == PLUS ) { if ( GET_CODE ( XEXP ( XEXP ( consumer , <NUM_LIT> ) , <NUM_LIT> ) ) != MULT ) return <NUM_LIT> ; op0 = XEXP ( XEXP ( XEXP ( consumer , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; op1 = XEXP ( XEXP ( XEXP ( consumer , <NUM_LIT> ) , <NUM_LIT> ) , <NUM_LIT> ) ; acc = XEXP ( XEXP ( consumer , <NUM_LIT> ) , <NUM_LIT> ) ; } else if ( GET_CODE ( XEXP ( consumer , <NUM_LIT> ) ) == MINUS ) {


<s> mode = CCmode , code = GTU ; break ; case C ( 'l' , 'e' ) : mode = CCmode , code = LE ; break ; case C ( 'l' , 's' ) : mode = CCmode , code = LEU ; break ; case C ( 'l' , 't' ) : mode = CCmode , code = LT ; break ; case C ( 'm' , 'i' ) : mode = CC_NZmode , code = LT ; break ; case C ( 'n' , 'e' ) : mode = CC_NZmode , code = NE ; break ; case C ( 'p' , 'l' ) : mode = CC_NZmode , code = GE ; break ; case C ( 'v' , 'c' ) : mode = CC_Vmode , code = EQ ; break ; case C ( 'v' , 's' ) : mode = CC_Vmode , code = NE ; break ; default : error_at ( loc , <STR_LIT> , constraints [ i ] ) ; continue ; } rtx dest = outputs [ i ] ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! SCALAR_INT_MODE_P ( dest_mode ) ) { error_at ( loc , <STR_LIT> ) ; continue ; } if ( ! saw_asm_flag ) { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_REG ( CCmode , CC_REGNUM ) ; saw_asm_flag = true ; } else { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_SCRATCH ( word_mode ) ; } rtx x = gen_rtx_REG ( mode , CC_REGNUM ) ;

x = gen_rtx_fmt_ee ( code , word_mode , x , const0_rtx ) ;


<s> break ; case C ( 'l' , 't' ) : mode = CCmode , code = LT ; break ; case C ( 'm' , 'i' ) : mode = CC_NZmode , code = LT ; break ; case C ( 'n' , 'e' ) : mode = CC_NZmode , code = NE ; break ; case C ( 'p' , 'l' ) : mode = CC_NZmode , code = GE ; break ; case C ( 'v' , 'c' ) : mode = CC_Vmode , code = EQ ; break ; case C ( 'v' , 's' ) : mode = CC_Vmode , code = NE ; break ; default : error_at ( loc , <STR_LIT> , constraints [ i ] ) ; continue ; } rtx dest = outputs [ i ] ; machine_mode dest_mode = GET_MODE ( dest ) ; if ( ! SCALAR_INT_MODE_P ( dest_mode ) ) { error_at ( loc , <STR_LIT> ) ; continue ; } if ( ! saw_asm_flag ) { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_REG ( CCmode , CC_REGNUM ) ; saw_asm_flag = true ; } else { constraints [ i ] = <STR_LIT> ; outputs [ i ] = gen_rtx_SCRATCH ( word_mode ) ; } rtx x = gen_rtx_REG ( mode , CC_REGNUM ) ; x = gen_rtx_fmt_ee ( code , word_mode , x , const0_rtx ) ; if ( dest_mode == word_mode && REG_P ( dest ) ) emit_insn ( gen_rtx_SET ( dest , x ) ) ;


<s> if ( ( early_op = arm_find_shift_sub_rtx ( op ) ) ) return ! reg_overlap_mentioned_p ( value , early_op ) ;


if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return <NUM_LIT> ;


<s> rtx value , op ; rtx early_op ; if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return <NUM_LIT> ; if ( ( early_op = arm_find_shift_sub_rtx ( op ) ) ) if ( ! reg_overlap_mentioned_p ( value , XEXP ( early_op , <NUM_LIT> ) ) ) return <NUM_LIT> ;


<s> rtx value , op ; if ( ! arm_get_set_operands ( producer , consumer , & value , & op ) ) return <NUM_LIT> ; if ( GET_CODE ( op ) == PLUS || GET_CODE ( op ) == MINUS ) { if ( GET_CODE ( XEXP ( op , <NUM_LIT> ) ) == MULT ) return ! reg_overlap_mentioned_p ( value , XEXP ( op , <NUM_LIT> ) ) ; else return ! reg_overlap_mentioned_p ( value , XEXP ( op , <NUM_LIT> ) ) ;


<s> int arm_no_early_store_addr_dep ( rtx producer , rtx consumer ) { rtx value = arm_find_sub_rtx_with_code ( PATTERN ( producer ) , SET , false ) ;

rtx addr = arm_find_sub_rtx_with_code ( PATTERN ( consumer ) , SET , false ) ;


<s> enum rtx_code code = GET_CODE ( x ) ; if ( code == MULT && CONST_INT_P ( XEXP ( x , <NUM_LIT> ) ) && exact_log2 ( INTVAL ( XEXP ( x , <NUM_LIT> ) ) ) > <NUM_LIT> ) return true ;


<s> else for ( unsigned int i = <NUM_LIT> ; i < ARRAY_SIZE ( shift_rtx_codes ) ; i ++ ) if ( GET_CODE ( x ) == shift_rtx_codes [ i ] ) return x ;


<s> else type_signature [ arg_num ] = 's' ; if ( qualifiers & qualifier_internal ) continue ; if ( qualifiers & qualifier_map_mode ) op_mode = d -> mode ; if ( qualifiers & qualifier_predicate ) op_mode = HImode ; if ( qualifiers & qualifier_pointer && VECTOR_MODE_P ( op_mode ) ) op_mode = GET_MODE_INNER ( op_mode ) ; if ( qualifiers & qualifier_void_pointer ) eltype = qualifiers & qualifier_const ? const_ptr_type_node : ptr_type_node ; else { eltype = arm_simd_builtin_type ( op_mode , qualifiers ) ; gcc_assert ( eltype != NULL ) ; if ( qualifiers & qualifier_const ) eltype = build_qualified_type ( eltype , TYPE_QUAL_CONST ) ; if ( qualifiers & qualifier_pointer ) eltype = build_pointer_type ( eltype ) ; } if ( arg_num == <NUM_LIT> ) return_type = eltype ;

else args = tree_cons ( NULL_TREE , eltype , args ) ;


ARM_BUILTIN_CRYPTO_ ## U <STR_LIT> # L R ## _ftype_ ## A R ## _ftype_ ## A1 ## _ ## A2 R ## _ftype_ ## A1 ## _ ## A2 ## _ ## A3 arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT1 ( R , A ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> ARM_BUILTIN_CRYPTO_ ## U <STR_LIT> # L R ## _ftype_ ## A R ## _ftype_ ## A1 ## _ ## A2 R ## _ftype_ ## A1 ## _ ## A2 ## _ ## A3 arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT1 ( R , A ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ; arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT2 ( R , A1 , A2 ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ;

arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT3 ( R , A1 , A2 , A3 ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> else type = build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ; type = build_distinct_type_copy ( type ) ; SET_TYPE_STRUCTURAL_EQUALITY ( type ) ; tree mangled_name = get_identifier ( arm_simd_types [ i ] . mangle ) ; tree value = tree_cons ( NULL_TREE , mangled_name , NULL_TREE ) ; TYPE_ATTRIBUTES ( type ) = tree_cons ( get_identifier ( <STR_LIT> ) , value , TYPE_ATTRIBUTES ( type ) ) ; arm_simd_types [ i ] . itype = type ; } tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ; SET_TYPE_STRUCTURAL_EQUALITY ( arm_simd_types [ i ] . itype ) ; } make_signed_type ( GET_MODE_PRECISION ( mode ) ) ; arm_simd_intOI_type_node = AARCH_BUILD_SIGNED_TYPE ( OImode ) ; arm_simd_intEI_type_node = AARCH_BUILD_SIGNED_TYPE ( EImode ) ; arm_simd_intCI_type_node = AARCH_BUILD_SIGNED_TYPE ( CImode ) ; arm_simd_intXI_type_node = AARCH_BUILD_SIGNED_TYPE ( XImode ) ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intEI_type_node ) ; TYPE_NAME ( arm_simd_intEI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intOI_type_node ) ; TYPE_NAME ( arm_simd_intOI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intCI_type_node ) ;

TYPE_NAME ( arm_simd_intCI_type_node ) = tdecl ;


<s> static tree arm_lookup_simd_builtin_type ( machine_mode mode , enum arm_type_qualifiers q ) { int i ; int nelts = ARRAY_SIZE ( arm_simd_types ) ;

if ( q != qualifier_poly && ! VECTOR_MODE_P ( mode ) ) return arm_simd_builtin_std_type ( mode , q ) ;


<s> if ( ( qualifiers & qualifier_poly ) != <NUM_LIT> ) return arm_lookup_simd_builtin_type ( mode , qualifier_poly ) ; else if ( ( qualifiers & qualifier_unsigned ) != <NUM_LIT> ) return arm_lookup_simd_builtin_type ( mode , qualifier_unsigned ) ;

else if ( ( qualifiers & qualifier_predicate ) != <NUM_LIT> ) return unsigned_intHI_type_node ;


<s> if ( ( qualifiers & qualifier_poly ) != <NUM_LIT> ) return arm_lookup_simd_builtin_type ( mode , qualifier_poly ) ; else if ( ( qualifiers & qualifier_unsigned ) != <NUM_LIT> ) return arm_lookup_simd_builtin_type ( mode , qualifier_unsigned ) ; else if ( ( qualifiers & qualifier_predicate ) != <NUM_LIT> ) return unsigned_intHI_type_node ;

else return arm_lookup_simd_builtin_type ( mode , qualifier_none ) ;


<s> return ARM_FIND_VRINT_VARIANT ( vrintp ) ; case BUILT_IN_TRUNCF : return ARM_FIND_VRINT_VARIANT ( vrintz ) ; case BUILT_IN_ROUNDF : return ARM_FIND_VRINT_VARIANT ( vrinta ) ; ( out_mode == SImode && out_n == C \ && in_mode == SFmode && in_n == C ) ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v2sfv2si , false ) \ : ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v4sfv4si , false ) \ : NULL_TREE ) ) ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## uv2sfv2si , false ) \ : ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## uv4sfv4si , false ) \ : NULL_TREE ) ) case BUILT_IN_LROUNDF : return out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvta ) : ARM_FIND_VCVT_VARIANT ( vcvta ) ; case BUILT_IN_LCEILF : return out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvtp ) : ARM_FIND_VCVT_VARIANT ( vcvtp ) ; case BUILT_IN_LFLOORF : return out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvtm ) : ARM_FIND_VCVT_VARIANT ( vcvtm ) ; ( out_mode == N ## mode && out_n == C \ && in_mode == N ## mode && in_n == C ) case BUILT_IN_BSWAP16 : if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , HI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv4hi , false ) ; else if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , HI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv8hi , false ) ; else return NULL_TREE ; case BUILT_IN_BSWAP32 : if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , SI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv2si , false ) ; else if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , SI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv4si , false ) ;


<s> if ( ! ( * insn_data [ icode ] . operand [ opno ] . predicate ) ( op [ argc ] , mode [ argc ] ) ) error_at ( EXPR_LOCATION ( exp ) , <STR_LIT> <STR_LIT> , argc + <NUM_LIT> ) ; break ; case NEON_ARG_MEMORY : if ( op [ argc ] == const0_rtx ) { va_end ( ap ) ; return <NUM_LIT> ; } gcc_assert ( MEM_P ( op [ argc ] ) ) ; PUT_MODE ( op [ argc ] , mode [ argc ] ) ; set_mem_alias_set ( op [ argc ] , <NUM_LIT> ) ; if ( ! ( * insn_data [ icode ] . operand [ opno ] . predicate ) ( op [ argc ] , mode [ argc ] ) ) op [ argc ] = ( replace_equiv_address ( op [ argc ] , force_reg ( Pmode , XEXP ( op [ argc ] , <NUM_LIT> ) ) ) ) ; break ; case NEON_ARG_STOP : gcc_unreachable ( ) ; } argc ++ ; } } va_end ( ap ) ; if ( have_retval ) switch ( argc ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; } else switch ( argc ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ;


<s> builtin_arg args [ SIMD_MAX_BUILTIN_ARGS ] ; int num_args = insn_data [ d -> code ] . n_operands ; int is_void = <NUM_LIT> ; int k ; is_void = ! ! ( d -> qualifiers [ <NUM_LIT> ] & qualifier_void ) ; num_args += is_void ; for ( k = <NUM_LIT> ; k < num_args ; k ++ ) { int qualifiers_k = k ; int operands_k = k - is_void ; int expr_args_k = k - <NUM_LIT> ; if ( d -> qualifiers [ qualifiers_k ] & qualifier_immediate ) args [ k ] = NEON_ARG_CONSTANT ; else if ( d -> qualifiers [ qualifiers_k ] & qualifier_maybe_immediate ) { rtx arg = expand_normal ( CALL_EXPR_ARG ( exp , ( expr_args_k ) ) ) ; bool op_const_int_p = ( CONST_INT_P ( arg ) && ( * insn_data [ icode ] . operand [ operands_k ] . predicate ) ( arg , insn_data [ icode ] . operand [ operands_k ] . mode ) ) ; args [ k ] = op_const_int_p ? NEON_ARG_CONSTANT : NEON_ARG_COPY_TO_REG ; } else if ( d -> qualifiers [ qualifiers_k ] & qualifier_pointer ) args [ k ] = NEON_ARG_MEMORY ; else args [ k ] = NEON_ARG_COPY_TO_REG ; }


<s> if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; gcc_assert ( ( GET_MODE ( op0 ) == mode0 || GET_MODE ( op0 ) == VOIDmode ) && ( GET_MODE ( op1 ) == mode1 || GET_MODE ( op1 ) == VOIDmode ) && ( GET_MODE ( op2 ) == mode2 || GET_MODE ( op2 ) == VOIDmode ) ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op2 , mode2 ) ) op2 = copy_to_mode_reg ( mode2 , op2 ) ; if ( builtin_sha1cpm_p ) op3 = GEN_INT ( TARGET_BIG_END ? <NUM_LIT> : <NUM_LIT> ) ; if ( builtin_sha1cpm_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 , op3 ) ; else pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return <NUM_LIT> ;


<s> machine_mode mode2 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( VECTOR_MODE_P ( mode2 ) ) op2 = safe_vector_operand ( op2 , mode2 ) ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; gcc_assert ( ( GET_MODE ( op0 ) == mode0 || GET_MODE ( op0 ) == VOIDmode ) && ( GET_MODE ( op1 ) == mode1 || GET_MODE ( op1 ) == VOIDmode ) && ( GET_MODE ( op2 ) == mode2 || GET_MODE ( op2 ) == VOIDmode ) ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op2 , mode2 ) ) op2 = copy_to_mode_reg ( mode2 , op2 ) ;


<s> if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; } if ( builtin_sha1h_p ) op1 = GEN_INT ( TARGET_BIG_END ? <NUM_LIT> : <NUM_LIT> ) ; if ( builtin_sha1h_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ; else pat = GEN_FCN ( icode ) ( target , op0 ) ;


<s> else { if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; } if ( builtin_sha1h_p ) op1 = GEN_INT ( TARGET_BIG_END ? <NUM_LIT> : <NUM_LIT> ) ; if ( builtin_sha1h_p ) pat = GEN_FCN ( icode ) ( target , op0 , op1 ) ;

else pat = GEN_FCN ( icode ) ( target , op0 ) ;


<s> static void arm_init_fp16_builtins ( void ) { tree fp16_type = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( fp16_type ) = <NUM_LIT> ;


<s> type_signature [ arg_num ] = 'p' ; print_type_signature_p = true ; } else type_signature [ arg_num ] = 's' ; if ( qualifiers & qualifier_internal ) continue ; if ( qualifiers & qualifier_map_mode ) op_mode = d -> mode ; if ( qualifiers & qualifier_pointer && VECTOR_MODE_P ( op_mode ) ) op_mode = GET_MODE_INNER ( op_mode ) ; eltype = arm_simd_builtin_type ( op_mode , ( qualifiers & qualifier_unsigned ) != <NUM_LIT> , ( qualifiers & qualifier_poly ) != <NUM_LIT> ) ; gcc_assert ( eltype != NULL ) ; if ( qualifiers & qualifier_const ) eltype = build_qualified_type ( eltype , TYPE_QUAL_CONST ) ; if ( qualifiers & qualifier_pointer ) eltype = build_pointer_type ( eltype ) ; if ( arg_num == <NUM_LIT> ) return_type = eltype ; else args = tree_cons ( NULL_TREE , eltype , args ) ; } ftype = build_function_type ( return_type , args ) ; gcc_assert ( ftype != NULL ) ; if ( print_type_signature_p ) snprintf ( namebuf , sizeof ( namebuf ) , <STR_LIT> , d -> name , type_signature ) ; else snprintf ( namebuf , sizeof ( namebuf ) , <STR_LIT> , d -> name ) ; fndecl = add_builtin_function ( namebuf , ftype , fcode , BUILT_IN_MD , NULL , NULL_TREE ) ; arm_builtin_decls [ fcode ] = fndecl ; } if ( TARGET_CRYPTO && TARGET_HARD_FLOAT ) { tree V16UQI_type_node = arm_simd_builtin_type ( V16QImode , true , false ) ; tree V4USI_type_node = arm_simd_builtin_type ( V4SImode , true , false ) ; tree v16uqi_ftype_v16uqi = build_function_type_list ( V16UQI_type_node , V16UQI_type_node , NULL_TREE ) ; tree v16uqi_ftype_v16uqi_v16uqi = build_function_type_list ( V16UQI_type_node , V16UQI_type_node , V16UQI_type_node , NULL_TREE ) ; tree v4usi_ftype_v4usi = build_function_type_list ( V4USI_type_node , V4USI_type_node , NULL_TREE ) ; tree v4usi_ftype_v4usi_v4usi = build_function_type_list ( V4USI_type_node , V4USI_type_node , V4USI_type_node , NULL_TREE ) ;


<s> ( * lang_hooks . types . register_builtin_type ) ( intQI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( intHI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( intSI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( float_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( intDI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( double_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( intTI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intQI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intHI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intSI_type_node , <STR_LIT> ) ;

( * lang_hooks . types . register_builtin_type ) ( unsigned_intDI_type_node , <STR_LIT> ) ;


<s> int i ; int nelts = sizeof ( arm_simd_types ) / sizeof ( arm_simd_types [ <NUM_LIT> ] ) ; tree tdecl ; arm_simd_floatHF_type_node = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( arm_simd_floatHF_type_node ) = GET_MODE_PRECISION ( HFmode ) ; layout_type ( arm_simd_floatHF_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_floatHF_type_node , <STR_LIT> ) ; arm_simd_polyQI_type_node = build_distinct_type_copy ( intQI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyQI_type_node , <STR_LIT> ) ; arm_simd_polyHI_type_node = build_distinct_type_copy ( intHI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyHI_type_node , <STR_LIT> ) ; arm_simd_polyDI_type_node = build_distinct_type_copy ( unsigned_intDI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyDI_type_node , <STR_LIT> ) ; arm_simd_polyTI_type_node = build_distinct_type_copy ( unsigned_intTI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyTI_type_node , <STR_LIT> ) ; arm_simd_types [ Int8x8_t ] . eltype = intQI_type_node ; arm_simd_types [ Int8x16_t ] . eltype = intQI_type_node ; arm_simd_types [ Int16x4_t ] . eltype = intHI_type_node ; arm_simd_types [ Int16x8_t ] . eltype = intHI_type_node ; arm_simd_types [ Int32x2_t ] . eltype = intSI_type_node ; arm_simd_types [ Int32x4_t ] . eltype = intSI_type_node ;

arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ;


<s> arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ; arm_simd_types [ Uint8x8_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Poly16x8_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Float16x4_t ] . eltype = arm_simd_floatHF_type_node ; arm_simd_types [ Float32x2_t ] . eltype = float_type_node ; arm_simd_types [ Float32x4_t ] . eltype = float_type_node ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) { tree eltype = arm_simd_types [ i ] . eltype ; enum machine_mode mode = arm_simd_types [ i ] . mode ; if ( arm_simd_types [ i ] . itype == NULL ) arm_simd_types [ i ] . itype = build_distinct_type_copy ( build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ) ; tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ; SET_TYPE_STRUCTURAL_EQUALITY ( arm_simd_types [ i ] . itype ) ; } make_signed_type ( GET_MODE_PRECISION ( mode ) ) ; arm_simd_intOI_type_node = AARCH_BUILD_SIGNED_TYPE ( OImode ) ; arm_simd_intEI_type_node = AARCH_BUILD_SIGNED_TYPE ( EImode ) ; arm_simd_intCI_type_node = AARCH_BUILD_SIGNED_TYPE ( CImode ) ; arm_simd_intXI_type_node = AARCH_BUILD_SIGNED_TYPE ( XImode ) ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intEI_type_node ) ; TYPE_NAME ( arm_simd_intEI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intOI_type_node ) ; TYPE_NAME ( arm_simd_intOI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intCI_type_node ) ; TYPE_NAME ( arm_simd_intCI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intXI_type_node ) ;

TYPE_NAME ( arm_simd_intXI_type_node ) = tdecl ;


<s> int nelts = sizeof ( arm_simd_types ) / sizeof ( arm_simd_types [ <NUM_LIT> ] ) ; if ( q != qualifier_poly && ! VECTOR_MODE_P ( mode ) ) return arm_simd_builtin_std_type ( mode , q ) ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) if ( arm_simd_types [ i ] . mode == mode && arm_simd_types [ i ] . q == q ) return arm_simd_types [ i ] . itype ;


<s> return QUAL_TYPE ( HI ) ; case SImode : return QUAL_TYPE ( SI ) ; case DImode : return QUAL_TYPE ( DI ) ; case TImode : return QUAL_TYPE ( TI ) ; case OImode : return arm_simd_intOI_type_node ; case EImode : return arm_simd_intEI_type_node ; case CImode : return arm_simd_intCI_type_node ; case XImode : return arm_simd_intXI_type_node ; case HFmode : return arm_simd_floatHF_type_node ; case SFmode : return float_type_node ; case DFmode : return double_type_node ; default : gcc_unreachable ( ) ; }


<s> return QUAL_TYPE ( TI ) ; case OImode : return arm_simd_intOI_type_node ; case EImode : return arm_simd_intEI_type_node ; case CImode : return arm_simd_intCI_type_node ; case XImode : return arm_simd_intXI_type_node ; case HFmode : return arm_simd_floatHF_type_node ; case SFmode : return float_type_node ; case DFmode : return double_type_node ; default : gcc_unreachable ( ) ; }


<s> else if ( unsigned_p ) return arm_lookup_simd_builtin_type ( mode , qualifier_unsigned ) ;


<s> else if ( d -> qualifiers [ qualifiers_k ] & qualifier_struct_load_store_lane_index ) args [ k ] = NEON_ARG_STRUCT_LOAD_STORE_LANE_INDEX ; else if ( d -> qualifiers [ qualifiers_k ] & qualifier_immediate ) args [ k ] = NEON_ARG_CONSTANT ; else if ( d -> qualifiers [ qualifiers_k ] & qualifier_maybe_immediate ) { rtx arg = expand_normal ( CALL_EXPR_ARG ( exp , ( expr_args_k ) ) ) ; bool op_const_int_p = ( CONST_INT_P ( arg ) && ( * insn_data [ icode ] . operand [ operands_k ] . predicate ) ( arg , insn_data [ icode ] . operand [ operands_k ] . mode ) ) ; args [ k ] = op_const_int_p ? NEON_ARG_CONSTANT : NEON_ARG_COPY_TO_REG ; } else if ( d -> qualifiers [ qualifiers_k ] & qualifier_pointer ) args [ k ] = NEON_ARG_MEMORY ; else args [ k ] = NEON_ARG_COPY_TO_REG ; } args [ k ] = NEON_ARG_STOP ; return arm_expand_neon_args ( target , d -> mode , fcode , icode , ! is_void , exp , & args [ <NUM_LIT> ] ) ;


<s> if ( arm_fp16_format ) ( * lang_hooks . types . register_builtin_type ) ( arm_simd_floatHF_type_node , <STR_LIT> ) ;


<s> static void arm_init_fp16_builtins ( void ) { arm_simd_floatHF_type_node = make_node ( REAL_TYPE ) ; TYPE_PRECISION ( arm_simd_floatHF_type_node ) = GET_MODE_PRECISION ( HFmode ) ;


<s> bool print_type_signature_p = false ; char type_signature [ SIMD_MAX_BUILTIN_ARGS ] = { <NUM_LIT> } ; neon_builtin_datum * d = & neon_builtin_data [ i ] ; char namebuf [ <NUM_LIT> ] ; tree ftype = NULL ; tree fndecl = NULL ; d -> fcode = fcode ; int op_num = insn_data [ d -> code ] . n_operands - <NUM_LIT> ; int arg_num = d -> qualifiers [ <NUM_LIT> ] & qualifier_void ? op_num + <NUM_LIT> : op_num ; tree return_type = void_type_node , args = void_list_node ; tree eltype ; for ( ; op_num >= <NUM_LIT> ; arg_num -- , op_num -- ) { machine_mode op_mode = insn_data [ d -> code ] . operand [ op_num ] . mode ; enum arm_type_qualifiers qualifiers = d -> qualifiers [ arg_num ] ; if ( qualifiers & qualifier_unsigned ) { type_signature [ arg_num ] = 'u' ; print_type_signature_p = true ; } else if ( qualifiers & qualifier_poly ) { type_signature [ arg_num ] = 'p' ; print_type_signature_p = true ; } else type_signature [ arg_num ] = 's' ; if ( qualifiers & qualifier_internal ) continue ;

if ( qualifiers & qualifier_map_mode ) op_mode = d -> mode ;


<s> arm_simd_polyTI_type_node = build_distinct_type_copy ( unsigned_intTI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyTI_type_node , <STR_LIT> ) ; arm_simd_types [ Int8x8_t ] . eltype = intQI_type_node ; arm_simd_types [ Int8x16_t ] . eltype = intQI_type_node ; arm_simd_types [ Int16x4_t ] . eltype = intHI_type_node ; arm_simd_types [ Int16x8_t ] . eltype = intHI_type_node ; arm_simd_types [ Int32x2_t ] . eltype = intSI_type_node ; arm_simd_types [ Int32x4_t ] . eltype = intSI_type_node ; arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ; arm_simd_types [ Uint8x8_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ;

arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ;


<s> tree arm_builtin_vectorized_function ( unsigned int fn , tree type_out , tree type_in ) { machine_mode in_mode , out_mode ; int in_n , out_n ; bool out_unsigned_p = TYPE_UNSIGNED ( type_out ) ; if ( ! TARGET_NEON ) return NULL_TREE ; if ( TREE_CODE ( type_out ) != VECTOR_TYPE || TREE_CODE ( type_in ) != VECTOR_TYPE ) return NULL_TREE ; out_mode = TYPE_MODE ( TREE_TYPE ( type_out ) ) ; out_n = TYPE_VECTOR_SUBPARTS ( type_out ) ; in_mode = TYPE_MODE ( TREE_TYPE ( type_in ) ) ; in_n = TYPE_VECTOR_SUBPARTS ( type_in ) ; ( TARGET_FPU_ARMV8 \ && flag_unsafe_math_optimizations \ && ARM_CHECK_BUILTIN_MODE_1 ( C ) ) ( out_mode == SFmode && out_n == C \ && in_mode == SFmode && in_n == C ) ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v2sf , false ) \ : ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v4sf , false ) \ : NULL_TREE ) ) switch ( fn ) { CASE_CFN_FLOOR : return ARM_FIND_VRINT_VARIANT ( vrintm ) ;


<s> return arm_expand_builtin_1 ( fcode , exp , target , d ) ;


<s> arm_builtin_datum * d = & acle_builtin_data [ fcode - ARM_BUILTIN_ACLE_PATTERN_START ] ;

return arm_expand_builtin_1 ( fcode , exp , target , d ) ;


else if ( d -> qualifiers [ qualifiers_k ] & qualifier_pointer ) {


<s> gcc_assert ( TREE_CODE ( nlanes ) == INTEGER_CST ) ; rtx lane_idx = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; if ( CONST_INT_P ( lane_idx ) ) neon_lane_bounds ( lane_idx , <NUM_LIT> , TREE_INT_CST_LOW ( nlanes ) , exp ) ; else error ( <STR_LIT> , exp ) ; return const0_rtx ;


<s> static void arm_init_acle_builtins ( void ) { unsigned int i , fcode = ARM_BUILTIN_ACLE_PATTERN_START ;

for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( acle_builtin_data ) ; i ++ , fcode ++ ) {


<s> arm_builtin_datum * d = & acle_builtin_data [ i ] ;

arm_init_builtin ( fcode , d , <STR_LIT> ) ;


<s> if ( qualifiers & qualifier_pointer ) eltype = build_pointer_type ( eltype ) ; if ( arg_num == <NUM_LIT> ) return_type = eltype ; else args = tree_cons ( NULL_TREE , eltype , args ) ; } ftype = build_function_type ( return_type , args ) ; gcc_assert ( ftype != NULL ) ; if ( print_type_signature_p && IN_RANGE ( fcode , ARM_BUILTIN_VFP_BASE , ARM_BUILTIN_ACLE_BASE - <NUM_LIT> ) ) snprintf ( namebuf , sizeof ( namebuf ) , <STR_LIT> , prefix , d -> name , type_signature ) ; else snprintf ( namebuf , sizeof ( namebuf ) , <STR_LIT> , prefix , d -> name ) ;

fndecl = add_builtin_function ( namebuf , ftype , fcode , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> else if ( qualifiers & qualifier_poly ) { type_signature [ arg_num ] = 'p' ; print_type_signature_p = true ; } else type_signature [ arg_num ] = 's' ; if ( qualifiers & qualifier_internal ) continue ; if ( qualifiers & qualifier_map_mode ) op_mode = d -> mode ; if ( qualifiers & qualifier_pointer && VECTOR_MODE_P ( op_mode ) ) op_mode = GET_MODE_INNER ( op_mode ) ; eltype = arm_simd_builtin_type ( op_mode , ( qualifiers & qualifier_unsigned ) != <NUM_LIT> , ( qualifiers & qualifier_poly ) != <NUM_LIT> ) ; gcc_assert ( eltype != NULL ) ; if ( qualifiers & qualifier_const ) eltype = build_qualified_type ( eltype , TYPE_QUAL_CONST ) ; if ( qualifiers & qualifier_pointer ) eltype = build_pointer_type ( eltype ) ; if ( arg_num == <NUM_LIT> ) return_type = eltype ;

else args = tree_cons ( NULL_TREE , eltype , args ) ;


tree ftype_cmse_nonsecure_caller = build_function_type_list ( unsigned_type_node , NULL ) ;


<s> arm_init_simd_builtin_scalar_types ( ) ; tree lane_check_fpr = build_function_type_list ( void_type_node , intSI_type_node , intSI_type_node , NULL ) ; arm_builtin_decls [ ARM_BUILTIN_NEON_LANE_CHECK ] = add_builtin_function ( <STR_LIT> , lane_check_fpr , ARM_BUILTIN_NEON_LANE_CHECK , BUILT_IN_MD , NULL , NULL_TREE ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( neon_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & neon_builtin_data [ i ] ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( neon_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & neon_builtin_data [ i ] ; arm_init_builtin ( fcode , d , <STR_LIT> ) ; }


<s> enum machine_mode mode = arm_simd_types [ i ] . mode ; if ( arm_simd_types [ i ] . itype == NULL ) arm_simd_types [ i ] . itype = build_distinct_type_copy ( build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ) ; tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ; SET_TYPE_STRUCTURAL_EQUALITY ( arm_simd_types [ i ] . itype ) ; } make_signed_type ( GET_MODE_PRECISION ( mode ) ) ; arm_simd_intOI_type_node = AARCH_BUILD_SIGNED_TYPE ( OImode ) ; arm_simd_intEI_type_node = AARCH_BUILD_SIGNED_TYPE ( EImode ) ; arm_simd_intCI_type_node = AARCH_BUILD_SIGNED_TYPE ( CImode ) ; arm_simd_intXI_type_node = AARCH_BUILD_SIGNED_TYPE ( XImode ) ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intEI_type_node ) ; TYPE_NAME ( arm_simd_intEI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intOI_type_node ) ; TYPE_NAME ( arm_simd_intOI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intCI_type_node ) ;

TYPE_NAME ( arm_simd_intCI_type_node ) = tdecl ;


<s> arm_simd_types [ Int16x8_t ] . eltype = intHI_type_node ; arm_simd_types [ Int32x2_t ] . eltype = intSI_type_node ; arm_simd_types [ Int32x4_t ] . eltype = intSI_type_node ; arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ; arm_simd_types [ Uint8x8_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Poly16x8_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Float16x4_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float16x8_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float32x2_t ] . eltype = float_type_node ; arm_simd_types [ Float32x4_t ] . eltype = float_type_node ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) { tree eltype = arm_simd_types [ i ] . eltype ; enum machine_mode mode = arm_simd_types [ i ] . mode ; if ( arm_simd_types [ i ] . itype == NULL ) arm_simd_types [ i ] . itype = build_distinct_type_copy ( build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ) ; tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ;

SET_TYPE_STRUCTURAL_EQUALITY ( arm_simd_types [ i ] . itype ) ;


<s> case HImode : return QUAL_TYPE ( HI ) ; case SImode : return QUAL_TYPE ( SI ) ; case DImode : return QUAL_TYPE ( DI ) ; case TImode : return QUAL_TYPE ( TI ) ; case OImode : return arm_simd_intOI_type_node ; case EImode : return arm_simd_intEI_type_node ; case CImode : return arm_simd_intCI_type_node ;


<s> argc ++ ; } } if ( have_retval ) switch ( argc ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( target , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; default : gcc_unreachable ( ) ; } else switch ( argc ) { case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> : pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ; break ; case <NUM_LIT> :

pat = GEN_FCN ( icode ) ( op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] , op [ <NUM_LIT> ] ) ;


<s> arm_simd_polyTI_type_node = build_distinct_type_copy ( unsigned_intTI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyTI_type_node , <STR_LIT> ) ; arm_simd_types [ Int8x8_t ] . eltype = intQI_type_node ; arm_simd_types [ Int8x16_t ] . eltype = intQI_type_node ; arm_simd_types [ Int16x4_t ] . eltype = intHI_type_node ; arm_simd_types [ Int16x8_t ] . eltype = intHI_type_node ; arm_simd_types [ Int32x2_t ] . eltype = intSI_type_node ; arm_simd_types [ Int32x4_t ] . eltype = intSI_type_node ; arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ; arm_simd_types [ Uint8x8_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Poly16x8_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Float16x4_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float16x8_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float32x2_t ] . eltype = float_type_node ; arm_simd_types [ Float32x4_t ] . eltype = float_type_node ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) { tree eltype = arm_simd_types [ i ] . eltype ; machine_mode mode = arm_simd_types [ i ] . mode ; if ( arm_simd_types [ i ] . itype == NULL ) arm_simd_types [ i ] . itype = build_distinct_type_copy ( build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ) ; tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ;


<s> switch ( mode ) { case E_QImode : return QUAL_TYPE ( QI ) ; case E_HImode : return QUAL_TYPE ( HI ) ; case E_SImode : return QUAL_TYPE ( SI ) ; case E_DImode : return QUAL_TYPE ( DI ) ; case E_TImode : return QUAL_TYPE ( TI ) ; case E_OImode : return arm_simd_intOI_type_node ; case E_EImode : return arm_simd_intEI_type_node ; case E_CImode : return arm_simd_intCI_type_node ; case E_XImode : return arm_simd_intXI_type_node ; case E_HFmode : return arm_fp16_type_node ; case E_SFmode : return float_type_node ; case E_DFmode :


else if ( d -> qualifiers [ qualifiers_k ] & qualifier_maybe_immediate ) {


<s> fatal_error ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> ) ; return const0_rtx ; } if ( fcode == ARM_BUILTIN_NEON_LANE_CHECK ) { tree nlanes = CALL_EXPR_ARG ( exp , <NUM_LIT> ) ; gcc_assert ( TREE_CODE ( nlanes ) == INTEGER_CST ) ;

rtx lane_idx = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ;


<s> arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Poly16x8_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Float16x4_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float16x8_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float32x2_t ] . eltype = float_type_node ; arm_simd_types [ Float32x4_t ] . eltype = float_type_node ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) { tree eltype = arm_simd_types [ i ] . eltype ; machine_mode mode = arm_simd_types [ i ] . mode ; if ( arm_simd_types [ i ] . itype == NULL ) arm_simd_types [ i ] . itype = build_distinct_type_copy ( build_vector_type ( eltype , GET_MODE_NUNITS ( mode ) ) ) ; tdecl = add_builtin_type ( arm_simd_types [ i ] . name , arm_simd_types [ i ] . itype ) ; TYPE_NAME ( arm_simd_types [ i ] . itype ) = tdecl ; SET_TYPE_STRUCTURAL_EQUALITY ( arm_simd_types [ i ] . itype ) ; } make_signed_type ( GET_MODE_PRECISION ( mode ) ) ; arm_simd_intOI_type_node = AARCH_BUILD_SIGNED_TYPE ( OImode ) ; arm_simd_intEI_type_node = AARCH_BUILD_SIGNED_TYPE ( EImode ) ; arm_simd_intCI_type_node = AARCH_BUILD_SIGNED_TYPE ( CImode ) ; arm_simd_intXI_type_node = AARCH_BUILD_SIGNED_TYPE ( XImode ) ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intEI_type_node ) ; TYPE_NAME ( arm_simd_intEI_type_node ) = tdecl ; tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intOI_type_node ) ; TYPE_NAME ( arm_simd_intOI_type_node ) = tdecl ;

tdecl = add_builtin_type ( <STR_LIT> , arm_simd_intCI_type_node ) ;


<s> if ( code >= ARM_BUILTIN_MAX ) return error_mark_node ;


<s> ( out_mode == SImode && out_n == C \ && in_mode == SFmode && in_n == C ) ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v2sfv2si , false ) \ : ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## v4sfv4si , false ) \ : NULL_TREE ) ) ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## uv2sfv2si , false ) \ : ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> ) \ ? arm_builtin_decl ( ARM_BUILTIN_NEON_ ## N ## uv4sfv4si , false ) \ : NULL_TREE ) ) CASE_CFN_LROUND : return ( out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvta ) : ARM_FIND_VCVT_VARIANT ( vcvta ) ) ; CASE_CFN_LCEIL : return ( out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvtp ) : ARM_FIND_VCVT_VARIANT ( vcvtp ) ) ; CASE_CFN_LFLOOR : return ( out_unsigned_p ? ARM_FIND_VCVTU_VARIANT ( vcvtm ) : ARM_FIND_VCVT_VARIANT ( vcvtm ) ) ; ( out_mode == N ## mode && out_n == C \ && in_mode == N ## mode && in_n == C ) case CFN_BUILT_IN_BSWAP16 : if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , HI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv4hi , false ) ; else if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , HI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv8hi , false ) ; else return NULL_TREE ; case CFN_BUILT_IN_BSWAP32 : if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , SI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv2si , false ) ; else if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , SI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv4si , false ) ; else return NULL_TREE ; case CFN_BUILT_IN_BSWAP64 :

if ( ARM_CHECK_BUILTIN_MODE ( <NUM_LIT> , DI ) ) return arm_builtin_decl ( ARM_BUILTIN_NEON_bswapv2di , false ) ;


<s> unsigned arm_cde_end_args ( tree fndecl ) {


<s> return DECL_MD_FUNCTION_CODE ( fndecl ) >= ARM_BUILTIN_vcx1q_p_v16qi ? <NUM_LIT> : <NUM_LIT> ;


<s> bool arm_check_builtin_call ( location_t , vec < location_t > , tree fndecl , tree , unsigned int , tree * ) { int fcode = DECL_MD_FUNCTION_CODE ( fndecl ) ; if ( fcode == ARM_BUILTIN_saturation_occurred || fcode == ARM_BUILTIN_set_saturation ) { if ( cfun && cfun -> decl ) DECL_ATTRIBUTES ( cfun -> decl ) = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , DECL_ATTRIBUTES ( cfun -> decl ) ) ; } if ( fcode == ARM_BUILTIN_sel ) { if ( cfun && cfun -> decl ) DECL_ATTRIBUTES ( cfun -> decl ) = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , DECL_ATTRIBUTES ( cfun -> decl ) ) ; } return true ;


<s> } if ( fcode == ARM_BUILTIN_sel ) { if ( cfun && cfun -> decl ) DECL_ATTRIBUTES ( cfun -> decl ) = tree_cons ( get_identifier ( <STR_LIT> ) , NULL_TREE , DECL_ATTRIBUTES ( cfun -> decl ) ) ; }


<s> enum resolver_ident arm_describe_resolver ( tree fndecl ) { if ( DECL_MD_FUNCTION_CODE ( fndecl ) >= ARM_BUILTIN_vcx1qv16qi && DECL_MD_FUNCTION_CODE ( fndecl ) < ARM_BUILTIN_MVE_BASE ) return arm_cde_resolver ;


<s> rtx min_sat = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; rtx max_sat = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; gcc_assert ( CONST_INT_P ( min_sat ) ) ; gcc_assert ( CONST_INT_P ( max_sat ) ) ; rtx sat_imm = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; if ( CONST_INT_P ( sat_imm ) ) { if ( ! IN_RANGE ( sat_imm , min_sat , max_sat ) ) error_at ( EXPR_LOCATION ( exp ) , <STR_LIT> , UINTVAL ( min_sat ) , UINTVAL ( max_sat ) ) ; } else error_at ( EXPR_LOCATION ( exp ) , <STR_LIT> ) ; return const0_rtx ; } gcc_assert ( fcode != ARM_BUILTIN_CDE_BASE ) ; arm_builtin_datum * d = ( fcode < ARM_BUILTIN_CDE_BASE ) ? & acle_builtin_data [ fcode - ARM_BUILTIN_ACLE_PATTERN_START ] : & cde_builtin_data [ fcode - ARM_BUILTIN_CDE_PATTERN_START ] . base ; return arm_expand_builtin_1 ( fcode , exp , target , d ) ;


<s> if ( fcode == ARM_BUILTIN_SAT_IMM_CHECK ) { rtx min_sat = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; rtx max_sat = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ; gcc_assert ( CONST_INT_P ( min_sat ) ) ; gcc_assert ( CONST_INT_P ( max_sat ) ) ; rtx sat_imm = expand_normal ( CALL_EXPR_ARG ( exp , <NUM_LIT> ) ) ;


<s> if ( VECTOR_MODE_P ( mode1 ) ) op1 = safe_vector_operand ( op1 , mode1 ) ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; gcc_assert ( ( GET_MODE ( op0 ) == mode0 || GET_MODE ( op0 ) == VOIDmode ) && ( GET_MODE ( op1 ) == mode1 || GET_MODE ( op1 ) == VOIDmode ) ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ;

if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ;


<s> int k ; bool neon = false ; bool mve = false ; if ( IN_RANGE ( fcode , ARM_BUILTIN_VFP_BASE , ARM_BUILTIN_ACLE_BASE - <NUM_LIT> ) ) neon = true ; if ( IN_RANGE ( fcode , ARM_BUILTIN_MVE_BASE , ARM_BUILTIN_MAX - <NUM_LIT> ) ) mve = true ; is_void = ! ! ( d -> qualifiers [ <NUM_LIT> ] & qualifier_void ) ; num_args += is_void ; for ( k = <NUM_LIT> ; k < num_args ; k ++ ) { int qualifiers_k = k ; int operands_k = k - is_void ; int expr_args_k = k - <NUM_LIT> ; if ( d -> qualifiers [ qualifiers_k ] & qualifier_lane_index ) args [ k ] = ARG_BUILTIN_LANE_INDEX ;

else if ( d -> qualifiers [ qualifiers_k ] & qualifier_lane_pair_index ) args [ k ] = ARG_BUILTIN_LANE_PAIR_INDEX ;


<s> static rtx arm_expand_mve_builtin ( int fcode , tree exp , rtx target ) { if ( fcode >= ARM_BUILTIN_MVE_BASE && ! TARGET_HAVE_MVE ) { fatal_error ( input_location , <STR_LIT> <STR_LIT> ) ; return const0_rtx ; }

arm_builtin_datum * d = & mve_builtin_data [ fcode - ARM_BUILTIN_MVE_PATTERN_START ] ;


<s> static rtx arm_expand_neon_builtin ( int fcode , tree exp , rtx target ) { if ( fcode >= ARM_BUILTIN_NEON_BASE && ! TARGET_NEON ) { fatal_error ( input_location , <STR_LIT> <STR_LIT> <STR_LIT> ) ;


<s> if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; gcc_assert ( ( GET_MODE ( op0 ) == mode0 || GET_MODE ( op0 ) == VOIDmode ) && ( GET_MODE ( op1 ) == mode1 || GET_MODE ( op1 ) == VOIDmode ) && ( GET_MODE ( op2 ) == mode2 || GET_MODE ( op2 ) == VOIDmode ) ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op1 , mode1 ) ) op1 = copy_to_mode_reg ( mode1 , op1 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op2 , mode2 ) ) op2 = copy_to_mode_reg ( mode2 , op2 ) ; pat = GEN_FCN ( icode ) ( target , op0 , op1 , op2 ) ; if ( ! pat ) return <NUM_LIT> ; emit_insn ( pat ) ; return target ;


<s> machine_mode tmode = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; machine_mode mode0 = insn_data [ icode ] . operand [ <NUM_LIT> ] . mode ; if ( ! target || GET_MODE ( target ) != tmode || ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( target , tmode ) ) target = gen_reg_rtx ( tmode ) ; if ( do_load ) op0 = gen_rtx_MEM ( mode0 , copy_to_mode_reg ( Pmode , op0 ) ) ; else { if ( VECTOR_MODE_P ( mode0 ) ) op0 = safe_vector_operand ( op0 , mode0 ) ; if ( ! ( * insn_data [ icode ] . operand [ <NUM_LIT> ] . predicate ) ( op0 , mode0 ) ) op0 = copy_to_mode_reg ( mode0 , op0 ) ; } pat = GEN_FCN ( icode ) ( target , op0 ) ; if ( ! pat ) return <NUM_LIT> ;


<s> arm_builtin_datum * d = & vfp_builtin_data [ fcode - ARM_BUILTIN_VFP_PATTERN_START ] ;

return arm_expand_builtin_1 ( fcode , exp , target , d ) ;


<s> static void arm_init_acle_builtins ( void ) { unsigned int i , fcode = ARM_BUILTIN_ACLE_PATTERN_START ; tree sat_check_fpr = build_function_type_list ( void_type_node , intSI_type_node , intSI_type_node , intSI_type_node , NULL ) ; arm_builtin_decls [ ARM_BUILTIN_SAT_IMM_CHECK ] = add_builtin_function ( <STR_LIT> , sat_check_fpr , ARM_BUILTIN_SAT_IMM_CHECK , BUILT_IN_MD , NULL , NULL_TREE ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( acle_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & acle_builtin_data [ i ] ; arm_init_builtin ( fcode , d , <STR_LIT> ) ; }


<s> } else if ( qualifiers & qualifier_poly ) { type_signature [ arg_num ] = 'p' ; print_type_signature_p = true ; } else type_signature [ arg_num ] = 's' ; if ( qualifiers & qualifier_internal ) continue ; if ( qualifiers & qualifier_map_mode ) op_mode = d -> mode ; if ( qualifiers & qualifier_predicate ) op_mode = HImode ; if ( qualifiers & qualifier_pointer && VECTOR_MODE_P ( op_mode ) ) op_mode = GET_MODE_INNER ( op_mode ) ; if ( qualifiers & qualifier_void_pointer ) eltype = qualifiers & qualifier_const ? const_ptr_type_node : ptr_type_node ; else { eltype = arm_simd_builtin_type ( op_mode , ( qualifiers & qualifier_unsigned ) != <NUM_LIT> , ( qualifiers & qualifier_poly ) != <NUM_LIT> ) ; gcc_assert ( eltype != NULL ) ; if ( qualifiers & qualifier_const ) eltype = build_qualified_type ( eltype , TYPE_QUAL_CONST ) ; if ( qualifiers & qualifier_pointer ) eltype = build_pointer_type ( eltype ) ; } if ( arg_num == <NUM_LIT> ) return_type = eltype ; else args = tree_cons ( NULL_TREE , eltype , args ) ;


<s> arm_init_bf16_types ( ) ; if ( TARGET_MAYBE_HARD_FLOAT ) { tree lane_check_fpr = build_function_type_list ( void_type_node , intSI_type_node , intSI_type_node , NULL ) ; arm_builtin_decls [ ARM_BUILTIN_SIMD_LANE_CHECK ] = add_builtin_function ( <STR_LIT> , lane_check_fpr , ARM_BUILTIN_SIMD_LANE_CHECK , BUILT_IN_MD , NULL , NULL_TREE ) ; if ( TARGET_HAVE_MVE ) arm_init_mve_builtins ( ) ; else arm_init_neon_builtins ( ) ; arm_init_vfp_builtins ( ) ; arm_init_crypto_builtins ( ) ; } if ( TARGET_CDE ) arm_init_cde_builtins ( ) ; arm_init_acle_builtins ( ) ; if ( TARGET_MAYBE_HARD_FLOAT ) {


<s> unsigned int i , fcode = ARM_BUILTIN_CDE_PATTERN_START ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( cde_builtin_data ) ; i ++ , fcode ++ ) { if ( ! TARGET_MAYBE_HARD_FLOAT && fcode >= ARM_BUILTIN_vcx1si ) break ; if ( ! TARGET_HAVE_MVE && fcode >= ARM_BUILTIN_vcx1qv16qi ) break ;

arm_builtin_cde_datum * cde = & cde_builtin_data [ i ] ;


<s> tree uti_ftype_udi_udi = build_function_type_list ( unsigned_intTI_type_node , unsigned_intDI_type_node , unsigned_intDI_type_node , NULL_TREE ) ; ARM_BUILTIN_CRYPTO_ ## U <STR_LIT> # L R ## _ftype_ ## A R ## _ftype_ ## A1 ## _ ## A2 R ## _ftype_ ## A1 ## _ ## A2 ## _ ## A3 arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT1 ( R , A ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ;

arm_builtin_decls [ C ( U ) ] \ = add_builtin_function ( N ( L ) , FT2 ( R , A1 , A2 ) , \ C ( U ) , BUILT_IN_MD , NULL , NULL_TREE ) ;


<s> TYPE_PRECISION ( arm_fp16_type_node ) = GET_MODE_PRECISION ( HFmode ) ; layout_type ( arm_fp16_type_node ) ; if ( arm_fp16_format ) ( * lang_hooks . types . register_builtin_type ) ( arm_fp16_type_node , <STR_LIT> ) ;


<s> for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mve_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & mve_builtin_data [ i ] ;

arm_init_builtin ( fcode , d , <STR_LIT> ) ;


<s> tree set_fpscr_nzcvqc = build_function_type_list ( void_type_node , intSI_type_node , NULL ) ; arm_builtin_decls [ ARM_BUILTIN_GET_FPSCR_NZCVQC ] = add_builtin_function ( <STR_LIT> , get_fpscr_nzcvqc , ARM_BUILTIN_GET_FPSCR_NZCVQC , BUILT_IN_MD , NULL , NULL_TREE ) ; arm_builtin_decls [ ARM_BUILTIN_SET_FPSCR_NZCVQC ] = add_builtin_function ( <STR_LIT> , set_fpscr_nzcvqc , ARM_BUILTIN_SET_FPSCR_NZCVQC , BUILT_IN_MD , NULL , NULL_TREE ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( mve_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & mve_builtin_data [ i ] ; arm_init_builtin ( fcode , d , <STR_LIT> ) ;


<s> arm_init_simd_builtin_scalar_types ( ) ; for ( i = <NUM_LIT> ; i < ARRAY_SIZE ( neon_builtin_data ) ; i ++ , fcode ++ ) { arm_builtin_datum * d = & neon_builtin_data [ i ] ; arm_init_builtin ( fcode , d , <STR_LIT> ) ; }


<s> ( * lang_hooks . types . register_builtin_type ) ( unsigned_intQI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intHI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intSI_type_node , <STR_LIT> ) ; ( * lang_hooks . types . register_builtin_type ) ( unsigned_intDI_type_node , <STR_LIT> ) ;

( * lang_hooks . types . register_builtin_type ) ( unsigned_intTI_type_node , <STR_LIT> ) ;


<s> arm_simd_polyDI_type_node = build_distinct_type_copy ( unsigned_intDI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyDI_type_node , <STR_LIT> ) ; arm_simd_polyTI_type_node = build_distinct_type_copy ( unsigned_intTI_type_node ) ; ( * lang_hooks . types . register_builtin_type ) ( arm_simd_polyTI_type_node , <STR_LIT> ) ; arm_simd_types [ Poly8x8_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly8x16_t ] . eltype = arm_simd_polyQI_type_node ; arm_simd_types [ Poly16x4_t ] . eltype = arm_simd_polyHI_type_node ; arm_simd_types [ Poly16x8_t ] . eltype = arm_simd_polyHI_type_node ; TYPE_STRING_FLAG ( arm_simd_polyQI_type_node ) = false ; TYPE_STRING_FLAG ( arm_simd_polyHI_type_node ) = false ; } arm_simd_types [ Int8x8_t ] . eltype = intQI_type_node ; arm_simd_types [ Int8x16_t ] . eltype = intQI_type_node ; arm_simd_types [ Int16x4_t ] . eltype = intHI_type_node ; arm_simd_types [ Int16x8_t ] . eltype = intHI_type_node ; arm_simd_types [ Int32x2_t ] . eltype = intSI_type_node ; arm_simd_types [ Int32x4_t ] . eltype = intSI_type_node ; arm_simd_types [ Int64x2_t ] . eltype = intDI_type_node ; arm_simd_types [ Uint8x8_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint8x16_t ] . eltype = unsigned_intQI_type_node ; arm_simd_types [ Uint16x4_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint16x8_t ] . eltype = unsigned_intHI_type_node ; arm_simd_types [ Uint32x2_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint32x4_t ] . eltype = unsigned_intSI_type_node ; arm_simd_types [ Uint64x2_t ] . eltype = unsigned_intDI_type_node ; arm_simd_types [ Float16x4_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float16x8_t ] . eltype = arm_fp16_type_node ; arm_simd_types [ Float32x2_t ] . eltype = float_type_node ; arm_simd_types [ Float32x4_t ] . eltype = float_type_node ; arm_simd_types [ Bfloat16x2_t ] . eltype = arm_bf16_type_node ; arm_simd_types [ Bfloat16x4_t ] . eltype = arm_bf16_type_node ; arm_simd_types [ Bfloat16x8_t ] . eltype = arm_bf16_type_node ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) { tree eltype = arm_simd_types [ i ] . eltype ; machine_mode mode = arm_simd_types [ i ] . mode ;

if ( eltype == NULL && ( ( GET_MODE_CLASS ( mode ) != MODE_VECTOR_BOOL ) || ! TARGET_HAVE_MVE ) ) continue ;


<s> arm_builtin_datum * d = & vfp_builtin_data [ i ] ; arm_init_builtin ( fcode , d , <STR_LIT> ) ;


<s> static tree arm_lookup_simd_builtin_type ( machine_mode mode , enum arm_type_qualifiers q ) { int i ; int nelts = sizeof ( arm_simd_types ) / sizeof ( arm_simd_types [ <NUM_LIT> ] ) ; if ( q != qualifier_poly && ! VECTOR_MODE_P ( mode ) ) return arm_simd_builtin_std_type ( mode , q ) ; for ( i = <NUM_LIT> ; i < nelts ; i ++ ) if ( arm_simd_types [ i ] . mode == mode && arm_simd_types [ i ] . q == q ) return arm_simd_types [ i ] . itype ; return NULL_TREE ;


<s> static tree arm_lookup_simd_builtin_type ( machine_mode mode , enum arm_type_qualifiers q ) { int i ; int nelts = sizeof ( arm_simd_types ) / sizeof ( arm_simd_types [ <NUM_LIT> ] ) ;

if ( q != qualifier_poly && ! VECTOR_MODE_P ( mode ) ) return arm_simd_builtin_std_type ( mode , q ) ;


<s> int i = <NUM_LIT> ; while ( arm_scalar_builtin_types [ i ] != NULL ) { const char * name = arm_scalar_builtin_types [ i ] ; if ( TREE_CODE ( TYPE_NAME ( type ) ) == TYPE_DECL && DECL_NAME ( TYPE_NAME ( type ) ) && ! strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( TYPE_NAME ( type ) ) ) , name ) ) return arm_scalar_builtin_types [ i ] ; i ++ ; } return NULL ;


<s> static const char * arm_mangle_builtin_scalar_type ( const_tree type ) { int i = <NUM_LIT> ; while ( arm_scalar_builtin_types [ i ] != NULL ) { const char * name = arm_scalar_builtin_types [ i ] ; if ( TREE_CODE ( TYPE_NAME ( type ) ) == TYPE_DECL && DECL_NAME ( TYPE_NAME ( type ) ) && ! strcmp ( IDENTIFIER_POINTER ( DECL_NAME ( TYPE_NAME ( type ) ) ) , name ) ) return arm_scalar_builtin_types [ i ] ; i ++ ;


<s> const char * mangle ; if ( ( mangle = arm_mangle_builtin_vector_type ( type ) ) || ( mangle = arm_mangle_builtin_scalar_type ( type ) ) ) return mangle ; return NULL ;


<s> if ( tree attr = lookup_attribute ( <STR_LIT> , attrs ) ) { tree mangled_name = TREE_VALUE ( TREE_VALUE ( attr ) ) ; return IDENTIFIER_POINTER ( mangled_name ) ; }


<s> if ( tree attr = lookup_attribute ( <STR_LIT> , attrs ) ) {

tree mangled_name = TREE_VALUE ( TREE_VALUE ( attr ) ) ;


<s> return QUAL_TYPE ( SI ) ; case E_DImode : return QUAL_TYPE ( DI ) ; case E_TImode : return QUAL_TYPE ( TI ) ; case E_OImode : return arm_simd_intOI_type_node ; case E_EImode : return arm_simd_intEI_type_node ; case E_CImode : return arm_simd_intCI_type_node ; case E_XImode : return arm_simd_intXI_type_node ; case E_HFmode : return arm_fp16_type_node ; case E_SFmode :


<s> if ( poly_p ) return arm_lookup_simd_builtin_type ( mode , qualifier_poly ) ; else if ( unsigned_p ) return arm_lookup_simd_builtin_type ( mode , qualifier_unsigned ) ; else return arm_lookup_simd_builtin_type ( mode , qualifier_none ) ;


gcc_assert ( POINTER_TYPE_P ( type ) ) ;


<s> vector_size = GET_MODE_SIZE ( vector_mode ) ; gcc_assert ( reg_size % vector_size == <NUM_LIT> ) ; nvectors = reg_size / vector_size ; gcc_assert ( POINTER_TYPE_P ( type ) ) ; elem_type = TREE_TYPE ( type ) ; if ( mem_mode == reg_mode ) nelems = vector_size * nvectors / int_size_in_bytes ( elem_type ) ;


<s> x = gen_reg_rtx ( mode ) ; emit_insn ( gen_iwmmxt_clrdi ( mode == DImode ? x : gen_rtx_SUBREG ( DImode , x , <NUM_LIT> ) ) ) ; return x ;


emit_insn ( gen_iwmmxt_clrdi ( mode == DImode ? x : gen_rtx_SUBREG ( DImode , x , <NUM_LIT> ) ) ) ;


<s> builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } else { builtin_define ( <STR_LIT> ) ; } if ( TARGET_SOFT_FLOAT ) builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_VFP ) ; if ( TARGET_ARM_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_FP ) ; else cpp_undef ( pfile , <STR_LIT> ) ; if ( arm_fp16_format == ARM_FP16_FORMAT_IEEE ) builtin_define ( <STR_LIT> ) ; if ( arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE ) builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_FMA ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; if ( TARGET_NEON_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_NEON_FP ) ; else cpp_undef ( pfile , <STR_LIT> ) ; if ( arm_cpp_interwork ) builtin_define ( <STR_LIT> ) ; builtin_define ( arm_arch_name ) ; if ( arm_arch_xscale ) builtin_define ( <STR_LIT> ) ; if ( arm_arch_iwmmxt ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( arm_arch_iwmmxt2 ) builtin_define ( <STR_LIT> ) ; if ( arm_arch6kz ) builtin_define ( <STR_LIT> ) ; if ( TARGET_AAPCS_BASED ) { if ( arm_pcs_default == ARM_PCS_AAPCS_VFP ) builtin_define ( <STR_LIT> ) ; else if ( arm_pcs_default == ARM_PCS_AAPCS ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ;


C_CPP_HASHNODE ( acond_macro ) -> flags |= NODE_CONDITIONAL ;


<s> void arm_register_target_pragmas ( void ) {


<s> builtin_define_type_sizeof ( <STR_LIT> , wchar_type_node ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_ARM_ARCH_PROFILE ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_ARCH_PROFILE ) ; builtin_define ( <STR_LIT> ) ; if ( TARGET_ARM_ARCH ) { cpp_undef ( pfile , <STR_LIT> ) ; builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_ARCH ) ; } if ( arm_arch_notm ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB2 ) ; if ( TARGET_BIG_END ) def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; else def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_ARM_ARCH_ISA_THUMB ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_ARCH_ISA_THUMB ) ; if ( TARGET_BIG_END ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } else { builtin_define ( <STR_LIT> ) ; } if ( TARGET_SOFT_FLOAT ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_ARM_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_FP ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format == ARM_FP16_FORMAT_IEEE ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format != ARM_FP16_FORMAT_NONE ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_VFP_FP16INST ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON_FP16INST ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_FP16FML ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_FMA ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_NEON_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_NEON_FP ) ; if ( arm_cpp_interwork ) builtin_define ( <STR_LIT> ) ; builtin_define ( arm_arch_name ) ; if ( arm_arch_xscale ) builtin_define ( <STR_LIT> ) ; if ( arm_arch_iwmmxt ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( arm_arch_iwmmxt2 ) builtin_define ( <STR_LIT> ) ; if ( arm_arch6kz ) builtin_define ( <STR_LIT> ) ; if ( TARGET_AAPCS_BASED ) { if ( arm_pcs_default == ARM_PCS_AAPCS_VFP ) builtin_define ( <STR_LIT> ) ; else if ( arm_pcs_default == ARM_PCS_AAPCS ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } def_or_undef_macro ( pfile , <STR_LIT> , TARGET_IDIV ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_IDIV ) ; def_or_undef_macro ( pfile , <STR_LIT> , inline_asm_unified ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_32BIT && arm_arch4 && ! ( arm_arch8 && arm_arch_notm ) ) { int coproc_level = <NUM_LIT> ; if ( arm_arch5t ) coproc_level |= <NUM_LIT> ; if ( arm_arch5te ) coproc_level |= <NUM_LIT> ; if ( arm_arch6 ) coproc_level |= <NUM_LIT> ;


<s> builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_ARCH ) ; } if ( arm_arch_notm ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB2 ) ; if ( TARGET_BIG_END ) def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; else def_or_undef_macro ( pfile , <STR_LIT> , TARGET_THUMB ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_ARM_ARCH_ISA_THUMB ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_ARCH_ISA_THUMB ) ; if ( TARGET_BIG_END ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } else { builtin_define ( <STR_LIT> ) ; } if ( TARGET_SOFT_FLOAT ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_ARM_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_ARM_FP ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format == ARM_FP16_FORMAT_IEEE ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format == ARM_FP16_FORMAT_ALTERNATIVE ) ; def_or_undef_macro ( pfile , <STR_LIT> , arm_fp16_format != ARM_FP16_FORMAT_NONE ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_VFP_FP16INST ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON_FP16INST ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_FP16FML ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_FMA ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_NEON ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_NEON_FP ) builtin_define_with_int_value ( <STR_LIT> , TARGET_NEON_FP ) ; if ( arm_cpp_interwork ) builtin_define ( <STR_LIT> ) ; builtin_define ( arm_arch_name ) ; if ( arm_arch_xscale ) builtin_define ( <STR_LIT> ) ; if ( arm_arch_iwmmxt ) { builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } if ( arm_arch_iwmmxt2 ) builtin_define ( <STR_LIT> ) ; if ( arm_arch6kz ) builtin_define ( <STR_LIT> ) ; if ( TARGET_AAPCS_BASED ) { if ( arm_pcs_default == ARM_PCS_AAPCS_VFP ) builtin_define ( <STR_LIT> ) ; else if ( arm_pcs_default == ARM_PCS_AAPCS ) builtin_define ( <STR_LIT> ) ; builtin_define ( <STR_LIT> ) ; } def_or_undef_macro ( pfile , <STR_LIT> , TARGET_IDIV ) ; def_or_undef_macro ( pfile , <STR_LIT> , TARGET_IDIV ) ; def_or_undef_macro ( pfile , <STR_LIT> , inline_asm_unified ) ; cpp_undef ( pfile , <STR_LIT> ) ; if ( TARGET_32BIT && arm_arch4 && ! ( arm_arch8 && arm_arch_notm ) ) { int coproc_level = <NUM_LIT> ; if ( arm_arch5t ) coproc_level |= <NUM_LIT> ; if ( arm_arch5te ) coproc_level |= <NUM_LIT> ; if ( arm_arch6 ) coproc_level |= <NUM_LIT> ;


<s> builtin_assert ( <STR_LIT> ) ; arm_cpu_builtins ( pfile ) ;


<s> void arm_lang_object_attributes_init ( void ) {


<s> int wchar_size = ( int ) ( TYPE_PRECISION ( wchar_type_node ) / BITS_PER_UNIT ) ;


<s> static void arm_pragma_arm ( cpp_reader * ) { tree x ; if ( pragma_lex ( & x ) != CPP_STRING ) { error ( <STR_LIT> ) ;


<s> tree prev_tree = target_option_current_node ; tree cur_tree ; struct cl_target_option * prev_opt ; struct cl_target_option * cur_opt ; if ( ! args ) { cur_tree = ( ( pop_target ) ? pop_target : target_option_default_node ) ; cl_target_option_restore ( & global_options , & global_options_set , TREE_TARGET_OPTION ( cur_tree ) ) ; } else { cur_tree = arm_valid_target_attribute_tree ( args , & global_options , & global_options_set ) ; if ( cur_tree == NULL_TREE ) { cl_target_option_restore ( & global_options , & global_options_set , TREE_TARGET_OPTION ( prev_tree ) ) ; return false ; } target_option_current_node = cur_tree ; arm_configure_build_target ( & arm_active_target , TREE_TARGET_OPTION ( cur_tree ) , false ) ; arm_option_reconfigure_globals ( ) ; }


<s> targetm . target_option . pragma_parse = arm_pragma_target_parse ;

targetm . resolve_overloaded_builtin = arm_resolve_overloaded_builtin ;


<s> if ( arm_describe_resolver ( fndecl ) == arm_cde_resolver ) return arm_resolve_cde_builtin ( loc , fndecl , arglist ) ;


<s> if ( arm_describe_resolver ( fndecl ) == arm_cde_resolver ) return arm_resolve_cde_builtin ( loc , fndecl , arglist ) ; return NULL_TREE ;


<s> if ( def_p ) cpp_define ( pfile , name ) ; else cpp_undef ( pfile , name ) ;


<s> switch ( arm_float_abi ) { case ARM_FLOAT_ABI_HARD : abi = <STR_LIT> ; break ; case ARM_FLOAT_ABI_SOFT : abi = <STR_LIT> ; break ; case ARM_FLOAT_ABI_SOFTFP : abi = <STR_LIT> ; break ;


<s> case ARM_FLOAT_ABI_HARD : abi = <STR_LIT> ; break ; case ARM_FLOAT_ABI_SOFT : abi = <STR_LIT> ; break ; case ARM_FLOAT_ABI_SOFTFP : abi = <STR_LIT> ; break ; default : abi = <STR_LIT> ;


<s> const struct d_target_info_spec handlers [ ] = { { <STR_LIT> , arm_d_handle_target_float_abi } , { NULL , NULL } , } ;

d_add_target_info_handlers ( handlers ) ;


<s> } if ( TARGET_HARD_FLOAT_ABI ) d_add_builtin_version ( <STR_LIT> ) ; else { if ( TARGET_SOFT_FLOAT ) d_add_builtin_version ( <STR_LIT> ) ; else if ( TARGET_HARD_FLOAT ) d_add_builtin_version ( <STR_LIT> ) ; } if ( TARGET_SOFT_FLOAT ) d_add_builtin_version ( <STR_LIT> ) ;


<s> for ( unsigned int i = <NUM_LIT> ; i < __TYPE_FINAL ; ++ i ) if ( arm_simd_types [ i ] . eltype == eltype && GET_MODE_SIZE ( arm_simd_types [ i ] . mode ) == <NUM_LIT> ) return arm_simd_types [ i ] . itype ;


<s> static tree arm_mve_type_for_scalar_type ( tree eltype ) {

for ( unsigned int i = <NUM_LIT> ; i < __TYPE_FINAL ; ++ i ) if ( arm_simd_types [ i ] . eltype == eltype && GET_MODE_SIZE ( arm_simd_types [ i ] . mode ) == <NUM_LIT> ) return arm_simd_types [ i ] . itype ;


<s> } register_builtin_types ( ) ; for ( unsigned int type_i = <NUM_LIT> ; type_i < NUM_VECTOR_TYPES ; ++ type_i ) {


<s> } register_builtin_types ( ) ; for ( unsigned int type_i = <NUM_LIT> ; type_i < NUM_VECTOR_TYPES ; ++ type_i ) { vector_type_index type = vector_type_index ( type_i ) ; register_vector_type ( type ) ; if ( type_i != VECTOR_TYPE_mve_pred16_t ) register_builtin_tuple_types ( type ) ;


<s> snprintf ( buffer , sizeof ( buffer ) , <STR_LIT> , ( int ) strlen ( vector_type_name ) - <NUM_LIT> , vector_type_name , num_vectors ) ; tree vectype = acle_vector_types [ <NUM_LIT> ] [ type ] ; tree arrtype = build_array_type_nelts ( vectype , num_vectors ) ; gcc_assert ( TYPE_MODE_RAW ( arrtype ) == TYPE_MODE ( arrtype ) ) ; tree field = build_decl ( input_location , FIELD_DECL , get_identifier ( <STR_LIT> ) , arrtype ) ;

tree t = lang_hooks . types . simulate_record_decl ( input_location , buffer , make_array_slice ( & field , <NUM_LIT> ) ) ;


<s> } else { vectype = arm_mve_type_for_scalar_type ( eltype ) ; gcc_assert ( VECTOR_MODE_P ( TYPE_MODE ( vectype ) ) && GET_MODE_SIZE ( TYPE_MODE ( vectype ) ) == <NUM_LIT> ) ; } abi_vector_types [ i ] = vectype ;


<s> if ( decl && TREE_CODE ( decl ) == TYPE_DECL && TREE_TYPE ( decl ) != error_mark_node && TYPE_MAIN_VARIANT ( TREE_TYPE ( decl ) ) == vectype ) vectype = TREE_TYPE ( decl ) ; acle_vector_types [ <NUM_LIT> ] [ type ] = vectype ;


<s> if ( vector_types [ type ] . requires_float && ! TARGET_HAVE_MVE_FLOAT ) return ; tree vectype = abi_vector_types [ type ] ; tree id = get_identifier ( vector_types [ type ] . acle_name ) ; tree decl = build_decl ( input_location , TYPE_DECL , id , vectype ) ; decl = lang_hooks . decls . pushdecl ( decl ) ; if ( decl && TREE_CODE ( decl ) == TYPE_DECL && TREE_TYPE ( decl ) != error_mark_node && TYPE_MAIN_VARIANT ( TREE_TYPE ( decl ) ) == vectype ) vectype = TREE_TYPE ( decl ) ; acle_vector_types [ <NUM_LIT> ] [ type ] = vectype ;


<s> void aarch_bti_arch_check ( void ) { if ( ! arm_arch8m_main ) error ( <STR_LIT> ) ;


<s> bool aarch_bti_enabled ( void ) { return aarch_enable_bti != <NUM_LIT> ;


<s> bool aarch_bti_j_insn_p ( rtx_insn * insn ) { if ( ! insn || ! INSN_P ( insn ) ) return false ; rtx pat = PATTERN ( insn ) ; return GET_CODE ( pat ) == UNSPEC_VOLATILE && XINT ( pat , <NUM_LIT> ) == VUNSPEC_BTI_NOP ;


return GET_CODE ( pat ) == UNSPEC_VOLATILE && XINT ( pat , <NUM_LIT> ) == VUNSPEC_BTI_NOP ;


<s> if ( ! x || ! INSN_P ( x ) ) return false ; rtx pat = PATTERN ( x ) ; if ( GET_CODE ( pat ) == SET ) { rtx tmp = XEXP ( pat , <NUM_LIT> ) ; if ( tmp && ( ( GET_CODE ( tmp ) == UNSPEC && XINT ( tmp , <NUM_LIT> ) == UNSPEC_PAC_NOP ) || ( GET_CODE ( tmp ) == UNSPEC_VOLATILE && XINT ( tmp , <NUM_LIT> ) == VUNSPEC_PACBTI_NOP ) ) ) return true ; }


<s> unsigned * cost = ( unsigned * ) data ; unsigned retval = <NUM_LIT> ; if ( flag_vect_cost_model ) { int stmt_cost = arm_builtin_vectorization_cost ( kind , vectype , misalign ) ; if ( where == vect_body && stmt_info && stmt_in_inner_loop_p ( vinfo , stmt_info ) ) count *= <NUM_LIT> ;

retval = ( unsigned ) ( count * stmt_cost ) ;


<s> static unsigned arm_add_stmt_cost ( vec_info * vinfo , void * data , int count , enum vect_cost_for_stmt kind , struct _stmt_vec_info * stmt_info , tree vectype , int misalign , enum vect_cost_model_location where ) { unsigned * cost = ( unsigned * ) data ; unsigned retval = <NUM_LIT> ; if ( flag_vect_cost_model ) {

int stmt_cost = arm_builtin_vectorization_cost ( kind , vectype , misalign ) ;


<s> unsigned HOST_WIDE_INT const1 ; unsigned HOST_WIDE_INT const2 = <NUM_LIT> ; if ( ! CONST_INT_P ( XEXP ( op0 , <NUM_LIT> ) ) ) return false ; const1 = UINTVAL ( XEXP ( op0 , <NUM_LIT> ) ) ; if ( ! CONST_INT_P ( XEXP ( op1 , <NUM_LIT> ) ) || ~ UINTVAL ( XEXP ( op1 , <NUM_LIT> ) ) != const1 ) return false ; if ( GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == ASHIFT && CONST_INT_P ( XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ) { const2 = UINTVAL ( XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ;

* sub0 = XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ;


<s> unsigned HOST_WIDE_INT const2 = <NUM_LIT> ; if ( ! CONST_INT_P ( XEXP ( op0 , <NUM_LIT> ) ) ) return false ; const1 = UINTVAL ( XEXP ( op0 , <NUM_LIT> ) ) ; if ( ! CONST_INT_P ( XEXP ( op1 , <NUM_LIT> ) ) || ~ UINTVAL ( XEXP ( op1 , <NUM_LIT> ) ) != const1 ) return false ; if ( GET_CODE ( XEXP ( op0 , <NUM_LIT> ) ) == ASHIFT && CONST_INT_P ( XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ) { const2 = UINTVAL ( XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ) ; * sub0 = XEXP ( XEXP ( op0 , <NUM_LIT> ) , <NUM_LIT> ) ; } else * sub0 = XEXP ( op0 , <NUM_LIT> ) ; if ( const2 >= GET_MODE_BITSIZE ( GET_MODE ( op0 ) ) ) return false ; * sub1 = XEXP ( op1 , <NUM_LIT> ) ;


<s> static bool arm_bfi_p ( rtx x , rtx * sub0 , rtx * sub1 ) { if ( GET_CODE ( x ) != IOR ) return false ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != AND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != AND ) return false ;

return ( arm_bfi_1_p ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , sub0 , sub1 ) || arm_bfi_1_p ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , sub1 , sub0 ) ) ;


<s> if ( GET_CODE ( x ) != IOR ) return false ; if ( GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != AND || GET_CODE ( XEXP ( x , <NUM_LIT> ) ) != AND ) return false ; return ( arm_bfi_1_p ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , sub0 , sub1 ) || arm_bfi_1_p ( XEXP ( x , <NUM_LIT> ) , XEXP ( x , <NUM_LIT> ) , sub1 , sub0 ) ) ;


<s> if ( TARGET_APCS_FRAME && frame_pointer_needed && TARGET_ARM ) save_reg_mask |= ( <NUM_LIT> << ARM_HARD_FRAME_POINTER_REGNUM ) | ( <NUM_LIT> << IP_REGNUM ) | ( <NUM_LIT> << LR_REGNUM ) | ( <NUM_LIT> << PC_REGNUM ) ; save_reg_mask |= arm_compute_save_reg0_reg12_mask ( ) ; if ( arm_current_function_pac_enabled_p ( ) ) save_reg_mask |= <NUM_LIT> << IP_REGNUM ; if ( df_regs_ever_live_p ( LR_REGNUM ) || ( save_reg_mask && optimize_size && ARM_FUNC_TYPE ( func_type ) == ARM_FT_NORMAL && ! crtl -> tail_call_emit && ! crtl -> calls_eh_return ) ) save_reg_mask |= <NUM_LIT> << LR_REGNUM ; if ( cfun -> machine -> lr_save_eliminated ) save_reg_mask &= ~ ( <NUM_LIT> << LR_REGNUM ) ; if ( TARGET_REALLY_IWMMXT && ( ( bit_count ( save_reg_mask ) + ARM_NUM_INTS ( crtl -> args . pretend_args_size + arm_compute_static_chain_stack_bytes ( ) ) ) % <NUM_LIT> ) != <NUM_LIT> ) { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( ( save_reg_mask & ( <NUM_LIT> << reg ) ) == <NUM_LIT> ) break ; if ( reg <= <NUM_LIT> ) save_reg_mask |= ( <NUM_LIT> << reg ) ; else { cfun -> machine -> sibcall_blocked = <NUM_LIT> ; save_reg_mask |= ( <NUM_LIT> << <NUM_LIT> ) ; } } if ( TARGET_THUMB2 && IS_NESTED ( func_type ) && flag_pic && ( save_reg_mask & THUMB2_WORK_REGS ) == <NUM_LIT> ) { reg = thumb_find_work_register ( <NUM_LIT> << <NUM_LIT> ) ; if ( ! call_used_or_fixed_reg_p ( reg ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; }


<s> if ( TARGET_REALLY_IWMMXT && ( ( bit_count ( save_reg_mask ) + ARM_NUM_INTS ( crtl -> args . pretend_args_size + arm_compute_static_chain_stack_bytes ( ) ) ) % <NUM_LIT> ) != <NUM_LIT> ) { for ( reg = <NUM_LIT> ; reg <= <NUM_LIT> ; reg ++ ) if ( ( save_reg_mask & ( <NUM_LIT> << reg ) ) == <NUM_LIT> ) break ; if ( reg <= <NUM_LIT> ) save_reg_mask |= ( <NUM_LIT> << reg ) ; else { cfun -> machine -> sibcall_blocked = <NUM_LIT> ; save_reg_mask |= ( <NUM_LIT> << <NUM_LIT> ) ; } } if ( TARGET_THUMB2 && IS_NESTED ( func_type ) && flag_pic && ( save_reg_mask & THUMB2_WORK_REGS ) == <NUM_LIT> ) { reg = thumb_find_work_register ( <NUM_LIT> << <NUM_LIT> ) ; if ( ! call_used_or_fixed_reg_p ( reg ) ) save_reg_mask |= ( <NUM_LIT> << reg ) ; } return save_reg_mask ;


<s> bool arm_current_function_pac_enabled_p ( void ) { return ( aarch_ra_sign_scope == AARCH_FUNCTION_ALL || ( aarch_ra_sign_scope == AARCH_FUNCTION_NON_LEAF && ! crtl -> is_leaf ) ) ;


<s> bool arm_current_function_pac_enabled_p ( void ) {

return ( aarch_ra_sign_scope == AARCH_FUNCTION_ALL || ( aarch_ra_sign_scope == AARCH_FUNCTION_NON_LEAF && ! crtl -> is_leaf ) ) ;


<s> if ( regno < <NUM_LIT> ) return regno ; if ( IS_VFP_REGNUM ( regno ) ) { if ( VFP_REGNO_OK_FOR_SINGLE ( regno ) ) return <NUM_LIT> + regno - FIRST_VFP_REGNUM ;

else return <NUM_LIT> + ( regno - FIRST_VFP_REGNUM ) / <NUM_LIT> ;


<s> if ( IS_VFP_REGNUM ( regno ) ) { if ( VFP_REGNO_OK_FOR_SINGLE ( regno ) ) return <NUM_LIT> + regno - FIRST_VFP_REGNUM ; else return <NUM_LIT> + ( regno - FIRST_VFP_REGNUM ) / <NUM_LIT> ; }

if ( IS_IWMMXT_GR_REGNUM ( regno ) ) return <NUM_LIT> + regno - FIRST_IWMMXT_GR_REGNUM ;


<s> gcc_assert ( REG_P ( op ) ) ; if ( ! strict || REGNO ( op ) < FIRST_PSEUDO_REGISTER || ! reg_renumber || reg_renumber [ REGNO ( op ) ] < <NUM_LIT> ) return REGNO ( op ) ;


<s> if ( return_in_pc ) XVECEXP ( par , <NUM_LIT> , <NUM_LIT> ) = ret_rtx ; if ( emit_update ) { tmp = gen_rtx_SET ( stack_pointer_rtx , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * num_regs ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , offset_adj ) = tmp ; } for ( j = <NUM_LIT> , i = <NUM_LIT> ; j < num_regs ; i ++ ) if ( saved_regs_mask & ( <NUM_LIT> << i ) ) { rtx dwarf_reg = reg = gen_rtx_REG ( SImode , i ) ; if ( arm_current_function_pac_enabled_p ( ) && i == IP_REGNUM ) dwarf_reg = gen_rtx_REG ( SImode , RA_AUTH_CODE ) ; if ( ( num_regs == <NUM_LIT> ) && emit_update && ! return_in_pc ) { tmp = gen_frame_mem ( SImode , gen_rtx_POST_INC ( Pmode , stack_pointer_rtx ) ) ; tmp = emit_insn ( gen_rtx_SET ( reg , tmp ) ) ; REG_NOTES ( tmp ) = alloc_reg_note ( REG_CFA_RESTORE , dwarf_reg , dwarf ) ; return ; } tmp = gen_rtx_SET ( reg , gen_frame_mem ( SImode , plus_constant ( Pmode , stack_pointer_rtx , <NUM_LIT> * j ) ) ) ; RTX_FRAME_RELATED_P ( tmp ) = <NUM_LIT> ; XVECEXP ( par , <NUM_LIT> , j + emit_update + offset_adj ) = tmp ; if ( i != PC_REGNUM ) dwarf = alloc_reg_note ( REG_CFA_RESTORE , dwarf_reg , dwarf ) ; j ++ ; } if ( return_in_pc ) par = emit_jump_insn ( par ) ; else par = emit_insn ( par ) ;


<s> insn = GEN_INT ( - ( <NUM_LIT> + args_to_push + fp_offset ) ) ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , ip_rtx , insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } else { insn = GEN_INT ( saved_regs - ( <NUM_LIT> + fp_offset ) ) ; insn = emit_insn ( gen_addsi3 ( hard_frame_pointer_rtx , stack_pointer_rtx , insn ) ) ; RTX_FRAME_RELATED_P ( insn ) = <NUM_LIT> ; } } size = offsets -> outgoing_args - offsets -> saved_args ; if ( flag_stack_usage_info ) current_function_static_stack_size = size ; if ( ! IS_INTERRUPT ( func_type ) && ( flag_stack_check == STATIC_BUILTIN_STACK_CHECK || flag_stack_clash_protection ) ) { unsigned int regno ; if ( ! IS_NESTED ( func_type ) || clobber_ip ) regno = IP_REGNUM ; else if ( df_regs_ever_live_p ( LR_REGNUM ) ) regno = LR_REGNUM ; else regno = <NUM_LIT> ; if ( crtl -> is_leaf && ! cfun -> calls_alloca ) { if ( size > PROBE_INTERVAL && size > get_stack_check_protect ( ) ) arm_emit_probe_stack_range ( get_stack_check_protect ( ) , size - get_stack_check_protect ( ) , regno , live_regs_mask ) ; } else if ( size > <NUM_LIT> ) arm_emit_probe_stack_range ( get_stack_check_protect ( ) , size , regno , live_regs_mask ) ; } if ( clobber_ip ) { if ( ! arm_r3_live_at_start_p ( ) || saved_pretend_args ) insn = gen_rtx_REG ( SImode , <NUM_LIT> ) ; else { insn = plus_constant ( Pmode , hard_frame_pointer_rtx , <NUM_LIT> ) ; insn = gen_frame_mem ( SImode , insn ) ; } emit_set_insn ( ip_rtx , insn ) ; emit_insn ( gen_force_register_use ( ip_rtx ) ) ; } if ( offsets -> outgoing_args != offsets -> saved_args + saved_regs ) { rtx_insn * last = get_last_insn ( ) ; amount = GEN_INT ( offsets -> saved_args + saved_regs - offsets -> outgoing_args ) ; insn = emit_insn ( gen_addsi3 ( stack_pointer_rtx , stack_pointer_rtx , amount ) ) ; do { last = last ? NEXT_INSN ( last ) : get_insns ( ) ; RTX_FRAME_RELATED_P ( last ) = <NUM_LIT> ; } while ( last != insn ) ; if ( frame_pointer_needed ) emit_insn ( gen_stack_tie ( stack_pointer_rtx , hard_frame_pointer_rtx ) ) ; } if ( frame_pointer_needed && TARGET_THUMB2 ) thumb_set_frame_pointer ( offsets ) ; if ( flag_pic && arm_pic_register != INVALID_REGNUM ) { unsigned long mask ; mask = live_regs_mask ; mask &= THUMB2_WORK_REGS ; if ( ! IS_NESTED ( func_type ) ) mask |= ( <NUM_LIT> << IP_REGNUM ) ; arm_load_pic_register ( mask , NULL_RTX ) ; } if ( crtl -> profile || ! TARGET_SCHED_PROLOG || ( arm_except_unwind_info ( & global_options ) == UI_TARGET && cfun -> can_throw_non_call_exceptions ) ) emit_insn ( gen_blockage ( ) ) ; if ( ( live_regs_mask & ( <NUM_LIT> << LR_REGNUM ) ) == <NUM_LIT> ) cfun -> machine -> lr_save_eliminated = <NUM_LIT> ;


<s> if ( inverted ) std :: swap ( operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ;

emit_insn ( gen_neon_vbsl ( GET_MODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , mask , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] ) ) ;


<s> rtx mask = gen_reg_rtx ( cmp_result_mode ) ;

bool inverted = arm_expand_vector_compare ( mask , GET_CODE ( operands [ <NUM_LIT> ] ) , operands [ <NUM_LIT> ] , operands [ <NUM_LIT> ] , true ) ;


<s> } case EQ : case GE : case GT : emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , op1 ) ) ; return inverted ; case GEU : case GTU : emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , force_reg ( cmp_mode , op1 ) ) ) ; return inverted ; case LEU : case LTU : emit_insn ( gen_neon_vc ( swap_condition ( code ) , cmp_mode , target , force_reg ( cmp_mode , op1 ) , op0 ) ) ; return inverted ; case LTGT : case ORDERED : { rtx gt_res = gen_reg_rtx ( cmp_result_mode ) ; rtx alt_res = gen_reg_rtx ( cmp_result_mode ) ; rtx_code alt_code = ( code == LTGT ? LT : LE ) ; if ( arm_expand_vector_compare ( gt_res , GT , op0 , op1 , true ) || arm_expand_vector_compare ( alt_res , alt_code , op0 , op1 , true ) ) gcc_unreachable ( ) ; emit_insn ( gen_rtx_SET ( target , gen_rtx_IOR ( cmp_result_mode , gt_res , alt_res ) ) ) ; return inverted ; } default :


<s> bool inverted ; switch ( code ) { case UNORDERED : case UNLT : case UNLE : case UNGT : case UNGE : case UNEQ : case NE : code = reverse_condition_maybe_unordered ( code ) ; if ( ! can_invert ) { rtx tmp = gen_reg_rtx ( cmp_result_mode ) ; if ( arm_expand_vector_compare ( tmp , code , op0 , op1 , true ) ) gcc_unreachable ( ) ; emit_insn ( gen_rtx_SET ( target , gen_rtx_NOT ( cmp_result_mode , tmp ) ) ) ; return false ; } inverted = true ; break ; default : inverted = false ; break ; } switch ( code ) { case LE : case LT : if ( op1 != CONST0_RTX ( cmp_mode ) ) { code = swap_condition ( code ) ; std :: swap ( op0 , op1 ) ; } case EQ : case GE : case GT : emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , op1 ) ) ; return inverted ; case GEU : case GTU : emit_insn ( gen_neon_vc ( code , cmp_mode , target , op0 , force_reg ( cmp_mode , op1 ) ) ) ; return inverted ; case LEU : case LTU : emit_insn ( gen_neon_vc ( swap_condition ( code ) , cmp_mode , target , force_reg ( cmp_mode , op1 ) , op0 ) ) ; return inverted ; case LTGT : case ORDERED : {


<s> int val ; bool pac = ( aarch_ra_sign_scope != AARCH_FUNCTION_NONE ) ; bool bti = ( aarch_enable_bti == <NUM_LIT> ) ; arm_print_asm_arch_directives ( asm_out_file , TREE_TARGET_OPTION ( target_option_default_node ) ) ; if ( TARGET_BPABI ) { if ( arm_active_target . core_name && bitmap_bit_p ( arm_active_target . isa , isa_bit_quirk_no_asmcpu ) && ! startswith ( arm_active_target . core_name , <STR_LIT> ) ) { const char * truncated_name = arm_rewrite_selected_cpu ( arm_active_target . core_name ) ; if ( bitmap_bit_p ( arm_active_target . isa , isa_bit_quirk_no_asmcpu ) ) asm_fprintf ( asm_out_file , <STR_LIT> , truncated_name ) ; } if ( print_tune_info ) arm_print_tune_info ( ) ; if ( TARGET_HARD_FLOAT && TARGET_VFP_SINGLE ) arm_emit_eabi_attribute ( <STR_LIT> , <NUM_LIT> , <NUM_LIT> ) ;


<s> fntype = TREE_TYPE ( * node ) ; if ( TREE_CODE ( * node ) == VAR_DECL || TREE_CODE ( * node ) == TYPE_DECL ) decl = * node ; } else fntype = * node ; while ( fntype && TREE_CODE ( fntype ) == POINTER_TYPE ) fntype = TREE_TYPE ( fntype ) ; if ( ( DECL_P ( * node ) && ! decl ) || TREE_CODE ( fntype ) != FUNCTION_TYPE ) { warning ( OPT_Wattributes , <STR_LIT> <STR_LIT> , name ) ; * no_add_attrs = true ; return NULL_TREE ; } * no_add_attrs |= cmse_func_args_or_return_in_stack ( NULL , name , fntype ) ; if ( * no_add_attrs ) return NULL_TREE ; if ( decl ) { type = build_distinct_type_copy ( TREE_TYPE ( decl ) ) ; TREE_TYPE ( decl ) = type ; } else { type = build_distinct_type_copy ( * node ) ; * node = type ; } fntype = type ; while ( TREE_CODE ( fntype ) != FUNCTION_TYPE ) {


<s> } * no_add_attrs |= cmse_func_args_or_return_in_stack ( NULL , name , fntype ) ; if ( * no_add_attrs ) return NULL_TREE ; if ( decl ) { type = build_distinct_type_copy ( TREE_TYPE ( decl ) ) ; TREE_TYPE ( decl ) = type ; } else { type = build_distinct_type_copy ( * node ) ; * node = type ; } fntype = type ; while ( TREE_CODE ( fntype ) != FUNCTION_TYPE ) { type = fntype ; fntype = TREE_TYPE ( fntype ) ; fntype = build_distinct_type_copy ( fntype ) ; TREE_TYPE ( type ) = fntype ;