{"ground_truth": ["<s>", "void", "avr_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "int", "i", ";", "builtin_define_std", "(", "\"AVR\"", ")", ";", "if", "(", "avr_arch", "->", "macro", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_ARCH__=%s\"", ",", "avr_arch", "->", "macro", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPD__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPX__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPY__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPZ__\"", ")", ";", "if", "(", "AVR_HAVE_ELPM", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPM__\"", ")", ";", "if", "(", "AVR_HAVE_ELPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPMX__\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MOVW__\"", ")", ";", "if", "(", "AVR_HAVE_LPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_LPMX__\"", ")", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ASM_ONLY__\"", ")", ";", "if", "(", "AVR_HAVE_MUL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ENHANCED__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MUL__\"", ")", ";", "}", "if", "(", "avr_arch", "->", "have_jmp_call", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_MEGA__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_JMP_CALL__\"", ")", ";", "}", "if", "(", "AVR_XMEGA", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_XMEGA__\"", ")", ";", "if", "(", "AVR_TINY", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x4000\"", ")", ";", "}", "if", "(", "AVR_HAVE_EIJMP_EICALL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_EIJMP_EICALL__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_3_BYTE_PC__\"", ")", ";", "}", "else", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_2_BYTE_PC__\"", ")", ";", "}", "if", "(", "AVR_HAVE_8BIT_SP", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_8BIT_SP__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_16BIT_SP__\"", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_SPH__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_SP8__\"", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "cpp_define", "(", "pfile", ",", "\"__NO_INTERRUPTS__\"", ")", ";", "if", "(", "TARGET_SKIP_BUG", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP__\"", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", ")", ";", "}", "if", "(", "TARGET_RMW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ISA_RMW__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_SFR_OFFSET__=0x%x\"", ",", "avr_arch", "->", "sfr_offset", ")", ";", "cpp_define", "(", "pfile", ",", "\"__WITH_AVRLIBC__\"", ")", ";", "if", "(", "lang_GNU_C", "(", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", "&&", "avr_addrspace", "[", "i", "]", ".", "segment", "<", "avr_n_flash", "&&", "(", "AVR_HAVE_LPM", "||", "avr_addrspace", "[", "i", "]", ".", "pointer_size", "<=", "2", ")", ")", "{", "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "1", "+", "strlen", "(", "name", ")", ")", ";", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "}", "}", "cpp_define", "(", "pfile", ",", "\"__BUILTIN_AVR_\"", "#", "NAME", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__INT24_MAX__=8388607%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"LL\"", ":", "\"L\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__UINT24_MAX__=16777215%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"ULL\"", ":", "\"UL\"", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CPU_CPP_BUILTINS", "."], "TS_V_token": ["avr", "\"AVR\"", "\"__AVR_ARCH__=%s\"", "\"__AVR_HAVE_RAMPD__\"", "\"__AVR_HAVE_RAMPX__\"", "\"__AVR_HAVE_RAMPY__\"", "\"__AVR_HAVE_RAMPZ__\"", "\"__AVR_HAVE_ELPM__\"", "\"__AVR_HAVE_ELPMX__\"", "\"__AVR_HAVE_MOVW__\"", "\"__AVR_HAVE_LPMX__\"", "\"__AVR_ASM_ONLY__\"", "\"__AVR_ENHANCED__\"", "\"__AVR_HAVE_MUL__\"", "\"__AVR_MEGA__\"", "\"__AVR_HAVE_JMP_CALL__\"", "\"__AVR_XMEGA__\"", "\"__AVR_TINY__\"", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x4000\"", "\"__AVR_HAVE_EIJMP_EICALL__\"", "\"__AVR_3_BYTE_PC__\"", "\"__AVR_2_BYTE_PC__\"", "\"__AVR_HAVE_8BIT_SP__\"", "\"__AVR_HAVE_16BIT_SP__\"", "\"__AVR_HAVE_SPH__\"", "\"__AVR_SP8__\"", "\"__NO_INTERRUPTS__\"", "\"__AVR_ERRATA_SKIP__\"", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", "\"__AVR_ISA_RMW__\"", "\"__AVR_SFR_OFFSET__=0x%x\"", "\"__WITH_AVRLIBC__\"", "0", "2", "1", "\"__BUILTIN_AVR_\"", "\"__INT24_MAX__=8388607%s\"", "8", "\"LL\"", "\"L\"", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", "\"__UINT24_MAX__=16777215%s\"", "8", "\"ULL\"", "\"UL\""], "File": "avr-c2", "Func": "avr_cpu_cpp_builtins", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30281, "Length": 482}
{"ground_truth": ["<s>", "void", "avr_register_target_pragmas", "(", "void", ")", "{", "int", "i", ";", "gcc_assert", "(", "ADDR_SPACE_GENERIC", "==", "ADDR_SPACE_RAM", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "{", "gcc_assert", "(", "i", "==", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", ")", "c_register_addr_space", "(", "avr_addrspace", "[", "i", "]", ".", "name", ",", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "}", "targetm", ".", "resolve_overloaded_builtin", "=", "avr_resolve_overloaded_builtin", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "REGISTER_TARGET_PRAGMAS", "'", "."], "TS_V_token": ["avr", "0"], "File": "avr-c2", "Func": "avr_register_target_pragmas", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30282, "Length": 75}
{"ground_truth": ["<s>", "void", "avr_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define_std", "(", "\"AVR\"", ")", ";", "if", "(", "avr_arch", "->", "macro", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_ARCH__=%s\"", ",", "avr_arch", "->", "macro", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPD__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPX__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPY__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPZ__\"", ")", ";", "if", "(", "AVR_HAVE_ELPM", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPM__\"", ")", ";", "if", "(", "AVR_HAVE_ELPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPMX__\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MOVW__\"", ")", ";", "if", "(", "AVR_HAVE_LPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_LPMX__\"", ")", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ASM_ONLY__\"", ")", ";", "if", "(", "AVR_HAVE_MUL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ENHANCED__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MUL__\"", ")", ";", "}", "if", "(", "avr_arch", "->", "have_jmp_call", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_MEGA__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_JMP_CALL__\"", ")", ";", "}", "if", "(", "AVR_XMEGA", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_XMEGA__\"", ")", ";", "if", "(", "AVR_TINY", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", ",", "AVR_TINY_PM_OFFSET", ")", ";", "}", "if", "(", "AVR_HAVE_EIJMP_EICALL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_EIJMP_EICALL__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_3_BYTE_PC__\"", ")", ";", "}", "else", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_2_BYTE_PC__\"", ")", ";", "}", "if", "(", "AVR_HAVE_8BIT_SP", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_8BIT_SP__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_16BIT_SP__\"", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_SPH__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_SP8__\"", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "cpp_define", "(", "pfile", ",", "\"__NO_INTERRUPTS__\"", ")", ";", "if", "(", "TARGET_SKIP_BUG", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP__\"", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", ")", ";", "}", "if", "(", "TARGET_RMW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ISA_RMW__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_SFR_OFFSET__=0x%x\"", ",", "avr_arch", "->", "sfr_offset", ")", ";", "cpp_define", "(", "pfile", ",", "\"__WITH_AVRLIBC__\"", ")", ";", "if", "(", "lang_GNU_C", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", "&&", "avr_addr_space_supported_p", "(", "(", "addr_space_t", ")", "i", ")", ")", "{", "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "1", "+", "strlen", "(", "name", ")", ")", ";", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "}", "}", "cpp_define", "(", "pfile", ",", "\"__BUILTIN_AVR_\"", "#", "NAME", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__INT24_MAX__=8388607%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"LL\"", ":", "\"L\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__UINT24_MAX__=16777215%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"ULL\"", ":", "\"UL\"", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CPU_CPP_BUILTINS", "."], "TS_V_token": ["avr", "\"AVR\"", "\"__AVR_ARCH__=%s\"", "\"__AVR_HAVE_RAMPD__\"", "\"__AVR_HAVE_RAMPX__\"", "\"__AVR_HAVE_RAMPY__\"", "\"__AVR_HAVE_RAMPZ__\"", "\"__AVR_HAVE_ELPM__\"", "\"__AVR_HAVE_ELPMX__\"", "\"__AVR_HAVE_MOVW__\"", "\"__AVR_HAVE_LPMX__\"", "\"__AVR_ASM_ONLY__\"", "\"__AVR_ENHANCED__\"", "\"__AVR_HAVE_MUL__\"", "\"__AVR_MEGA__\"", "\"__AVR_HAVE_JMP_CALL__\"", "\"__AVR_XMEGA__\"", "\"__AVR_TINY__\"", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", "\"__AVR_HAVE_EIJMP_EICALL__\"", "\"__AVR_3_BYTE_PC__\"", "\"__AVR_2_BYTE_PC__\"", "\"__AVR_HAVE_8BIT_SP__\"", "\"__AVR_HAVE_16BIT_SP__\"", "\"__AVR_HAVE_SPH__\"", "\"__AVR_SP8__\"", "\"__NO_INTERRUPTS__\"", "\"__AVR_ERRATA_SKIP__\"", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", "\"__AVR_ISA_RMW__\"", "\"__AVR_SFR_OFFSET__=0x%x\"", "\"__WITH_AVRLIBC__\"", "0", "1", "\"__BUILTIN_AVR_\"", "\"__INT24_MAX__=8388607%s\"", "8", "\"LL\"", "\"L\"", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", "\"__UINT24_MAX__=16777215%s\"", "8", "\"ULL\"", "\"UL\""], "File": "avr-c4", "Func": "avr_cpu_cpp_builtins", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30283, "Length": 468}
{"ground_truth": ["<s>", "void", "avr_cpu_cpp_builtins", "(", "struct", "cpp_reader", "*", "pfile", ")", "{", "builtin_define_std", "(", "\"AVR\"", ")", ";", "if", "(", "avr_arch", "->", "macro", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_ARCH__=%s\"", ",", "avr_arch", "->", "macro", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPD__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPX__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPY__\"", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_RAMPZ__\"", ")", ";", "if", "(", "AVR_HAVE_ELPM", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPM__\"", ")", ";", "if", "(", "AVR_HAVE_ELPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_ELPMX__\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MOVW__\"", ")", ";", "if", "(", "AVR_HAVE_LPMX", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_LPMX__\"", ")", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ASM_ONLY__\"", ")", ";", "if", "(", "AVR_HAVE_MUL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ENHANCED__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_MUL__\"", ")", ";", "}", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_JMP_CALL__\"", ")", ";", "if", "(", "avr_arch", "->", "have_jmp_call", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_MEGA__\"", ")", ";", "if", "(", "AVR_SHORT_CALLS", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_SHORT_CALLS__\"", ")", ";", "if", "(", "AVR_XMEGA", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_XMEGA__\"", ")", ";", "if", "(", "AVR_TINY", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_TINY__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "}", "if", "(", "avr_arch", "->", "flash_pm_offset", ")", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_PM_BASE_ADDRESS__=0x%x\"", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "if", "(", "AVR_HAVE_EIJMP_EICALL", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_EIJMP_EICALL__\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__AVR_3_BYTE_PC__\"", ")", ";", "}", "else", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_2_BYTE_PC__\"", ")", ";", "}", "if", "(", "AVR_HAVE_8BIT_SP", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_8BIT_SP__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_16BIT_SP__\"", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_HAVE_SPH__\"", ")", ";", "else", "cpp_define", "(", "pfile", ",", "\"__AVR_SP8__\"", ")", ";", "if", "(", "TARGET_NO_INTERRUPTS", ")", "cpp_define", "(", "pfile", ",", "\"__NO_INTERRUPTS__\"", ")", ";", "if", "(", "TARGET_SKIP_BUG", ")", "{", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP__\"", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", ")", ";", "}", "if", "(", "TARGET_RMW", ")", "cpp_define", "(", "pfile", ",", "\"__AVR_ISA_RMW__\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__AVR_SFR_OFFSET__=0x%x\"", ",", "avr_arch", "->", "sfr_offset", ")", ";", "cpp_define", "(", "pfile", ",", "\"__WITH_AVRLIBC__\"", ")", ";", "if", "(", "lang_GNU_C", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", "&&", "avr_addr_space_supported_p", "(", "(", "addr_space_t", ")", "i", ")", ")", "{", "const", "char", "*", "name", "=", "avr_addrspace", "[", "i", "]", ".", "name", ";", "char", "*", "Name", "=", "(", "char", "*", ")", "alloca", "(", "1", "+", "strlen", "(", "name", ")", ")", ";", "cpp_define", "(", "pfile", ",", "avr_toupper", "(", "Name", ",", "name", ")", ")", ";", "}", "}", "cpp_define", "(", "pfile", ",", "\"__BUILTIN_AVR_\"", "#", "NAME", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__INT24_MAX__=8388607%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"LL\"", ":", "\"L\"", ")", ";", "cpp_define", "(", "pfile", ",", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", ")", ";", "cpp_define_formatted", "(", "pfile", ",", "\"__UINT24_MAX__=16777215%s\"", ",", "INT_TYPE_SIZE", "==", "8", "?", "\"ULL\"", ":", "\"UL\"", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_CPU_CPP_BUILTINS", "."], "TS_V_token": ["avr", "\"AVR\"", "\"__AVR_ARCH__=%s\"", "\"__AVR_HAVE_RAMPD__\"", "\"__AVR_HAVE_RAMPX__\"", "\"__AVR_HAVE_RAMPY__\"", "\"__AVR_HAVE_RAMPZ__\"", "\"__AVR_HAVE_ELPM__\"", "\"__AVR_HAVE_ELPMX__\"", "\"__AVR_HAVE_MOVW__\"", "\"__AVR_HAVE_LPMX__\"", "\"__AVR_ASM_ONLY__\"", "\"__AVR_ENHANCED__\"", "\"__AVR_HAVE_MUL__\"", "\"__AVR_HAVE_JMP_CALL__\"", "\"__AVR_MEGA__\"", "\"__AVR_SHORT_CALLS__\"", "\"__AVR_XMEGA__\"", "\"__AVR_TINY__\"", "\"__AVR_TINY_PM_BASE_ADDRESS__=0x%x\"", "\"__AVR_PM_BASE_ADDRESS__=0x%x\"", "\"__AVR_HAVE_EIJMP_EICALL__\"", "\"__AVR_3_BYTE_PC__\"", "\"__AVR_2_BYTE_PC__\"", "\"__AVR_HAVE_8BIT_SP__\"", "\"__AVR_HAVE_16BIT_SP__\"", "\"__AVR_HAVE_SPH__\"", "\"__AVR_SP8__\"", "\"__NO_INTERRUPTS__\"", "\"__AVR_ERRATA_SKIP__\"", "\"__AVR_ERRATA_SKIP_JMP_CALL__\"", "\"__AVR_ISA_RMW__\"", "\"__AVR_SFR_OFFSET__=0x%x\"", "\"__WITH_AVRLIBC__\"", "0", "1", "\"__BUILTIN_AVR_\"", "\"__INT24_MAX__=8388607%s\"", "8", "\"LL\"", "\"L\"", "\"__INT24_MIN__=(-__INT24_MAX__-1)\"", "\"__UINT24_MAX__=16777215%s\"", "8", "\"ULL\"", "\"UL\""], "File": "avr-c5", "Func": "avr_cpu_cpp_builtins", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30284, "Length": 500}
{"ground_truth": ["<s>", "void", "avr_register_target_pragmas", "(", "void", ")", "{", "gcc_assert", "(", "ADDR_SPACE_GENERIC", "==", "ADDR_SPACE_RAM", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "ADDR_SPACE_COUNT", ";", "i", "++", ")", "{", "gcc_assert", "(", "i", "==", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "i", ")", ")", "c_register_addr_space", "(", "avr_addrspace", "[", "i", "]", ".", "name", ",", "avr_addrspace", "[", "i", "]", ".", "id", ")", ";", "}", "targetm", ".", "resolve_overloaded_builtin", "=", "avr_resolve_overloaded_builtin", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "REGISTER_TARGET_PRAGMAS", "'", "."], "TS_V_token": ["avr", "0"], "File": "avr-c", "Func": "avr_register_target_pragmas", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30285, "Length": 73}
{"ground_truth": ["<s>", "static", "char", "*", "avr_toupper", "(", "char", "*", "up", ",", "const", "char", "*", "lo", ")", "{", "char", "*", "up0", "=", "up", ";", "for", "(", ";", "*", "lo", ";", "lo", "++", ",", "up", "++", ")", "*", "up", "=", "TOUPPER", "(", "*", "lo", ")", ";", "*", "up", "=", "'\\0'", ";", "return", "up0", ";", "}", "</s>"], "natrual_language": ["Transform", "LO", "into", "uppercase", "and", "write", "the", "result", "to", "UP", ".", "You", "must", "provide", "enough", "space", "for", "UP", ".", "Return", "UP", "."], "TS_V_token": ["avr"], "File": "avr-c", "Func": "avr_toupper", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30286, "Length": 51}
{"ground_truth": ["<s>", "static", "int", "comparator", "(", "const", "void", "*", "va", ",", "const", "void", "*", "vb", ")", "{", "const", "char", "*", "a", "=", "*", "(", "const", "char", "*", "const", "*", ")", "va", ";", "const", "char", "*", "b", "=", "*", "(", "const", "char", "*", "const", "*", ")", "vb", ";", "while", "(", "*", "a", "&&", "*", "b", ")", "{", "if", "(", "ISALPHA", "(", "*", "a", ")", "&&", "ISDIGIT", "(", "*", "b", ")", ")", "return", "-", "1", ";", "if", "(", "ISDIGIT", "(", "*", "a", ")", "&&", "ISALPHA", "(", "*", "b", ")", ")", "return", "1", ";", "if", "(", "*", "a", "!=", "*", "b", ")", "return", "*", "a", "-", "*", "b", ";", "a", "++", ";", "b", "++", ";", "}", "return", "*", "a", "-", "*", "b", ";", "}", "</s>"], "natrual_language": ["Compare", "two", "MCUs", "and", "order", "them", "for", "easy", "lookup", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr-devices2", "Func": "comparator", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30287, "Length": 119}
{"ground_truth": ["<s>", "void", "avr_log_set_avr_log", "(", "void", ")", "{", "bool", "all", "=", "TARGET_ALL_DEBUG", "!=", "0", ";", "if", "(", "all", ")", "avr_log_details", "=", "\"all\"", ";", "if", "(", "all", "||", "avr_log_details", ")", "{", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "3", "+", "strlen", "(", "avr_log_details", ")", ")", ";", "bool", "info", ";", "str", "[", "0", "]", "=", "','", ";", "strcat", "(", "stpcpy", "(", "str", "+", "1", ",", "avr_log_details", ")", ",", "\",\"", ")", ";", "all", "|=", "NULL", "!=", "strstr", "(", "str", ",", "\",all,\"", ")", ";", "info", "=", "NULL", "!=", "strstr", "(", "str", ",", "\",?,\"", ")", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"\\n-mlog=\"", ")", ";", "do", "{", "\\", "avr_log", ".", "S", "=", "(", "all", "||", "NULL", "!=", "strstr", "(", "str", ",", "\",\"", "#", "S", "\",\"", ")", ")", ";", "\\", "if", "(", "info", ")", "\\", "fprintf", "(", "stderr", ",", "#", "S", "\",\"", ")", ";", "\\", "}", "while", "(", "0", ")", "SET_DUMP_DETAIL", "(", "address_cost", ")", ";", "SET_DUMP_DETAIL", "(", "builtin", ")", ";", "SET_DUMP_DETAIL", "(", "constraints", ")", ";", "SET_DUMP_DETAIL", "(", "legitimate_address_p", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_address", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_reload_address", ")", ";", "SET_DUMP_DETAIL", "(", "progmem", ")", ";", "SET_DUMP_DETAIL", "(", "rtx_costs", ")", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"?\\n\\n\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "from", "avr.cc", ":", "avr_option_override", "(", ")", ".", "Parse", "argument", "of", "-mlog=", "and", "set", "respective", "fields", "in", "avr_log", "."], "TS_V_token": ["avr", "0", "\"all\"", "3", "0", "1", "\",\"", "\",all,\"", "\",?,\"", "\"\\n-mlog=\"", "\",\"", "\",\"", "\",\"", "0", "\"?\\n\\n\""], "File": "avr-log2", "Func": "avr_log_set_avr_log", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30288, "Length": 200}
{"ground_truth": ["<s>", "int", "avr_vdump", "(", "FILE", "*", "stream", ",", "const", "char", "*", "caller", ",", "...", ")", "{", "va_list", "ap", ";", "if", "(", "NULL", "==", "stream", "&&", "dump_file", ")", "stream", "=", "dump_file", ";", "va_start", "(", "ap", ",", "caller", ")", ";", "if", "(", "stream", ")", "avr_log_vadump", "(", "stream", ",", "caller", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Wrapper", "for", "avr_log_vadump", ".", "If", "STREAM", "is", "NULL", "we", "are", "called", "by", "avr_dump", ",", "i.e", ".", "output", "to", "dump_file", "if", "available", ".", "The", "2nd", "argument", "is", "__FUNCTION__", ".", "The", "3rd", "argument", "is", "the", "format", "string", "."], "TS_V_token": ["avr", "1"], "File": "avr-log2", "Func": "avr_vdump", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30289, "Length": 59}
{"ground_truth": ["<s>", "void", "avr_log_set_avr_log", "(", "void", ")", "{", "bool", "all", "=", "TARGET_ALL_DEBUG", "!=", "0", ";", "if", "(", "all", ")", "avr_log_details", "=", "\"all\"", ";", "if", "(", "all", "||", "avr_log_details", ")", "{", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "3", "+", "strlen", "(", "avr_log_details", ")", ")", ";", "bool", "info", ";", "str", "[", "0", "]", "=", "','", ";", "strcat", "(", "stpcpy", "(", "str", "+", "1", ",", "avr_log_details", ")", ",", "\",\"", ")", ";", "all", "|=", "strstr", "(", "str", ",", "\",all,\"", ")", "!=", "NULL", ";", "info", "=", "strstr", "(", "str", ",", "\",?,\"", ")", "!=", "NULL", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"\\n-mlog=\"", ")", ";", "do", "{", "\\", "avr_log", ".", "S", "=", "(", "all", "||", "strstr", "(", "str", ",", "\",\"", "#", "S", "\",\"", ")", "!=", "NULL", ")", ";", "\\", "if", "(", "info", ")", "\\", "fprintf", "(", "stderr", ",", "#", "S", "\",\"", ")", ";", "\\", "}", "while", "(", "0", ")", "SET_DUMP_DETAIL", "(", "address_cost", ")", ";", "SET_DUMP_DETAIL", "(", "builtin", ")", ";", "SET_DUMP_DETAIL", "(", "constraints", ")", ";", "SET_DUMP_DETAIL", "(", "insn_addresses", ")", ";", "SET_DUMP_DETAIL", "(", "legitimate_address_p", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_address", ")", ";", "SET_DUMP_DETAIL", "(", "legitimize_reload_address", ")", ";", "SET_DUMP_DETAIL", "(", "progmem", ")", ";", "SET_DUMP_DETAIL", "(", "rtx_costs", ")", ";", "if", "(", "info", ")", "fprintf", "(", "stderr", ",", "\"?\\n\\n\"", ")", ";", "}", "}", "</s>"], "natrual_language": ["Called", "from", "avr.cc", ":", "avr_option_override", "(", ")", ".", "Parse", "argument", "of", "-mlog=", "and", "set", "respective", "fields", "in", "avr_log", "."], "TS_V_token": ["avr", "0", "\"all\"", "3", "0", "1", "\",\"", "\",all,\"", "\",?,\"", "\"\\n-mlog=\"", "\",\"", "\",\"", "\",\"", "0", "\"?\\n\\n\""], "File": "avr-log", "Func": "avr_log_set_avr_log", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30290, "Length": 205}
{"ground_truth": ["<s>", "int", "avr_vdump", "(", "FILE", "*", "stream", ",", "const", "char", "*", "caller", ",", "...", ")", "{", "va_list", "ap", ";", "if", "(", "stream", "==", "NULL", "&&", "dump_file", ")", "stream", "=", "dump_file", ";", "va_start", "(", "ap", ",", "caller", ")", ";", "if", "(", "stream", ")", "avr_log_vadump", "(", "stream", ",", "caller", ",", "ap", ")", ";", "va_end", "(", "ap", ")", ";", "return", "1", ";", "}", "</s>"], "natrual_language": ["Wrapper", "for", "avr_log_vadump", ".", "If", "STREAM", "is", "NULL", "we", "are", "called", "by", "avr_dump", ",", "i.e", ".", "output", "to", "dump_file", "if", "available", ".", "The", "2nd", "argument", "is", "__FUNCTION__", ".", "The", "3rd", "argument", "is", "the", "format", "string", "."], "TS_V_token": ["avr", "1"], "File": "avr-log", "Func": "avr_vdump", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30291, "Length": 59}
{"ground_truth": ["<s>", "void", "avr_init_once", "(", ")", "{", "tmp_reg_rtx", "=", "xmalloc", "(", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "memset", "(", "tmp_reg_rtx", ",", "0", ",", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "PUT_CODE", "(", "tmp_reg_rtx", ",", "REG", ")", ";", "PUT_MODE", "(", "tmp_reg_rtx", ",", "QImode", ")", ";", "XINT", "(", "tmp_reg_rtx", ",", "0", ")", "=", "TMP_REGNO", ";", "zero_reg_rtx", "=", "xmalloc", "(", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "memset", "(", "zero_reg_rtx", ",", "0", ",", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "PUT_CODE", "(", "zero_reg_rtx", ",", "REG", ")", ";", "PUT_MODE", "(", "zero_reg_rtx", ",", "QImode", ")", ";", "XINT", "(", "zero_reg_rtx", ",", "0", ")", "=", "ZERO_REGNO", ";", "ldi_reg_rtx", "=", "xmalloc", "(", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "memset", "(", "ldi_reg_rtx", ",", "0", ",", "sizeof", "(", "struct", "rtx_def", ")", "+", "1", "*", "sizeof", "(", "rtunion", ")", ")", ";", "PUT_CODE", "(", "ldi_reg_rtx", ",", "REG", ")", ";", "PUT_MODE", "(", "ldi_reg_rtx", ",", "QImode", ")", ";", "XINT", "(", "ldi_reg_rtx", ",", "0", ")", "=", "LDI_REG_REGNO", ";", "}", "</s>"], "natrual_language": ["Initialize", "TMP_REG_RTX", "and", "ZERO_REG_RTX"], "TS_V_token": ["avr", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1", "0"], "File": "avr2", "Func": "avr_init_once", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30292, "Length": 189}
{"ground_truth": ["<s>", "avr_regno_mode_code_ok_for_base_p", "(", "num", ",", "mode", ",", "as", ",", "outer_code", ",", "index_code", ")", "{", "ARG_POINTER_REGNUM", ",", "STACK_POINTER_REGNUM", "}", ",", "\\", "{", "ARG_POINTER_REGNUM", ",", "FRAME_POINTER_REGNUM", "}", ",", "\\", "{", "FRAME_POINTER_REGNUM", ",", "STACK_POINTER_REGNUM", "}", ",", "\\", "{", "FRAME_POINTER_REGNUM", "+", "1", ",", "STACK_POINTER_REGNUM", "+", "1", "}", "</s>"], "natrual_language": ["Implement", "`", "REGNO_MODE_CODE_OK_FOR_BASE_P", "'", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr2", "Func": "avr_regno_mode_code_ok_for_base_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30293, "Length": 42}
{"ground_truth": ["<s>", "int", "avr_ret_register", "(", ")", "{", "return", "24", ";", "}", "</s>"], "natrual_language": ["Returns", "register", "number", "for", "function", "return", "value", "."], "TS_V_token": ["avr", "24"], "File": "avr2", "Func": "avr_ret_register", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30294, "Length": 9}
{"ground_truth": ["<s>", "int", "frame_pointer_required_p", "(", ")", "{", "return", "(", "current_function_calls_alloca", "||", "current_function_args_info", ".", "nregs", "==", "0", "||", "current_function_varargs", "||", "get_frame_size", "(", ")", ">", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "frame", "pointer", "for", "current", "function", "required", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr2", "Func": "frame_pointer_required_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30295, "Length": 25}
{"ground_truth": ["<s>", "void", "order_regs_for_local_alloc", "(", ")", "{", "unsigned", "int", "i", ";", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "order_1", ":", "TARGET_ORDER_2", "?", "order_2", ":", "order_0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>"], "natrual_language": ["Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "."], "TS_V_token": ["avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0"], "File": "avr2", "Func": "order_regs_for_local_alloc", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30296, "Length": 296}
{"ground_truth": ["<s>", "static", "int", "sequent_regs_live", "(", ")", "{", "int", "reg", ";", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "18", ";", "++", "reg", ")", "{", "if", "(", "!", "call_used_regs", "[", "reg", "]", ")", "{", "if", "(", "regs_ever_live", "[", "reg", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "regs_ever_live", "[", "REG_Y", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "regs_ever_live", "[", "REG_Y", "+", "1", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>"], "natrual_language": ["This", "function", "checks", "sequence", "of", "live", "registers"], "TS_V_token": ["avr", "0", "0", "0", "18", "0", "0", "1", "0", "2", "2", "0"], "File": "avr2", "Func": "sequent_regs_live", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30297, "Length": 136}
{"ground_truth": ["<s>", "const", "char", "*", "ashrqi3_out", "(", "rtx", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "1", ":", "*", "len", "=", "1", ";", "return", "AS1", "(", "asr", ",", "%", "0", ")", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "4", ":", "*", "len", "=", "4", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "5", ":", "*", "len", "=", "5", ";", "return", "(", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", "CR_TAB", "AS1", "(", "asr", ",", "%", "0", ")", ")", ";", "case", "6", ":", "*", "len", "=", "4", ";", "return", "(", "AS2", "(", "bst", ",", "%", "0", ",", "6", ")", "CR_TAB", "AS1", "(", "lsl", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "sbc", ",", "%", "0", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "bld", ",", "%", "0", ",", "0", ")", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "case", "7", ":", "*", "len", "=", "2", ";", "return", "(", "AS1", "(", "lsl", ",", "%", "0", ")", "CR_TAB", "AS2", "(", "sbc", ",", "%", "0", ",", "%", "0", ")", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "AS1", "(", "asr", ",", "%", "0", ")", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "arithmetic", "shift", "right", "(", "(", "signed", "char", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "1", "1", "0", "2", "2", "0", "0", "3", "3", "0", "0", "0", "4", "4", "0", "0", "0", "0", "5", "5", "0", "0", "0", "0", "0", "6", "4", "0", "6", "0", "0", "0", "0", "0", "2", "8", "7", "2", "0", "0", "0", "2", "\"internal compiler error.  Incorrect shift:\"", "0", "1", "\"\""], "File": "avr3", "Func": "ashrqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30298, "Length": 367}
{"ground_truth": ["<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SUBREG", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "61", ")", "return", "18", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "avr_io_address_p", "(", "x", ",", "1", ")", ")", "return", "2", ";", "return", "4", ";", "}", "return", "4", ";", "}", "</s>"], "natrual_language": ["Calculate", "the", "cost", "of", "a", "memory", "address", "."], "TS_V_token": ["avr", "1", "0", "0", "1", "61", "18", "1", "2", "4", "4"], "File": "avr3", "Func": "avr_address_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30299, "Length": 96}
{"ground_truth": ["<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "(", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", ")", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", ")", "{", "fputs", "(", "\"\\t.word\\tpm(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>"], "natrual_language": ["Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "."], "TS_V_token": ["avr", "\"\\t.word\\tpm(\"", "\")\\n\""], "File": "avr3", "Func": "avr_assemble_integer", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30300, "Length": 85}
{"ground_truth": ["<s>", "static", "void", "avr_file_end", "(", "void", ")", "{", "fputs", "(", "\"/* File \"", ",", "asm_out_file", ")", ";", "output_quoted_string", "(", "asm_out_file", ",", "main_input_filename", ")", ";", "fprintf", "(", "asm_out_file", ",", "\": code %4d = 0x%04x (%4d), prologues %3d, epilogues %3d */\\n\"", ",", "commands_in_file", ",", "commands_in_file", ",", "commands_in_file", "-", "commands_in_prologues", "-", "commands_in_epilogues", ",", "commands_in_prologues", ",", "commands_in_epilogues", ")", ";", "}", "</s>"], "natrual_language": ["Outputs", "to", "the", "stdio", "stream", "FILE", "some", "appropriate", "text", "to", "go", "at", "the", "end", "of", "an", "assembler", "file", "."], "TS_V_token": ["avr", "\"/* File \"", "\": code %4d = 0x%04x (%4d), prologues %3d, epilogues %3d */\\n\""], "File": "avr3", "Func": "avr_file_end", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30301, "Length": 43}
{"ground_truth": ["<s>", "static", "void", "avr_file_start", "(", "void", ")", "{", "if", "(", "avr_asm_only_p", ")", "error", "(", "\"MCU %qs supported for assembler only\"", ",", "avr_mcu_name", ")", ";", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.arch %s\\n\"", ",", "avr_mcu_name", ")", ";", "fputs", "(", "\"__SREG__ = 0x3f\\n\"", "\"__SP_H__ = 0x3e\\n\"", "\"__SP_L__ = 0x3d\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"__tmp_reg__ = 0\\n\"", "\"__zero_reg__ = 1\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.global __do_copy_data\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.global __do_clear_bss\\n\"", ",", "asm_out_file", ")", ";", "commands_in_file", "=", "0", ";", "commands_in_prologues", "=", "0", ";", "commands_in_epilogues", "=", "0", ";", "}", "</s>"], "natrual_language": ["Outputs", "some", "appropriate", "text", "to", "go", "at", "the", "start", "of", "an", "assembler", "file", "."], "TS_V_token": ["avr", "\"MCU %qs supported for assembler only\"", "\"\\t.arch %s\\n\"", "\"__SREG__ = 0x3f\\n\"", "\"__SP_H__ = 0x3e\\n\"", "\"__SP_L__ = 0x3d\\n\"", "\"__tmp_reg__ = 0\\n\"", "\"__zero_reg__ = 1\\n\"", "\"\\t.global __do_copy_data\\n\"", "\"\\t.global __do_clear_bss\\n\"", "0", "0", "0"], "File": "avr3", "Func": "avr_file_start", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30302, "Length": 75}
{"ground_truth": ["<s>", "rtx", "avr_function_value", "(", "tree", "type", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "offs", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "!=", "BLKmode", ")", "return", "avr_libcall_value", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "offs", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "if", "(", "offs", ">", "2", "&&", "offs", "<", "GET_MODE_SIZE", "(", "SImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "else", "if", "(", "offs", ">", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offs", "<", "GET_MODE_SIZE", "(", "DImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "return", "gen_rtx_REG", "(", "BLKmode", ",", "RET_REGISTER", "+", "2", "-", "offs", ")", ";", "}", "</s>"], "natrual_language": ["Create", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "a", "value", "of", "data", "type", "VALTYPE", "."], "TS_V_token": ["avr", "2", "2", "2", "2"], "File": "avr3", "Func": "avr_function_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30303, "Length": 107}
{"ground_truth": ["<s>", "static", "tree", "avr_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "{", "const", "char", "*", "func_name", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "*", "node", ")", ")", ";", "const", "char", "*", "attr", "=", "IDENTIFIER_POINTER", "(", "name", ")", ";", "if", "(", "strncmp", "(", "attr", ",", "\"interrupt\"", ",", "strlen", "(", "\"interrupt\"", ")", ")", "==", "0", ")", "{", "if", "(", "strncmp", "(", "func_name", ",", "\"__vector\"", ",", "strlen", "(", "\"__vector\"", ")", ")", "!=", "0", ")", "{", "warning", "(", "0", ",", "\"%qs appears to be a misspelled interrupt handler\"", ",", "func_name", ")", ";", "}", "}", "else", "if", "(", "strncmp", "(", "attr", ",", "\"signal\"", ",", "strlen", "(", "\"signal\"", ")", ")", "==", "0", ")", "{", "if", "(", "strncmp", "(", "func_name", ",", "\"__vector\"", ",", "strlen", "(", "\"__vector\"", ")", ")", "!=", "0", ")", "{", "warning", "(", "0", ",", "\"%qs appears to be a misspelled signal handler\"", ",", "func_name", ")", ";", "}", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["avr", "\"%qs attribute only applies to functions\"", "\"interrupt\"", "\"interrupt\"", "0", "\"__vector\"", "\"__vector\"", "0", "0", "\"%qs appears to be a misspelled interrupt handler\"", "\"signal\"", "\"signal\"", "0", "\"__vector\"", "\"__vector\"", "0", "0", "\"%qs appears to be a misspelled signal handler\""], "File": "avr3", "Func": "avr_handle_fndecl_attribute", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30304, "Length": 175}
{"ground_truth": ["<s>", "static", "tree", "avr_handle_progmem_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "TYPE_DECL", ")", "{", "tree", "type", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "tree", "attr", "=", "tree_cons", "(", "name", ",", "args", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "tree", "newtype", "=", "build_type_attribute_variant", "(", "type", ",", "attr", ")", ";", "TYPE_MAIN_VARIANT", "(", "newtype", ")", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "TREE_TYPE", "(", "*", "node", ")", "=", "newtype", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_STATIC", "(", "*", "node", ")", "||", "DECL_EXTERNAL", "(", "*", "node", ")", ")", "{", "if", "(", "DECL_INITIAL", "(", "*", "node", ")", "==", "NULL_TREE", "&&", "!", "DECL_EXTERNAL", "(", "*", "node", ")", ")", "{", "warning", "(", "0", ",", "\"only initialized variables can be placed into \"", "\"program memory area\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute ignored\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "a", "``", "progmem", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["avr", "0", "\"only initialized variables can be placed into \"", "\"program memory area\"", "\"%qs attribute ignored\""], "File": "avr3", "Func": "avr_handle_progmem_attribute", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30305, "Length": 176}
{"ground_truth": ["<s>", "int", "avr_hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_Y", "&&", "mode", "==", "Pmode", ")", "return", "1", ";", "if", "(", "regno", "<=", "(", "REG_Y", "+", "1", ")", "&&", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ")", ">=", "(", "REG_Y", "+", "1", ")", ")", "return", "0", ";", "if", "(", "mode", "==", "QImode", ")", "return", "1", ";", "if", "(", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "FIRST_PSEUDO_REGISTER", ")", "return", "0", ";", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "a", "value", "of", "mode", "MODE", "can", "be", "stored", "starting", "with", "hard", "register", "number", "REGNO", ".", "On", "the", "enhanced", "core", ",", "anything", "larger", "than", "1", "byte", "must", "start", "in", "even", "numbered", "register", "for", "``", "movw", "''", "to", "work", "(", "this", "way", "we", "do", "n't", "have", "to", "check", "for", "odd", "registers", "everywhere", ")", "."], "TS_V_token": ["avr", "1", "1", "1", "0", "1", "0", "1"], "File": "avr3", "Func": "avr_hard_regno_mode_ok", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30306, "Length": 84}
{"ground_truth": ["<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "static", "const", "char", "dsec", "[", "]", "=", "\".progmem.data\"", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"section\"", ")", ",", "build_tree_list", "(", "NULL", ",", "build_string", "(", "strlen", "(", "dsec", ")", ",", "dsec", ")", ")", ",", "*", "attributes", ")", ";", "TREE_READONLY", "(", "node", ")", "=", "1", ";", "}", "}", "</s>"], "natrual_language": ["Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "."], "TS_V_token": ["avr", "\".progmem.data\"", "\"section\"", "1"], "File": "avr3", "Func": "avr_insert_attributes", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30307, "Length": 89}
{"ground_truth": ["<s>", "int", "avr_io_address_p", "(", "rtx", "x", ",", "int", "size", ")", "{", "return", "(", "optimize", ">", "0", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "x", ")", ">=", "0x20", "&&", "INTVAL", "(", "x", ")", "<=", "0x60", "-", "size", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "X", "is", "a", "valid", "address", "for", "an", "I/O", "register", "of", "size", "SIZE", "(", "1", "or", "2", ")", ".", "Used", "for", "lds/sts", "-", ">", "in/out", "optimization", ".", "Add", "0x20", "to", "SIZE", "to", "check", "for", "the", "lower", "half", "of", "I/O", "space", "(", "for", "cbi/sbi/sbic/sbis", ")", "."], "TS_V_token": ["avr", "0", "0x20", "0x60"], "File": "avr3", "Func": "avr_io_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30308, "Length": 41}
{"ground_truth": ["<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_MODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "-", "63", "<=", "jump_distance", "&&", "jump_distance", "<=", "62", ")", "return", "1", ";", "else", "if", "(", "-", "2046", "<=", "jump_distance", "&&", "jump_distance", "<=", "2045", ")", "return", "2", ";", "else", "if", "(", "AVR_MEGA", ")", "return", "3", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "."], "TS_V_token": ["avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2"], "File": "avr3", "Func": "avr_jump_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30309, "Length": 94}
{"ground_truth": ["<s>", "rtx", "avr_libcall_value", "(", "enum", "machine_mode", "mode", ")", "{", "int", "offs", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "return", "gen_rtx_REG", "(", "mode", ",", "RET_REGISTER", "+", "2", "-", "offs", ")", ";", "}", "</s>"], "natrual_language": ["Ceate", "an", "RTX", "representing", "the", "place", "where", "a", "library", "function", "returns", "a", "value", "of", "mode", "MODE", "."], "TS_V_token": ["avr", "2", "2", "2"], "File": "avr3", "Func": "avr_libcall_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30310, "Length": 39}
{"ground_truth": ["<s>", "static", "int", "avr_naked_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_DECL", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "FUNC", "is", "a", "naked", "function", "."], "TS_V_token": ["avr", "\"naked\""], "File": "avr3", "Func": "avr_naked_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30311, "Length": 39}
{"ground_truth": ["<s>", "static", "int", "avr_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "1", ")", "&", "~", "1", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "number", "of", "registers", "to", "allocate", "for", "a", "function", "argument", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr3", "Func": "avr_num_arg_regs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30312, "Length": 47}
{"ground_truth": ["<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "code", ",", "outer", ",", "&", "total", ")", ";", "return", "total", ";", "}", "</s>"], "natrual_language": ["Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr3", "Func": "avr_operand_rtx_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30313, "Length": 82}
{"ground_truth": ["<s>", "void", "avr_output_addr_vec_elt", "(", "FILE", "*", "stream", ",", "int", "value", ")", "{", "progmem_section", "(", ")", ";", "if", "(", "AVR_MEGA", ")", "fprintf", "(", "stream", ",", "\"\\t.word pm(.L%d)\\n\"", ",", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\trjmp .L%d\\n\"", ",", "value", ")", ";", "jump_tables_size", "++", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "`", "ASM_OUTPUT_ADDR_VEC_ELT", "'", "."], "TS_V_token": ["avr", "\"\\t.word pm(.L%d)\\n\"", "\"\\trjmp .L%d\\n\""], "File": "avr3", "Func": "avr_output_addr_vec_elt", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30314, "Length": 42}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_sbxx_branch", "(", "rtx", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "comp", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "int", "long_jump", "=", "(", "get_attr_length", "(", "insn", ")", ">=", "4", ")", ";", "int", "reverse", "=", "long_jump", "||", "jump_over_one_insn_p", "(", "insn", ",", "operands", "[", "3", "]", ")", ";", "if", "(", "comp", "==", "GE", ")", "comp", "=", "EQ", ";", "else", "if", "(", "comp", "==", "LT", ")", "comp", "=", "NE", ";", "if", "(", "reverse", ")", "comp", "=", "reverse_condition", "(", "comp", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "1", "]", ")", "<", "0x40", ")", "{", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "AS2", "(", "sbis", ",", "%", "1", "-", "0x20", ",", "%", "2", ")", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "AS2", "(", "sbic", ",", "%", "1", "-", "0x20", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "AS2", "(", "in", ",", "__tmp_reg__", ",", "%", "1", "-", "0x20", ")", ",", "operands", ")", ";", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "AS2", "(", "sbrs", ",", "__tmp_reg__", ",", "%", "2", ")", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "AS2", "(", "sbrc", ",", "__tmp_reg__", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "}", "else", "{", "if", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", "==", "QImode", ")", "{", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "AS2", "(", "sbrs", ",", "%", "1", ",", "%", "2", ")", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "AS2", "(", "sbrc", ",", "%", "1", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "else", "{", "static", "char", "buf", "[", "]", "=", "\"sbrc %A1,0\"", ";", "int", "bit_nr", "=", "exact_log2", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "&", "GET_MODE_MASK", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", ")", ";", "buf", "[", "3", "]", "=", "(", "comp", "==", "EQ", ")", "?", "'s'", ":", "'c'", ";", "buf", "[", "6", "]", "=", "'A'", "+", "(", "bit_nr", ">>", "3", ")", ";", "buf", "[", "9", "]", "=", "'0'", "+", "(", "bit_nr", "&", "7", ")", ";", "output_asm_insn", "(", "buf", ",", "operands", ")", ";", "}", "}", "if", "(", "long_jump", ")", "return", "(", "AS1", "(", "rjmp", ",", ".", "+", "4", ")", "CR_TAB", "AS1", "(", "jmp", ",", "%", "3", ")", ")", ";", "if", "(", "!", "reverse", ")", "return", "AS1", "(", "rjmp", ",", "%", "3", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "a", "branch", "that", "tests", "a", "single", "bit", "of", "a", "register", "(", "QI", ",", "HI", "or", "SImode", ")", "or", "memory", "location", "in", "the", "I/O", "space", "(", "QImode", "only", ")", ".", "Operand", "0", ":", "comparison", "operator", "(", "must", "be", "EQ", "or", "NE", ",", "compare", "bit", "to", "zero", ")", ".", "Operand", "1", ":", "register", "operand", "to", "test", ",", "or", "CONST_INT", "memory", "address", ".", "Operand", "2", ":", "bit", "number", "(", "for", "QImode", "operand", ")", "or", "mask", "(", "HImode", ",", "SImode", ")", ".", "Operand", "3", ":", "label", "to", "jump", "to", "if", "the", "test", "is", "true", "."], "TS_V_token": ["avr", "0", "4", "3", "1", "1", "0x40", "1", "0x20", "2", "1", "0x20", "2", "1", "0x20", "2", "2", "1", "1", "2", "1", "2", "\"sbrc %A1,0\"", "2", "1", "3", "6", "3", "9", "7", "4", "3", "3", "\"\""], "File": "avr3", "Func": "avr_out_sbxx_branch", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30315, "Length": 395}
{"ground_truth": ["<s>", "int", "avr_peep2_scratch_safe", "(", "rtx", "scratch", ")", "{", "if", "(", "(", "interrupt_function_p", "(", "current_function_decl", ")", "||", "signal_function_p", "(", "current_function_decl", ")", ")", "&&", "leaf_function_p", "(", ")", ")", "{", "int", "first_reg", "=", "true_regnum", "(", "scratch", ")", ";", "int", "last_reg", "=", "first_reg", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "scratch", ")", ")", "-", "1", ";", "int", "reg", ";", "for", "(", "reg", "=", "first_reg", ";", "reg", "<=", "last_reg", ";", "reg", "++", ")", "{", "if", "(", "!", "regs_ever_live", "[", "reg", "]", ")", "return", "0", ";", "}", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "SCRATCH", "are", "safe", "to", "be", "allocated", "as", "a", "scratch", "registers", "(", "for", "a", "define_peephole2", ")", "in", "the", "current", "function", "."], "TS_V_token": ["avr", "1", "0", "1"], "File": "avr3", "Func": "avr_peep2_scratch_safe", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30316, "Length": 83}
{"ground_truth": ["<s>", "int", "avr_progmem_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "0", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "attributes", ")", ")", "return", "1", ";", "a", "=", "decl", ";", "do", "a", "=", "TREE_TYPE", "(", "a", ")", ";", "while", "(", "TREE_CODE", "(", "a", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "a", "==", "error_mark_node", ")", "return", "0", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "TYPE_ATTRIBUTES", "(", "a", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Look", "for", "attribute", "`", "progmem", "'", "in", "DECL", "if", "found", "return", "1", ",", "otherwise", "0", "."], "TS_V_token": ["avr", "0", "\"progmem\"", "1", "0", "\"progmem\"", "1", "0"], "File": "avr3", "Func": "avr_progmem_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30317, "Length": 91}
{"ground_truth": ["<s>", "enum", "reg_class", "avr_regno_reg_class", "(", "int", "r", ")", "{", "if", "(", "r", "<=", "33", ")", "return", "reg_class_tab", "[", "r", "]", ";", "return", "ALL_REGS", ";", "}", "</s>"], "natrual_language": ["Return", "register", "class", "for", "register", "R"], "TS_V_token": ["avr", "33"], "File": "avr3", "Func": "avr_regno_reg_class", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30318, "Length": 24}
{"ground_truth": ["<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "reg", ",", "count", ";", "int", "int_or_sig_p", "=", "(", "interrupt_function_p", "(", "current_function_decl", ")", "||", "signal_function_p", "(", "current_function_decl", ")", ")", ";", "int", "leaf_func_p", "=", "leaf_function_p", "(", ")", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "return", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "leaf_func_p", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "regs_ever_live", "[", "reg", "]", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "(", "REG_Y", "+", "1", ")", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>"], "natrual_language": ["Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "."], "TS_V_token": ["avr", "0", "0", "0", "32", "1"], "File": "avr3", "Func": "avr_regs_to_save", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30319, "Length": 155}
{"ground_truth": ["<s>", "enum", "reg_class", "avr_reg_class_from_letter", "(", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'t'", ":", "return", "R0_REG", ";", "case", "'b'", ":", "return", "BASE_POINTER_REGS", ";", "case", "'e'", ":", "return", "POINTER_REGS", ";", "case", "'w'", ":", "return", "ADDW_REGS", ";", "case", "'d'", ":", "return", "LD_REGS", ";", "case", "'l'", ":", "return", "NO_LD_REGS", ";", "case", "'a'", ":", "return", "SIMPLE_LD_REGS", ";", "case", "'x'", ":", "return", "POINTER_X_REGS", ";", "case", "'y'", ":", "return", "POINTER_Y_REGS", ";", "case", "'z'", ":", "return", "POINTER_Z_REGS", ";", "case", "'q'", ":", "return", "STACK_REG", ";", "default", ":", "break", ";", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["A", "C", "expression", "which", "defines", "the", "machine-dependent", "operand", "constraint", "letters", "for", "register", "classes", ".", "If", "C", "is", "such", "a", "letter", ",", "the", "value", "should", "be", "the", "register", "class", "corresponding", "to", "it", ".", "Otherwise", ",", "the", "value", "should", "be", "`", "NO_REGS", "'", ".", "The", "register", "letter", "`", "r", "'", ",", "corresponding", "to", "class", "`", "GENERAL_REGS", "'", ",", "will", "not", "be", "passed", "to", "this", "macro", ";", "you", "do", "not", "need", "to", "handle", "it", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "avr_reg_class_from_letter", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30320, "Length": 88}
{"ground_truth": ["<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx", "insn", ",", "pattern", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "||", "!", "single_set", "(", "insn", ")", ")", "continue", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", "&&", "SET_DEST", "(", "pattern", ")", "==", "cc0_rtx", "&&", "compare_diff_p", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "COMPARE", ")", "{", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "GET_CODE", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "else", "if", "(", "true_regnum", "(", "SET_SRC", "(", "pattern", ")", ")", ">=", "0", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "SET_SRC", "(", "pattern", ")", "=", "gen_rtx_NEG", "(", "GET_MODE", "(", "SET_SRC", "(", "pattern", ")", ")", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "</s>"], "natrual_language": ["This", "function", "optimizes", "conditional", "jumps", "."], "TS_V_token": ["avr", "0", "0", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1", "0", "0", "1", "1"], "File": "avr3", "Func": "avr_reorg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30321, "Length": 503}
{"ground_truth": ["<s>", "static", "bool", "avr_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "8", ")", ";", "}", "else", "return", "false", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "."], "TS_V_token": ["avr", "1", "8"], "File": "avr3", "Func": "avr_return_in_memory", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30322, "Length": 48}
{"ground_truth": ["<s>", "int", "avr_ret_register", "(", "void", ")", "{", "return", "24", ";", "}", "</s>"], "natrual_language": ["Returns", "register", "number", "for", "function", "return", "value", "."], "TS_V_token": ["avr", "24"], "File": "avr3", "Func": "avr_ret_register", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30323, "Length": 10}
{"ground_truth": ["<s>", "static", "unsigned", "int", "avr_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "strncmp", "(", "name", ",", "\".noinit\"", ",", "7", ")", "==", "0", ")", "{", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "NULL_TREE", ")", "flags", "|=", "SECTION_BSS", ";", "else", "warning", "(", "0", ",", "\"only uninitialized variables can be placed in the \"", "\".noinit section\"", ")", ";", "}", "return", "flags", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_SECTION_TYPE_FLAGS", "'", "."], "TS_V_token": ["avr", "\".noinit\"", "7", "0", "0", "\"only uninitialized variables can be placed in the \"", "\".noinit section\""], "File": "avr3", "Func": "avr_section_type_flags", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30324, "Length": 80}
{"ground_truth": ["<s>", "int", "avr_simple_epilogue", "(", "void", ")", "{", "return", "(", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "avr_regs_to_save", "(", "NULL", ")", "==", "0", "&&", "!", "interrupt_function_p", "(", "current_function_decl", ")", "&&", "!", "signal_function_p", "(", "current_function_decl", ")", "&&", "!", "avr_naked_function_p", "(", "current_function_decl", ")", "&&", "!", "MAIN_NAME_P", "(", "DECL_NAME", "(", "current_function_decl", ")", ")", "&&", "!", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "the", "function", "epilogue", "is", "just", "a", "single", "``", "ret", "''", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr3", "Func": "avr_simple_epilogue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30325, "Length": 59}
{"ground_truth": ["<s>", "int", "avr_simplify_comparison_p", "(", "enum", "machine_mode", "mode", ",", "RTX_CODE", "operator", ",", "rtx", "x", ")", "{", "unsigned", "int", "max", "=", "(", "mode", "==", "QImode", "?", "0xff", ":", "mode", "==", "HImode", "?", "0xffff", ":", "mode", "==", "SImode", "?", "0xffffffff", ":", "0", ")", ";", "if", "(", "max", "&&", "operator", "&&", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "if", "(", "unsigned_condition", "(", "operator", ")", "!=", "operator", ")", "max", ">>=", "1", ";", "if", "(", "max", "!=", "(", "INTVAL", "(", "x", ")", "&", "max", ")", "&&", "INTVAL", "(", "x", ")", "!=", "0xff", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "0", "if", "undefined", ",", "1", "if", "always", "true", "or", "always", "false", "."], "TS_V_token": ["avr", "0xff", "0xffff", "0xffffffff", "0", "1", "0xff", "1", "0"], "File": "avr3", "Func": "avr_simplify_comparison_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30326, "Length": 95}
{"ground_truth": ["<s>", "int", "byte_immediate_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op", ")", "<=", "0xff", "&&", "INTVAL", "(", "op", ")", ">=", "0", ")", ";", "}", "</s>"], "natrual_language": ["Predicate", "function", "for", "immediate", "operand", "which", "fits", "to", "byte", "(", "8bit", ")"], "TS_V_token": ["avr", "0xff", "0"], "File": "avr3", "Func": "byte_immediate_operand", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30327, "Length": 37}
{"ground_truth": ["<s>", "int", "call_insn_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "rtx", "inside", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "register_operand", "(", "inside", ",", "Pmode", ")", ")", "return", "1", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "inside", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Test", "for", "a", "valid", "operand", "for", "a", "call", "instruction", ".", "Do", "n't", "allow", "the", "arg", "pointer", "register", "or", "virtual", "regs", "since", "they", "may", "change", "into", "reg", "+", "const", ",", "which", "the", "patterns", "ca", "n't", "handle", "yet", "."], "TS_V_token": ["avr", "0", "1", "1", "0"], "File": "avr3", "Func": "call_insn_operand", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30328, "Length": 59}
{"ground_truth": ["<s>", "enum", "reg_class", "class_likely_spilled_p", "(", "int", "c", ")", "{", "return", "(", "c", "!=", "ALL_REGS", "&&", "c", "!=", "ADDW_REGS", ")", ";", "}", "</s>"], "natrual_language": ["Return", "value", "is", "nonzero", "if", "pseudos", "that", "have", "been", "assigned", "to", "registers", "of", "class", "CLASS", "would", "likely", "be", "spilled", "because", "registers", "of", "CLASS", "are", "needed", "for", "spill", "registers", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "class_likely_spilled_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30329, "Length": 20}
{"ground_truth": ["<s>", "int", "class_max_nregs", "(", "enum", "reg_class", "class", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["A", "C", "expression", "for", "the", "maximum", "number", "of", "consecutive", "registers", "of", "class", "CLASS", "needed", "to", "hold", "a", "value", "of", "mode", "MODE", "."], "TS_V_token": ["avr", "1"], "File": "avr3", "Func": "class_max_nregs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30330, "Length": 30}
{"ground_truth": ["<s>", "static", "RTX_CODE", "compare_condition", "(", "rtx", "insn", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "RTX_CODE", "cond", "=", "UNKNOWN", ";", "if", "(", "next", "&&", "GET_CODE", "(", "next", ")", "==", "JUMP_INSN", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "cond", "=", "GET_CODE", "(", "t", ")", ";", "}", "return", "cond", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "condition", "of", "compare", "insn", "INSN", ",", "or", "UNKNOWN", "."], "TS_V_token": ["avr", "0"], "File": "avr3", "Func": "compare_condition", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30331, "Length": 71}
{"ground_truth": ["<s>", "int", "compare_diff_p", "(", "rtx", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GT", "||", "cond", "==", "GTU", "||", "cond", "==", "LE", "||", "cond", "==", "LEU", ")", "?", "cond", ":", "0", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "the", "next", "insn", "is", "a", "JUMP_INSN", "with", "a", "condition", "that", "needs", "to", "be", "swapped", "(", "GT", ",", "GTU", ",", "LE", ",", "LEU", ")", "."], "TS_V_token": ["avr", "0"], "File": "avr3", "Func": "compare_diff_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30332, "Length": 39}
{"ground_truth": ["<s>", "int", "compare_eq_p", "(", "rtx", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "EQ", "||", "cond", "==", "NE", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "INSN", "is", "a", "compare", "insn", "with", "the", "EQ", "or", "NE", "condition", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "compare_eq_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30333, "Length": 27}
{"ground_truth": ["<s>", "static", "int", "compare_sign_p", "(", "rtx", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GE", "||", "cond", "==", "LT", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "INSN", "is", "a", "tst", "insn", "that", "only", "tests", "the", "sign", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "compare_sign_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30334, "Length": 28}
{"ground_truth": ["<s>", "static", "const", "char", "*", "cond_string", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "\"ne\"", ";", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "GE", ":", "if", "(", "cc_prev_status", ".", "flags", "&", "CC_OVERFLOW_UNUSABLE", ")", "return", "\"pl\"", ";", "else", "return", "\"ge\"", ";", "case", "LT", ":", "if", "(", "cc_prev_status", ".", "flags", "&", "CC_OVERFLOW_UNUSABLE", ")", "return", "\"mi\"", ";", "else", "return", "\"lt\"", ";", "case", "GEU", ":", "return", "\"sh\"", ";", "case", "LTU", ":", "return", "\"lo\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Return", "assembly", "language", "string", "which", "identifies", "a", "comparison", "type", "."], "TS_V_token": ["avr", "\"ne\"", "\"eq\"", "\"pl\"", "\"ge\"", "\"mi\"", "\"lt\"", "\"sh\"", "\"lo\""], "File": "avr3", "Func": "cond_string", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30335, "Length": 84}
{"ground_truth": ["<s>", "int", "const_int_pow2_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "d", "=", "INTVAL", "(", "x", ")", ";", "HOST_WIDE_INT", "abs_d", "=", "(", "d", ">=", "0", ")", "?", "d", ":", "-", "d", ";", "return", "exact_log2", "(", "abs_d", ")", "+", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "(", "bit", "number", "+", "1", ")", "if", "X", ",", "or", "-X", ",", "is", "a", "constant", "power", "of", "2", "."], "TS_V_token": ["avr", "0", "1", "0"], "File": "avr3", "Func": "const_int_pow2_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30336, "Length": 52}
{"ground_truth": ["<s>", "int", "extra_constraint", "(", "rtx", "x", ",", "int", "c", ")", "{", "if", "(", "c", "==", "'Q'", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "(", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", ")", ",", "reload_completed", ",", "reload_in_progress", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "(", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", ")", ",", "reload_completed", ",", "reload_in_progress", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "1", ";", "else", "if", "(", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", ")", "return", "1", ";", "else", "if", "(", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["EXTRA_CONSTRAINT", "helper"], "TS_V_token": ["avr", "0", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", "0", "0", "0", "0", "1", "0", "1", "0", "0", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", "1", "1", "1", "0"], "File": "avr3", "Func": "extra_constraint", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30337, "Length": 233}
{"ground_truth": ["<s>", "void", "final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "int", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "TARGET_INSN_SIZE_DUMP", "||", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"/*DEBUG: 0x%x\\t\\t%d\\t%d */\\n\"", ",", "INSN_ADDRESSES", "(", "uid", ")", ",", "INSN_ADDRESSES", "(", "uid", ")", "-", "last_insn_address", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "INSN", ")", ")", ";", "}", "last_insn_address", "=", "INSN_ADDRESSES", "(", "uid", ")", ";", "}", "</s>"], "natrual_language": ["If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "."], "TS_V_token": ["avr", "\"/*DEBUG: 0x%x\\t\\t%d\\t%d */\\n\""], "File": "avr3", "Func": "final_prescan_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30338, "Length": 69}
{"ground_truth": ["<s>", "int", "frame_pointer_required_p", "(", "void", ")", "{", "return", "(", "current_function_calls_alloca", "||", "current_function_args_info", ".", "nregs", "==", "0", "||", "get_frame_size", "(", ")", ">", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "frame", "pointer", "for", "current", "function", "required", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr3", "Func": "frame_pointer_required_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30339, "Length": 24}
{"ground_truth": ["<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "function_arg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30340, "Length": 57}
{"ground_truth": ["<s>", "void", "function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>"], "natrual_language": ["Handle", "the", "FUNCTION_ARG_ADVANCE", "macro", ".", "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr3", "Func": "function_arg_advance", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30341, "Length": 64}
{"ground_truth": ["<s>", "int", "function_arg_regno_p", "(", "int", "r", ")", "{", "return", "(", "r", ">=", "8", "&&", "r", "<=", "25", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "when", "register", "may", "be", "used", "to", "pass", "function", "parameters", "."], "TS_V_token": ["avr", "8", "25"], "File": "avr3", "Func": "function_arg_regno_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30342, "Length": 19}
{"ground_truth": ["<s>", "void", "gas_output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "str", ",", "size_t", "length", ")", "{", "const", "unsigned", "char", "*", "_ascii_bytes", "=", "(", "const", "unsigned", "char", "*", ")", "str", ";", "const", "unsigned", "char", "*", "limit", "=", "_ascii_bytes", "+", "length", ";", "unsigned", "bytes_in_chunk", "=", "0", ";", "for", "(", ";", "_ascii_bytes", "<", "limit", ";", "_ascii_bytes", "++", ")", "{", "const", "unsigned", "char", "*", "p", ";", "if", "(", "bytes_in_chunk", ">=", "60", ")", "{", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "bytes_in_chunk", "=", "0", ";", "}", "for", "(", "p", "=", "_ascii_bytes", ";", "p", "<", "limit", "&&", "*", "p", "!=", "'\\0'", ";", "p", "++", ")", "continue", ";", "if", "(", "p", "<", "limit", "&&", "(", "p", "-", "_ascii_bytes", ")", "<=", "(", "signed", ")", "STRING_LIMIT", ")", "{", "if", "(", "bytes_in_chunk", ">", "0", ")", "{", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "bytes_in_chunk", "=", "0", ";", "}", "gas_output_limited_string", "(", "file", ",", "(", "char", "*", ")", "_ascii_bytes", ")", ";", "_ascii_bytes", "=", "p", ";", "}", "else", "{", "int", "escape", ";", "unsigned", "ch", ";", "if", "(", "bytes_in_chunk", "==", "0", ")", "fprintf", "(", "file", ",", "\"\\t.ascii\\t\\\"\"", ")", ";", "switch", "(", "escape", "=", "ESCAPES", "[", "ch", "=", "*", "_ascii_bytes", "]", ")", "{", "case", "0", ":", "putc", "(", "ch", ",", "file", ")", ";", "bytes_in_chunk", "++", ";", "break", ";", "case", "1", ":", "fprintf", "(", "file", ",", "\"\\\\%03o\"", ",", "ch", ")", ";", "bytes_in_chunk", "+=", "4", ";", "break", ";", "default", ":", "putc", "(", "'\\\\'", ",", "file", ")", ";", "putc", "(", "escape", ",", "file", ")", ";", "bytes_in_chunk", "+=", "2", ";", "break", ";", "}", "}", "}", "if", "(", "bytes_in_chunk", ">", "0", ")", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "}", "</s>"], "natrual_language": ["The", "routine", "used", "to", "output", "sequences", "of", "byte", "values", ".", "We", "use", "a", "special", "version", "of", "this", "for", "most", "svr4", "targets", "because", "doing", "so", "makes", "the", "generated", "assembly", "code", "more", "compact", "(", "and", "thus", "faster", "to", "assemble", ")", "as", "well", "as", "more", "readable", ".", "Note", "that", "if", "we", "find", "subparts", "of", "the", "character", "sequence", "which", "end", "with", "NUL", "(", "and", "which", "are", "shorter", "than", "STRING_LIMIT", ")", "we", "output", "those", "using", "ASM_OUTPUT_LIMITED_STRING", "."], "TS_V_token": ["avr", "0", "60", "\"\\\"\\n\"", "0", "0", "\"\\\"\\n\"", "0", "0", "\"\\t.ascii\\t\\\"\"", "0", "1", "\"\\\\%03o\"", "4", "2", "0", "\"\\\"\\n\""], "File": "avr3", "Func": "gas_output_ascii", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30343, "Length": 260}
{"ground_truth": ["<s>", "void", "gas_output_limited_string", "(", "FILE", "*", "file", ",", "const", "char", "*", "str", ")", "{", "const", "unsigned", "char", "*", "_limited_str", "=", "(", "unsigned", "char", "*", ")", "str", ";", "unsigned", "ch", ";", "fprintf", "(", "file", ",", "\"%s\\\"\"", ",", "STRING_ASM_OP", ")", ";", "for", "(", ";", "(", "ch", "=", "*", "_limited_str", ")", ";", "_limited_str", "++", ")", "{", "int", "escape", ";", "switch", "(", "escape", "=", "ESCAPES", "[", "ch", "]", ")", "{", "case", "0", ":", "putc", "(", "ch", ",", "file", ")", ";", "break", ";", "case", "1", ":", "fprintf", "(", "file", ",", "\"\\\\%03o\"", ",", "ch", ")", ";", "break", ";", "default", ":", "putc", "(", "'\\\\'", ",", "file", ")", ";", "putc", "(", "escape", ",", "file", ")", ";", "break", ";", "}", "}", "fprintf", "(", "file", ",", "\"\\\"\\n\"", ")", ";", "}", "</s>"], "natrual_language": ["The", "routine", "used", "to", "output", "NUL", "terminated", "strings", ".", "We", "use", "a", "special", "version", "of", "this", "for", "most", "svr4", "targets", "because", "doing", "so", "makes", "the", "generated", "assembly", "code", "more", "compact", "(", "and", "thus", "faster", "to", "assemble", ")", "as", "well", "as", "more", "readable", ",", "especially", "for", "targets", "like", "the", "i386", "(", "where", "the", "only", "alternative", "is", "to", "output", "character", "sequences", "as", "comma", "separated", "lists", "of", "numbers", ")", "."], "TS_V_token": ["avr", "\"%s\\\"\"", "0", "1", "\"\\\\%03o\"", "\"\\\"\\n\""], "File": "avr3", "Func": "gas_output_limited_string", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30344, "Length": 119}
{"ground_truth": ["<s>", "int", "initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "0", ";", "else", "{", "int", "offset", "=", "frame_pointer_needed", "?", "2", ":", "0", ";", "offset", "+=", "avr_regs_to_save", "(", "NULL", ")", ";", "return", "get_frame_size", "(", ")", "+", "2", "+", "1", "+", "offset", ";", "}", "}", "</s>"], "natrual_language": ["Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "."], "TS_V_token": ["avr", "0", "2", "0", "2", "1"], "File": "avr3", "Func": "initial_elimination_offset", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30345, "Length": 54}
{"ground_truth": ["<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "nregs", "=", "18", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "if", "(", "!", "libname", "&&", "fntype", ")", "{", "int", "stdarg", "=", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ";", "if", "(", "stdarg", ")", "cum", "->", "nregs", "=", "0", ";", "}", "}", "</s>"], "natrual_language": ["Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "."], "TS_V_token": ["avr", "18", "0", "0"], "File": "avr3", "Func": "init_cumulative_args", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30346, "Length": 77}
{"ground_truth": ["<s>", "static", "int", "interrupt_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt", "''", "attribute", "."], "TS_V_token": ["avr", "0", "\"interrupt\""], "File": "avr3", "Func": "interrupt_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30347, "Length": 41}
{"ground_truth": ["<s>", "int", "legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict", ")", "{", "enum", "reg_class", "r", "=", "NO_REGS", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"mode: (%s) %s %s %s %s:\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "strict", "?", "\"(strict)\"", ":", "\"\"", ",", "reload_completed", "?", "\"(reload_completed)\"", ":", "\"\"", ",", "reload_in_progress", "?", "\"(reload_in_progress)\"", ":", "\"\"", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", "&&", "reg_renumber", ")", "fprintf", "(", "stderr", ",", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "REG_P", "(", "x", ")", "&&", "(", "strict", "?", "REG_OK_FOR_BASE_STRICT_P", "(", "x", ")", ":", "REG_OK_FOR_BASE_NOSTRICT_P", "(", "x", ")", ")", ")", "r", "=", "POINTER_REGS", ";", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "r", "=", "ALL_REGS", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "{", "int", "fit", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", ";", "if", "(", "fit", ")", "{", "if", "(", "!", "strict", "||", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG_Y", "||", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG_Z", ")", "r", "=", "BASE_POINTER_REGS", ";", "if", "(", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", "||", "XEXP", "(", "x", ",", "0", ")", "==", "arg_pointer_rtx", ")", "r", "=", "BASE_POINTER_REGS", ";", "}", "else", "if", "(", "frame_pointer_needed", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", ")", "r", "=", "POINTER_Y_REGS", ";", "}", "else", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "x", ")", "==", "POST_INC", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "(", "strict", "?", "REG_OK_FOR_BASE_STRICT_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ":", "REG_OK_FOR_BASE_NOSTRICT_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "r", "=", "POINTER_REGS", ";", "}", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"   ret = %c\\n\"", ",", "r", "+", "'0'", ")", ";", "}", "return", "r", "==", "NO_REGS", "?", "0", ":", "(", "int", ")", "r", ";", "}", "</s>"], "natrual_language": ["legitimate_address_p", "returns", "1", "if", "it", "recognizes", "an", "RTL", "expression", "``", "x", "''", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", "."], "TS_V_token": ["avr", "\"mode: (%s) %s %s %s %s:\"", "\"(strict)\"", "\"\"", "\"(reload_completed)\"", "\"\"", "\"(reload_in_progress)\"", "\"\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "1", "\"(r%d ---> r%d)\"", "0", "0", "0", "1", "1", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "\"   ret = %c\\n\"", "0"], "File": "avr3", "Func": "legitimate_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30348, "Length": 425}
{"ground_truth": ["<s>", "rtx", "legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "enum", "machine_mode", "mode", ")", "{", "x", "=", "oldx", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "\"legitimize_address mode: %s\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "debug_rtx", "(", "oldx", ")", ";", "}", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", ")", "if", "(", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "if", "(", "TARGET_ALL_DEBUG", ")", "fprintf", "(", "stderr", ",", "\"force_reg (big offset)\\n\"", ")", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "return", "x", ";", "}", "</s>"], "natrual_language": ["Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "."], "TS_V_token": ["avr", "\"legitimize_address mode: %s\"", "0", "1", "1", "1", "0", "\"force_reg (big offset)\\n\""], "File": "avr3", "Func": "legitimize_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30349, "Length": 165}
{"ground_truth": ["<s>", "int", "mask_one_bit_p", "(", "HOST_WIDE_INT", "mask", ")", "{", "int", "i", ";", "unsigned", "HOST_WIDE_INT", "n", "=", "mask", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "++", "i", ")", "{", "if", "(", "n", "&", "0x80000000L", ")", "{", "if", "(", "n", "&", "0x7fffffffL", ")", "return", "0", ";", "else", "return", "32", "-", "i", ";", "}", "n", "<<=", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "the", "number", "MASK", "has", "only", "one", "bit", "set", "."], "TS_V_token": ["avr", "0", "32", "0x80000000L", "0x7fffffffL", "0", "32", "1", "0"], "File": "avr3", "Func": "mask_one_bit_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30350, "Length": 62}
{"ground_truth": ["<s>", "void", "notice_update_cc", "(", "rtx", "body", "ATTRIBUTE_UNUSED", ",", "rtx", "insn", ")", "{", "rtx", "set", ";", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_SET_N", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_ZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_SET_CZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "ASHIFTRT", "&&", "GET_MODE", "(", "src", ")", "==", "QImode", ")", "{", "rtx", "x", "=", "XEXP", "(", "src", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "x", ")", ">", "0", "&&", "INTVAL", "(", "x", ")", "!=", "6", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "}", "}", "break", ";", "}", "}", "</s>"], "natrual_language": ["On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "."], "TS_V_token": ["avr", "1", "0", "6"], "File": "avr3", "Func": "notice_update_cc", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30351, "Length": 229}
{"ground_truth": ["<s>", "void", "order_regs_for_local_alloc", "(", "void", ")", "{", "unsigned", "int", "i", ";", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "order_1", ":", "TARGET_ORDER_2", "?", "order_2", ":", "order_0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>"], "natrual_language": ["Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "."], "TS_V_token": ["avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0"], "File": "avr3", "Func": "order_regs_for_local_alloc", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30352, "Length": 297}
{"ground_truth": ["<s>", "const", "char", "*", "output_reload_inhi", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ",", "int", "*", "len", ")", "{", "int", "tmp", ";", "if", "(", "!", "len", ")", "len", "=", "&", "tmp", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "int", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "(", "val", "&", "0xff", ")", "==", "0", ")", "{", "*", "len", "=", "3", ";", "return", "(", "AS2", "(", "mov", ",", "%", "A0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "ldi", ",", "%", "2", ",", "hi8", "(", "%", "1", ")", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "B0", ",", "%", "2", ")", ")", ";", "}", "else", "if", "(", "(", "val", "&", "0xff00", ")", "==", "0", ")", "{", "*", "len", "=", "3", ";", "return", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "lo8", "(", "%", "1", ")", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "A0", ",", "%", "2", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "B0", ",", "__zero_reg__", ")", ")", ";", "}", "else", "if", "(", "(", "val", "&", "0xff", ")", "==", "(", "(", "val", "&", "0xff00", ")", ">>", "8", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "lo8", "(", "%", "1", ")", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "A0", ",", "%", "2", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "B0", ",", "%", "2", ")", ")", ";", "}", "}", "*", "len", "=", "4", ";", "return", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "lo8", "(", "%", "1", ")", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "A0", ",", "%", "2", ")", "CR_TAB", "AS2", "(", "ldi", ",", "%", "2", ",", "hi8", "(", "%", "1", ")", ")", "CR_TAB", "AS2", "(", "mov", ",", "%", "B0", ",", "%", "2", ")", ")", ";", "}", "</s>"], "natrual_language": ["Reload", "the", "constant", "OP", "[", "1", "]", "into", "the", "HI", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "PLEN", "==", "NULL", ":", "Output", "instructions", ".", "PLEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "PLEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "1", "1", "0xff", "0", "3", "2", "1", "2", "0xff00", "0", "3", "2", "1", "2", "0xff", "0xff00", "8", "3", "2", "1", "2", "2", "4", "2", "1", "2", "2", "1", "2"], "File": "avr3", "Func": "output_reload_inhi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30353, "Length": 291}
{"ground_truth": ["<s>", "const", "char", "*", "output_reload_insisf", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ",", "int", "*", "len", ")", "{", "rtx", "src", "=", "operands", "[", "1", "]", ";", "int", "cnst", "=", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", ";", "if", "(", "len", ")", "{", "if", "(", "cnst", ")", "*", "len", "=", "4", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff00", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff0000", ")", "!=", "0", ")", "+", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff000000", ")", "!=", "0", ")", ";", "else", "*", "len", "=", "8", ";", "return", "\"\"", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "A0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "lo8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "A0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff00", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "B0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hi8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "B0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff0000", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "C0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hlo8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "C0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "if", "(", "cnst", "&&", "(", "(", "INTVAL", "(", "src", ")", "&", "0xff000000", ")", "==", "0", ")", ")", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "D0", ",", "__zero_reg__", ")", ",", "operands", ")", ";", "else", "{", "output_asm_insn", "(", "AS2", "(", "ldi", ",", "%", "2", ",", "hhi8", "(", "%", "1", ")", ")", ",", "operands", ")", ";", "output_asm_insn", "(", "AS2", "(", "mov", ",", "%", "D0", ",", "%", "2", ")", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Reload", "a", "SI", "or", "SF", "compile", "time", "constant", "OP", "[", "1", "]", "into", "the", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "LEN", "==", "NULL", ":", "Output", "instructions", ".", "LEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "LEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "1", "4", "0xff", "0", "0xff00", "0", "0xff0000", "0", "0xff000000", "0", "8", "\"\"", "0xff", "0", "2", "1", "2", "0xff00", "0", "2", "1", "2", "0xff0000", "0", "2", "1", "2", "0xff000000", "0", "2", "1", "2", "\"\""], "File": "avr3", "Func": "output_reload_insisf", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30354, "Length": 398}
{"ground_truth": ["<s>", "static", "int", "out_adj_frame_ptr", "(", "FILE", "*", "file", ",", "int", "adj", ")", "{", "int", "size", "=", "0", ";", "if", "(", "adj", ")", "{", "if", "(", "TARGET_TINY_STACK", ")", "{", "if", "(", "adj", "<", "-", "63", "||", "adj", ">", "63", ")", "warning", "(", "0", ",", "\"large frame pointer change (%d) with -mtiny-stack\"", ",", "adj", ")", ";", "fprintf", "(", "file", ",", "(", "AS2", "(", "subi", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "adj", ")", ";", "size", "++", ";", "}", "else", "if", "(", "adj", "<", "-", "63", "||", "adj", ">", "63", ")", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "subi", ",", "r28", ",", "lo8", "(", "%", "d", ")", ")", "CR_TAB", "AS2", "(", "sbci", ",", "r29", ",", "hi8", "(", "%", "d", ")", ")", "CR_TAB", ")", ",", "adj", ",", "adj", ")", ";", "size", "+=", "2", ";", "}", "else", "if", "(", "adj", "<", "0", ")", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "adiw", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "-", "adj", ")", ";", "size", "++", ";", "}", "else", "{", "fprintf", "(", "file", ",", "(", "AS2", "(", "sbiw", ",", "r28", ",", "%", "d", ")", "CR_TAB", ")", ",", "adj", ")", ";", "size", "++", ";", "}", "}", "return", "size", ";", "}", "</s>"], "natrual_language": ["Output", "to", "FILE", "the", "asm", "instructions", "to", "adjust", "the", "frame", "pointer", "by", "ADJ", "(", "r29", ":", "r28", "-=", "ADJ", ";", ")", "which", "can", "be", "positive", "(", "prologue", ")", "or", "negative", "(", "epilogue", ")", ".", "Returns", "the", "number", "of", "instructions", "generated", "."], "TS_V_token": ["avr", "0", "63", "63", "0", "\"large frame pointer change (%d) with -mtiny-stack\"", "63", "63", "2", "0"], "File": "avr3", "Func": "out_adj_frame_ptr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30355, "Length": 191}
{"ground_truth": ["<s>", "static", "int", "out_set_stack_ptr", "(", "FILE", "*", "file", ",", "int", "before", ",", "int", "after", ")", "{", "int", "do_sph", ",", "do_cli", ",", "do_save", ",", "do_sei", ",", "lock_sph", ",", "size", ";", "do_sph", "=", "!", "TARGET_TINY_STACK", ";", "lock_sph", "=", "do_sph", "&&", "!", "TARGET_NO_INTERRUPTS", ";", "do_cli", "=", "(", "before", "!=", "0", "&&", "(", "after", "==", "0", "||", "lock_sph", ")", ")", ";", "do_save", "=", "(", "do_cli", "&&", "before", "==", "-", "1", "&&", "after", "==", "-", "1", ")", ";", "do_sei", "=", "(", "(", "do_cli", "||", "before", "!=", "1", ")", "&&", "after", "==", "1", ")", ";", "size", "=", "1", ";", "if", "(", "do_save", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "in", ",", "__tmp_reg__", ",", "__SREG__", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_cli", ")", "{", "fprintf", "(", "file", ",", "\"cli\"", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_sph", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SP_H__", ",", "r29", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_save", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SREG__", ",", "__tmp_reg__", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "else", "if", "(", "do_sei", ")", "{", "fprintf", "(", "file", ",", "\"sei\"", "CR_TAB", ")", ";", "size", "++", ";", "}", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SP_L__", ",", "r28", ")", "\"\\n\"", ")", ";", "return", "size", ";", "}", "</s>"], "natrual_language": ["Output", "to", "FILE", "the", "asm", "instructions", "to", "copy", "r29", ":", "r28", "to", "SPH", ":", "SPL", ",", "handling", "various", "cases", "of", "interrupt", "enable", "flag", "state", "BEFORE", "and", "AFTER", "(", "0=disabled", ",", "1=enabled", ",", "-1=unknown/unchanged", ")", "and", "target_flags", ".", "Returns", "the", "number", "of", "instructions", "generated", "."], "TS_V_token": ["avr", "0", "0", "1", "1", "1", "1", "1", "\"cli\"", "\"sei\"", "\"\\n\""], "File": "avr3", "Func": "out_set_stack_ptr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30356, "Length": 218}
{"ground_truth": ["<s>", "const", "char", "*", "out_tsthi", "(", "rtx", "insn", ",", "int", "*", "l", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS1", "(", "tst", ",", "%", "B0", ")", ";", "}", "if", "(", "reg_unused_after", "(", "insn", ",", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS2", "(", "or", ",", "%", "A0", ",", "%", "B0", ")", ";", "}", "if", "(", "test_hard_reg_class", "(", "ADDW_REGS", ",", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS2", "(", "sbiw", ",", "%", "0", ",", "0", ")", ";", "}", "if", "(", "l", ")", "*", "l", "=", "2", ";", "return", "(", "AS2", "(", "cp", ",", "%", "A0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "B0", ",", "__zero_reg__", ")", ")", ";", "}", "</s>"], "natrual_language": ["Output", "test", "instruction", "for", "HImode", "."], "TS_V_token": ["avr", "1", "1", "1", "0", "0", "2"], "File": "avr3", "Func": "out_tsthi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30357, "Length": 153}
{"ground_truth": ["<s>", "const", "char", "*", "out_tstsi", "(", "rtx", "insn", ",", "int", "*", "l", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "1", ";", "return", "AS1", "(", "tst", ",", "%", "D0", ")", ";", "}", "if", "(", "test_hard_reg_class", "(", "ADDW_REGS", ",", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", "{", "if", "(", "l", ")", "*", "l", "=", "3", ";", "return", "(", "AS2", "(", "sbiw", ",", "%", "A0", ",", "0", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "C0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "D0", ",", "__zero_reg__", ")", ")", ";", "}", "if", "(", "l", ")", "*", "l", "=", "4", ";", "return", "(", "AS2", "(", "cp", ",", "%", "A0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "B0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "C0", ",", "__zero_reg__", ")", "CR_TAB", "AS2", "(", "cpc", ",", "%", "D0", ",", "__zero_reg__", ")", ")", ";", "}", "</s>"], "natrual_language": ["Output", "test", "instruction", "for", "SImode", "."], "TS_V_token": ["avr", "1", "3", "0", "4"], "File": "avr3", "Func": "out_tstsi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30358, "Length": 152}
{"ground_truth": ["<s>", "enum", "reg_class", "preferred_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "class", ")", "{", "return", "class", ";", "}", "</s>"], "natrual_language": ["Given", "an", "rtx", "X", "being", "reloaded", "into", "a", "reg", "required", "to", "be", "in", "class", "CLASS", ",", "return", "the", "class", "of", "reg", "to", "actually", "use", ".", "In", "general", "this", "is", "just", "CLASS", ";", "but", "on", "some", "machines", "in", "some", "cases", "it", "is", "preferable", "to", "use", "a", "more", "restrictive", "class", ".", "Also", ",", "we", "must", "ensure", "that", "a", "PLUS", "is", "reloaded", "either", "into", "an", "accumulator", "or", "an", "address", "register", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "preferred_reload_class", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30359, "Length": 17}
{"ground_truth": ["<s>", "void", "print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "int", "abcd", "=", "0", ";", "if", "(", "code", ">=", "'A'", "&&", "code", "<=", "'D'", ")", "abcd", "=", "code", "-", "'A'", ";", "if", "(", "code", "==", "'~'", ")", "{", "if", "(", "!", "AVR_MEGA", ")", "fputc", "(", "'r'", ",", "file", ")", ";", "}", "else", "if", "(", "REG_P", "(", "x", ")", ")", "{", "if", "(", "x", "==", "zero_reg_rtx", ")", "fprintf", "(", "file", ",", "\"__zero_reg__\"", ")", ";", "else", "fprintf", "(", "file", ",", "reg_names", "[", "true_regnum", "(", "x", ")", "+", "abcd", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "x", ")", "+", "abcd", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "CONSTANT_P", "(", "addr", ")", "&&", "abcd", ")", "{", "fputc", "(", "'('", ",", "file", ")", ";", "output_address", "(", "addr", ")", ";", "fprintf", "(", "file", ",", "\")+%d\"", ",", "abcd", ")", ";", "}", "else", "if", "(", "code", "==", "'o'", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", "fatal_insn", "(", "\"bad address, not (reg+disp):\"", ",", "addr", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "}", "else", "if", "(", "code", "==", "'p'", "||", "code", "==", "'r'", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "POST_INC", "&&", "GET_CODE", "(", "addr", ")", "!=", "PRE_DEC", ")", "fatal_insn", "(", "\"bad address, not post_inc or pre_dec:\"", ",", "addr", ")", ";", "if", "(", "code", "==", "'p'", ")", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "else", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "print_operand_address", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "if", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG_X", ")", "fatal_insn", "(", "\"internal compiler error.  Bad address:\"", ",", "addr", ")", ";", "fputc", "(", "'+'", ",", "file", ")", ";", "print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "code", ")", ";", "}", "else", "print_operand_address", "(", "file", ",", "addr", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "long", "val", ";", "REAL_VALUE_TYPE", "rv", ";", "if", "(", "GET_MODE", "(", "x", ")", "!=", "SFmode", ")", "fatal_insn", "(", "\"internal compiler error.  Unknown mode:\"", ",", "x", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "rv", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "rv", ",", "val", ")", ";", "fprintf", "(", "file", ",", "\"0x%lx\"", ",", "val", ")", ";", "}", "else", "if", "(", "code", "==", "'j'", ")", "fputs", "(", "cond_string", "(", "GET_CODE", "(", "x", ")", ")", ",", "file", ")", ";", "else", "if", "(", "code", "==", "'k'", ")", "fputs", "(", "cond_string", "(", "reverse_condition", "(", "GET_CODE", "(", "x", ")", ")", ")", ",", "file", ")", ";", "else", "print_operand_address", "(", "file", ",", "x", ")", ";", "}", "</s>"], "natrual_language": ["Use", "S", "for", "SI", "regsUse", "B", "&", "T", "for", "parts", "of", "DI", "regs", "X", "-", "stack", "pointer", "name", "Registers", "Q", "-", "byte", "sized", "register", "name", "U", "-", "high", "byte", "of", "word", "register", "V", "-", "low", "byte", "of", "word", "register", "H", "-", "word", "register", "name", "I", "-", "next", "word", "register", "name", "S", "&", "B", "-", "long", "register", "name", "T", "-", "next", "long", "register", "name", "D", "-", "quad", "register", "name", "P", "-", "register", "name", "in", "size", "of", "pointer", "Integers", "O", "-", "log", "two", "of", "value", "P", "-", "inverted", "log", "two", "H", "-", "bottom", "16", "bits", "I", "-", "top", "16", "bits", "N", "-", "negative", "B", "-", "high", "32", "bits", "of", "32bit", "number", ".", "default", ":", "value", "Memory", "I", "-", "adjusted", "upwards", "by", "two", "T", "-", "adjusted", "upwards", "by", "four", "default", ":", "value", "Address", "H", "-", "low", "16", "bits", "I", "-", "high", "16", "bits", "A", "-", "as", "long", "constant", "S", "-", "as", "A", "but", "with", "#", "default", ":", "error", "Misc", "C", "-", "conditional", "name", "D", "-", "reverse", "conditional", "name", "F", "-", "clear", "v", "flag", "if", "necessary"], "TS_V_token": ["avr", "0", "\"__zero_reg__\"", "0", "\")+%d\"", "\"bad address, not (reg+disp):\"", "1", "0", "\"bad address, not post_inc or pre_dec:\"", "0", "0", "0", "0", "0", "\"internal compiler error.  Bad address:\"", "1", "\"internal compiler error.  Unknown mode:\"", "\"0x%lx\""], "File": "avr3", "Func": "print_operand", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30360, "Length": 463}
{"ground_truth": ["<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "(", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "||", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", ")", "{", "fprintf", "(", "file", ",", "\"pm(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>"], "natrual_language": ["Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr"], "TS_V_token": ["avr", "\"-%s\"", "0", "\"%s+\"", "0", "\"pm(\"", "\")\""], "File": "avr3", "Func": "print_operand_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30361, "Length": 152}
{"ground_truth": ["<s>", "static", "const", "char", "*", "ptrreg_to_str", "(", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "REG_X", ":", "return", "\"X\"", ";", "case", "REG_Y", ":", "return", "\"Y\"", ";", "case", "REG_Z", ":", "return", "\"Z\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Return", "a", "pointer", "register", "name", "as", "a", "string"], "TS_V_token": ["avr", "\"X\"", "\"Y\"", "\"Z\""], "File": "avr3", "Func": "ptrreg_to_str", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30362, "Length": 44}
{"ground_truth": ["<s>", "int", "reg_unused_after", "(", "rtx", "insn", ",", "rtx", "reg", ")", "{", "return", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", "||", "(", "REG_P", "(", "reg", ")", "&&", "_reg_unused_after", "(", "insn", ",", "reg", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "."], "TS_V_token": ["avr"], "File": "avr3", "Func": "reg_unused_after", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30363, "Length": 35}
{"ground_truth": ["<s>", "static", "int", "sequent_regs_live", "(", "void", ")", "{", "int", "reg", ";", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "18", ";", "++", "reg", ")", "{", "if", "(", "!", "call_used_regs", "[", "reg", "]", ")", "{", "if", "(", "regs_ever_live", "[", "reg", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "regs_ever_live", "[", "REG_Y", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "regs_ever_live", "[", "REG_Y", "+", "1", "]", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>"], "natrual_language": ["This", "function", "checks", "sequence", "of", "live", "registers"], "TS_V_token": ["avr", "0", "0", "0", "18", "0", "0", "1", "0", "2", "2", "0"], "File": "avr3", "Func": "sequent_regs_live", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30364, "Length": 137}
{"ground_truth": ["<s>", "static", "int", "signal_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "0", ";", "a", "=", "lookup_attribute", "(", "\"signal\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "a", "!=", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "a", "signal", "function", "as", "specified", "by", "the", "``", "signal", "''", "attribute", "."], "TS_V_token": ["avr", "0", "\"signal\""], "File": "avr3", "Func": "signal_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30365, "Length": 41}
{"ground_truth": ["<s>", "const", "char", "*", "ashlqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsl %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0xf0\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xe0\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xc0\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"ror %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"ror %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsl %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "shift", "left", "(", "(", "char", ")", "x", "<", "<", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsl %0\"", "2", "2", "\"lsl %0\"", "\"lsl %0\"", "3", "3", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0xf0\"", "4", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "5", "0", "3", "\"swap %0\"", "\"lsl %0\"", "\"andi %0,0xe0\"", "5", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "6", "0", "4", "\"swap %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"andi %0,0xc0\"", "6", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "7", "3", "\"ror %0\"", "\"clr %0\"", "\"ror %0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"lsl %0\"", "1", "\"\""], "File": "avr4", "Func": "ashlqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30366, "Length": 324}
{"ground_truth": ["<s>", "const", "char", "*", "ashlsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "(", "\"mov %D0,%C1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %D0,%C1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "==", "reg1", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %C0,%A1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %C0,%A1\"", "CR_TAB", "\"mov %D0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "case", "24", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %D0,%A1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", "CR_TAB", "\"rol %D0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "shift", "left", "(", "(", "long", ")", "x", "<", "<", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %D0,%C1\"", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "\"mov %D0,%C1\"", "16", "0", "1", "2", "2", "\"clr %B0\"", "\"clr %A0\"", "3", "\"movw %C0,%A1\"", "\"clr %B0\"", "\"clr %A0\"", "4", "\"mov %C0,%A1\"", "\"mov %D0,%B1\"", "\"clr %B0\"", "\"clr %A0\"", "24", "4", "\"mov %D0,%A1\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "31", "6", "\"clr %D0\"", "\"lsr %A0\"", "\"ror %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "\"rol %D0\"", "4", "\"\""], "File": "avr4", "Func": "ashlsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30367, "Length": 326}
{"ground_truth": ["<s>", "const", "char", "*", "ashrhi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "scratch", "=", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", ";", "int", "ldi_ok", "=", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ";", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "4", ":", "case", "5", ":", "break", ";", "case", "6", ":", "if", "(", "optimize_size", ")", "break", ";", "*", "len", "=", "8", ";", "return", "(", "\"mov __tmp_reg__,%A0\"", "CR_TAB", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl __tmp_reg__\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"lsl __tmp_reg__\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"rol %B0\"", ")", ";", "case", "7", ":", "*", "len", "=", "4", ";", "return", "(", "\"lsl %A0\"", "CR_TAB", "\"mov %A0,%B0\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"sbc %B0,%B0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", ")", "return", "*", "len", "=", "3", ",", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"dec %B0\"", ")", ";", "}", "case", "9", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "10", ":", "*", "len", "=", "5", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "11", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x20\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", "&&", "scratch", ")", "break", ";", "*", "len", "=", "6", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "12", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x10\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", "&&", "scratch", ")", "break", ";", "*", "len", "=", "7", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "13", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x08\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", ")", "break", ";", "*", "len", "=", "8", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "14", ":", "*", "len", "=", "5", ";", "return", "(", "\"lsl %B0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"rol %A0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "16", ")", "break", ";", "case", "15", ":", "return", "*", "len", "=", "3", ",", "(", "\"lsl %B0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["16bit", "arithmetic", "shift", "right", "(", "(", "signed", "short", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "0", "2", "4", "5", "6", "8", "\"mov __tmp_reg__,%A0\"", "\"mov %A0,%B0\"", "\"lsl __tmp_reg__\"", "\"rol %A0\"", "\"sbc %B0,%B0\"", "\"lsl __tmp_reg__\"", "\"rol %A0\"", "\"rol %B0\"", "7", "4", "\"lsl %A0\"", "\"mov %A0,%B0\"", "\"rol %A0\"", "\"sbc %B0,%B0\"", "8", "0", "1", "3", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "4", "\"mov %A0,%B1\"", "\"clr %B0\"", "\"sbrc %A0,7\"", "\"dec %B0\"", "9", "4", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "10", "5", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "11", "5", "\"ldi %A0,0x20\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "6", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "12", "5", "\"ldi %A0,0x10\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "7", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "13", "5", "\"ldi %A0,0x08\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "8", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "14", "5", "\"lsl %B0\"", "\"sbc %A0,%A0\"", "\"lsl %B0\"", "\"mov %B0,%A0\"", "\"rol %A0\"", "2", "16", "15", "3", "\"lsl %B0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"asr %B0\"", "\"ror %A0\"", "2", "\"\""], "File": "avr4", "Func": "ashrhi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30368, "Length": 508}
{"ground_truth": ["<s>", "const", "char", "*", "ashrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"asr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "4", ":", "*", "len", "=", "4", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "5", ":", "*", "len", "=", "5", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "6", ":", "*", "len", "=", "4", ";", "return", "(", "\"bst %0,6\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", "CR_TAB", "\"bld %0,0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "case", "7", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"asr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "arithmetic", "shift", "right", "(", "(", "signed", "char", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "1", "1", "\"asr %0\"", "2", "2", "\"asr %0\"", "\"asr %0\"", "3", "3", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "4", "4", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "5", "5", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "6", "4", "\"bst %0,6\"", "\"lsl %0\"", "\"sbc %0,%0\"", "\"bld %0,0\"", "2", "8", "7", "2", "\"lsl %0\"", "\"sbc %0,%0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"asr %0\"", "1", "\"\""], "File": "avr4", "Func": "ashrqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30369, "Length": 226}
{"ground_truth": ["<s>", "const", "char", "*", "ashrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "6", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %C0,7\"", "CR_TAB", "\"dec %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %D1,7\"", "CR_TAB", "\"dec %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "4", ",", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "5", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "else", "return", "*", "len", "=", "6", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "6", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %B0,%D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "case", "31", ":", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "4", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"movw %C0,%A0\"", ")", ";", "else", "return", "*", "len", "=", "5", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"mov %C0,%A0\"", "CR_TAB", "\"mov %D0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "arithmetic", "shift", "right", "(", "(", "signed", "long", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "8", "0", "1", "6", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"sbrc %C0,7\"", "\"dec %D0\"", "\"clr %D0\"", "\"sbrc %D1,7\"", "\"dec %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "4", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "5", "\"movw %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "6", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "24", "6", "\"mov %A0,%D1\"", "\"clr %D0\"", "\"sbrc %A0,7\"", "\"com %D0\"", "\"mov %B0,%D0\"", "\"mov %C0,%D0\"", "2", "32", "31", "4", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"movw %C0,%A0\"", "5", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"mov %C0,%A0\"", "\"mov %D0,%A0\"", "\"asr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\""], "File": "avr4", "Func": "ashrsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30370, "Length": 335}
{"ground_truth": ["<s>", "static", "bool", "avr_2word_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "TARGET_SKIP_BUG", "||", "!", "insn", "||", "2", "!=", "get_attr_length", "(", "insn", ")", ")", "{", "return", "false", ";", "}", "switch", "(", "INSN_CODE", "(", "insn", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CODE_FOR_movqi_insn", ":", "case", "CODE_FOR_movuqq_insn", ":", "case", "CODE_FOR_movqq_insn", ":", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "REG_P", "(", "src", ")", "||", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "dest", ")", ")", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ";", "}", "return", "false", ";", "}", "case", "CODE_FOR_call_insn", ":", "case", "CODE_FOR_call_value_insn", ":", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "for", "jump_over_one_insn_p", ":", "Test", "if", "INSN", "is", "a", "2-word", "instruction", "and", "thus", "is", "suitable", "to", "be", "skipped", "by", "CPSE", ",", "SBRC", ",", "etc", "."], "TS_V_token": ["avr", "2", "0", "0"], "File": "avr4", "Func": "avr_2word_insn_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30371, "Length": 153}
{"ground_truth": ["<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "cost", "=", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SUBREG", ")", ")", "{", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "61", ")", "cost", "=", "18", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "optimize", ">", "0", "&&", "io_address_operand", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "}", "if", "(", "avr_log", ".", "address_cost", ")", "avr_edump", "(", "\"\\n%?: %d = %r\\n\"", ",", "cost", ",", "x", ")", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Calculate", "the", "cost", "of", "a", "memory", "address", "."], "TS_V_token": ["avr", "4", "1", "0", "0", "1", "61", "18", "0", "2", "\"\\n%?: %d = %r\\n\""], "File": "avr4", "Func": "avr_address_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30372, "Length": 134}
{"ground_truth": ["<s>", "static", "machine_mode", "avr_addr_space_address_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addrspace", "[", "as", "]", ".", "pointer_size", "==", "3", "?", "PSImode", ":", "HImode", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_ADDRESS_MODE", "'", "."], "TS_V_token": ["avr", "3"], "File": "avr4", "Func": "avr_addr_space_address_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30373, "Length": 23}
{"ground_truth": ["<s>", "static", "rtx", "avr_addr_space_convert", "(", "rtx", "src", ",", "tree", "type_from", ",", "tree", "type_to", ")", "{", "addr_space_t", "as_from", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_from", ")", ")", ";", "addr_space_t", "as_to", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_to", ")", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", ",", "src", ",", "type_from", ",", "type_to", ")", ";", "if", "(", "as_from", "!=", "ADDR_SPACE_MEMX", "&&", "as_to", "==", "ADDR_SPACE_MEMX", ")", "{", "int", "msb", ";", "rtx", "sym", "=", "src", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "PSImode", ")", ";", "while", "(", "CONST", "==", "GET_CODE", "(", "sym", ")", "||", "PLUS", "==", "GET_CODE", "(", "sym", ")", ")", "sym", "=", "XEXP", "(", "sym", ",", "0", ")", ";", "if", "(", "SYMBOL_REF", "==", "GET_CODE", "(", "sym", ")", "&&", "ADDR_SPACE_FLASH", "==", "AVR_SYMBOL_GET_ADDR_SPACE", "(", "sym", ")", ")", "{", "as_from", "=", "ADDR_SPACE_FLASH", ";", "}", "msb", "=", "ADDR_SPACE_GENERIC_P", "(", "as_from", ")", "?", "0x80", ":", "avr_addrspace", "[", "as_from", "]", ".", "segment", ";", "src", "=", "force_reg", "(", "Pmode", ",", "src", ")", ";", "emit_insn", "(", "msb", "==", "0", "?", "gen_zero_extendhipsi2", "(", "reg", ",", "src", ")", ":", "gen_n_extendhipsi2", "(", "reg", ",", "gen_int_mode", "(", "msb", ",", "QImode", ")", ",", "src", ")", ")", ";", "return", "reg", ";", "}", "if", "(", "as_from", "==", "ADDR_SPACE_MEMX", "&&", "as_to", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "new_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src", "=", "force_reg", "(", "PSImode", ",", "src", ")", ";", "emit_move_insn", "(", "new_src", ",", "simplify_gen_subreg", "(", "Pmode", ",", "src", ",", "PSImode", ",", "0", ")", ")", ";", "return", "new_src", ";", "}", "return", "src", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_CONVERT", "'", "."], "TS_V_token": ["avr", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", "0", "0x80", "0", "0"], "File": "avr4", "Func": "avr_addr_space_convert", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30374, "Length": 236}
{"ground_truth": ["<s>", "static", "machine_mode", "avr_addr_space_pointer_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addr_space_address_mode", "(", "as", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_POINTER_MODE", "'", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_addr_space_pointer_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30375, "Length": 15}
{"ground_truth": ["<s>", "void", "avr_adjust_reg_alloc_order", "(", "void", ")", "{", "unsigned", "int", "i", ";", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_0", "[", "]", "=", "{", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_1", "[", "]", "=", "{", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "(", "AVR_TINY", "?", "tiny_order_1", ":", "order_1", ")", ":", "TARGET_ORDER_2", "?", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_2", ")", ":", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_0", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>"], "natrual_language": ["Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "."], "TS_V_token": ["avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0"], "File": "avr4", "Func": "avr_adjust_reg_alloc_order", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30376, "Length": 477}
{"ground_truth": ["<s>", "static", "void", "avr_adjust_type_node", "(", "tree", "*", "node", ",", "machine_mode", "mode", ",", "int", "sat_p", ")", "{", "*", "node", "=", "make_node", "(", "FIXED_POINT_TYPE", ")", ";", "TYPE_SATURATING", "(", "*", "node", ")", "=", "sat_p", ";", "TYPE_UNSIGNED", "(", "*", "node", ")", "=", "UNSIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", ";", "TYPE_IBIT", "(", "*", "node", ")", "=", "GET_MODE_IBIT", "(", "mode", ")", ";", "TYPE_FBIT", "(", "*", "node", ")", "=", "GET_MODE_FBIT", "(", "mode", ")", ";", "TYPE_PRECISION", "(", "*", "node", ")", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "TYPE_ALIGN", "(", "*", "node", ")", "=", "8", ";", "SET_TYPE_MODE", "(", "*", "node", ",", "mode", ")", ";", "layout_type", "(", "*", "node", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "the", "function", "below", "."], "TS_V_token": ["avr", "8"], "File": "avr4", "Func": "avr_adjust_type_node", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30377, "Length": 98}
{"ground_truth": ["<s>", "static", "void", "avr_asm_function_begin_epilogue", "(", "FILE", "*", "file", ")", "{", "fprintf", "(", "file", ",", "\"/* epilogue start */\\n\"", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_FUNCTION_BEGIN_EPILOGUE", "'", "."], "TS_V_token": ["avr", "\"/* epilogue start */\\n\""], "File": "avr4", "Func": "avr_asm_function_begin_epilogue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30378, "Length": 17}
{"ground_truth": ["<s>", "static", "void", "avr_asm_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "fputs", "(", "\"/* prologue: naked */\\n\"", ",", "file", ")", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "fputs", "(", "\"/* prologue: Interrupt */\\n\"", ",", "file", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "is_signal", ")", "{", "fputs", "(", "\"/* prologue: Signal */\\n\"", ",", "file", ")", ";", "}", "else", "fputs", "(", "\"/* prologue: function */\\n\"", ",", "file", ")", ";", "}", "if", "(", "ACCUMULATE_OUTGOING_ARGS", ")", "fprintf", "(", "file", ",", "\"/* outgoing args size = %d */\\n\"", ",", "avr_outgoing_args_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* frame size = \"", "HOST_WIDE_INT_PRINT_DEC", "\" */\\n\"", ",", "get_frame_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* stack size = %d */\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "}", "</s>"], "natrual_language": ["Output", "summary", "at", "end", "of", "function", "prologue", "."], "TS_V_token": ["avr", "\"/* prologue: naked */\\n\"", "\"/* prologue: Interrupt */\\n\"", "\"/* prologue: Signal */\\n\"", "\"/* prologue: function */\\n\"", "\"/* outgoing args size = %d */\\n\"", "\"/* frame size = \"", "\" */\\n\"", "\"/* stack size = %d */\\n\"", "\".L__stack_usage = %d\\n\""], "File": "avr4", "Func": "avr_asm_function_end_prologue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30379, "Length": 127}
{"ground_truth": ["<s>", "static", "section", "*", "avr_asm_function_rodata_section", "(", "tree", "decl", ")", "{", "unsigned", "int", "flags", ";", "section", "*", "frodata", ";", "{", "int", "fdata", "=", "flag_data_sections", ";", "flag_data_sections", "=", "flag_function_sections", ";", "frodata", "=", "default_function_rodata_section", "(", "decl", ")", ";", "flag_data_sections", "=", "fdata", ";", "flags", "=", "frodata", "->", "common", ".", "flags", ";", "}", "if", "(", "frodata", "!=", "readonly_data_section", "&&", "flags", "&", "SECTION_NAMED", ")", "{", "unsigned", "int", "i", ";", "static", "const", "char", "*", "const", "prefix", "[", "]", "=", "{", "\".rodata\"", ",", "\".progmem.gcc_sw_table\"", ",", "\".gnu.linkonce.r.\"", ",", "\".gnu.linkonce.t.\"", "}", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "prefix", ")", "/", "sizeof", "(", "*", "prefix", ")", ";", "i", "+=", "2", ")", "{", "const", "char", "*", "old_prefix", "=", "prefix", "[", "i", "]", ";", "const", "char", "*", "new_prefix", "=", "prefix", "[", "i", "+", "1", "]", ";", "const", "char", "*", "name", "=", "frodata", "->", "named", ".", "name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "rname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "flags", "&=", "~", "SECTION_CODE", ";", "flags", "|=", "AVR_HAVE_JMP_CALL", "?", "0", ":", "SECTION_CODE", ";", "return", "get_section", "(", "rname", ",", "flags", ",", "frodata", "->", "named", ".", "decl", ")", ";", "}", "}", "}", "return", "progmem_swtable_section", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_FUNCTION_RODATA_SECTION", "'", "."], "TS_V_token": ["avr", "\".rodata\"", "\".progmem.gcc_sw_table\"", "\".gnu.linkonce.r.\"", "\".gnu.linkonce.t.\"", "0", "2", "1", "0"], "File": "avr4", "Func": "avr_asm_function_rodata_section", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30380, "Length": 203}
{"ground_truth": ["<s>", "static", "void", "avr_asm_init_sections", "(", "void", ")", "{", "if", "(", "AVR_HAVE_JMP_CALL", ")", "{", "progmem_swtable_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.section\\t.progmem.gcc_sw_table\"", "\",\\\"a\\\",@progbits\"", ")", ";", "}", "else", "{", "progmem_swtable_section", "=", "get_unnamed_section", "(", "SECTION_CODE", ",", "output_section_asm_op", ",", "\"\\t.section\\t.progmem.gcc_sw_table\"", "\",\\\"ax\\\",@progbits\"", ")", ";", "}", "readonly_data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "bss_section", "->", "unnamed", ".", "callback", "=", "avr_output_bss_section_asm_op", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_INIT_SECTIONS", "'", "."], "TS_V_token": ["avr", "0", "\"\\t.section\\t.progmem.gcc_sw_table\"", "\",\\\"a\\\",@progbits\"", "\"\\t.section\\t.progmem.gcc_sw_table\"", "\",\\\"ax\\\",@progbits\""], "File": "avr4", "Func": "avr_asm_init_sections", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30381, "Length": 65}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_asm_len", "(", "const", "char", "*", "tpl", ",", "rtx", "*", "operands", ",", "int", "*", "plen", ",", "int", "n_words", ")", "{", "if", "(", "NULL", "==", "plen", ")", "{", "output_asm_insn", "(", "tpl", ",", "operands", ")", ";", "}", "else", "{", "if", "(", "n_words", "<", "0", ")", "*", "plen", "=", "-", "n_words", ";", "else", "*", "plen", "+=", "n_words", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "to", "print", "assembler", "resp", ".", "track", "instruction", "sequence", "lengths", ".", "Always", "return", "``", "''", ".", "If", "PLEN", "==", "NULL", ":", "Output", "assembler", "code", "from", "template", "TPL", "with", "operands", "supplied", "by", "OPERANDS", ".", "This", "is", "just", "forwarding", "to", "output_asm_insn", ".", "If", "PLEN", "!", "=", "NULL", ":", "If", "N_WORDS", ">", "=", "0", "Add", "N_WORDS", "to", "*", "PLEN", ".", "If", "N_WORDS", "<", "0", "Set", "*", "PLEN", "to", "-N_WORDS", ".", "Do", "n't", "output", "anything", "."], "TS_V_token": ["avr", "0", "\"\""], "File": "avr4", "Func": "avr_asm_len", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30382, "Length": 63}
{"ground_truth": ["<s>", "static", "void", "avr_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", ")", "{", "if", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "{", "addr_space_t", "as", "=", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "/", "SECTION_MACH_DEP", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "default_elf_asm_named_section", "(", "sname", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "default_elf_asm_named_section", "(", "new_prefix", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "avr_need_copy_data_p", ")", "avr_need_copy_data_p", "=", "(", "STR_PREFIX_P", "(", "name", ",", "\".data\"", ")", "||", "STR_PREFIX_P", "(", "name", ",", "\".rodata\"", ")", "||", "STR_PREFIX_P", "(", "name", ",", "\".gnu.linkonce.d\"", ")", ")", ";", "if", "(", "!", "avr_need_clear_bss_p", ")", "avr_need_clear_bss_p", "=", "STR_PREFIX_P", "(", "name", ",", "\".bss\"", ")", ";", "default_elf_asm_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "}", "</s>"], "natrual_language": ["Track", "need", "of", "__do_clear_bss", ",", "__do_copy_data", "for", "named", "sections", "."], "TS_V_token": ["avr", "\".rodata\"", "\".data\"", "\".rodata\"", "\".gnu.linkonce.d\"", "\".bss\""], "File": "avr4", "Func": "avr_asm_named_section", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30383, "Length": 163}
{"ground_truth": ["<s>", "void", "avr_asm_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "bool", "local_p", ")", "{", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "rtx", "symbol", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "GET_CODE", "(", "(", "symbol", "=", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "==", "SYMBOL_REF", "&&", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "(", "SYMBOL_FLAG_IO", "|", "SYMBOL_FLAG_ADDRESS", ")", ")", ")", "{", "if", "(", "!", "local_p", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.globl\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "if", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "SYMBOL_FLAG_ADDRESS", ")", "{", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\" = %ld\\n\"", ",", "(", "long", ")", "INTVAL", "(", "avr_eval_addr_attrib", "(", "symbol", ")", ")", ")", ";", "}", "else", "if", "(", "local_p", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"static IO declaration for %q+D needs an address\"", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__gnu_lto\"", ")", ")", "avr_need_clear_bss_p", "=", "true", ";", "if", "(", "local_p", ")", "ASM_OUTPUT_ALIGNED_LOCAL", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "else", "ASM_OUTPUT_ALIGNED_COMMON", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "}", "</s>"], "natrual_language": ["Track", "need", "of", "__do_clear_bss", "."], "TS_V_token": ["avr", "0", "\"\\t.globl\\t\"", "\"\\n\"", "\" = %ld\\n\"", "\"static IO declaration for %q+D needs an address\"", "\"__gnu_lto\""], "File": "avr4", "Func": "avr_asm_output_aligned_decl_common", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30384, "Length": 211}
{"ground_truth": ["<s>", "static", "section", "*", "avr_asm_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "sect", "=", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "if", "(", "sect", "->", "common", ".", "flags", "&", "SECTION_NAMED", ")", "{", "const", "char", "*", "name", "=", "sect", "->", "named", ".", "name", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "return", "get_section", "(", "sname", ",", "sect", "->", "common", ".", "flags", ",", "sect", "->", "named", ".", "decl", ")", ";", "}", "}", "if", "(", "!", "progmem_section", "[", "as", "]", ")", "{", "progmem_section", "[", "as", "]", "=", "get_unnamed_section", "(", "0", ",", "avr_output_progmem_section_asm_op", ",", "avr_addrspace", "[", "as", "]", ".", "section_name", ")", ";", "}", "return", "progmem_section", "[", "as", "]", ";", "}", "return", "sect", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_SELECT_SECTION", "'"], "TS_V_token": ["avr", "\".rodata\"", "0"], "File": "avr4", "Func": "avr_asm_select_section", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30385, "Length": 203}
{"ground_truth": ["<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.word\\tgs(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "PSImode", ")", "{", "fputs", "(", "\"\\t.byte\\tlo8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thi8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thh8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "CONST_FIXED_P", "(", "x", ")", ")", "{", "unsigned", "n", ";", "for", "(", "n", "=", "0", ";", "n", "<", "size", ";", "n", "++", ")", "{", "rtx", "xn", "=", "simplify_gen_subreg", "(", "QImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "n", ")", ";", "default_assemble_integer", "(", "xn", ",", "1", ",", "aligned_p", ")", ";", "}", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>"], "natrual_language": ["Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "."], "TS_V_token": ["avr", "\"\\t.word\\tgs(\"", "\")\\n\"", "\"\\t.byte\\tlo8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thi8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thh8(\"", "\")\"", "\"need binutils PR13503\\n\"", "0", "1"], "File": "avr4", "Func": "avr_assemble_integer", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30386, "Length": 210}
{"ground_truth": ["<s>", "static", "rtx", "avr_builtin_setjmp_frame_value", "(", "void", ")", "{", "rtx", "xval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_subhi3", "(", "xval", ",", "virtual_stack_vars_rtx", ",", "gen_int_mode", "(", "STARTING_FRAME_OFFSET", ",", "Pmode", ")", ")", ")", ";", "return", "xval", ";", "}", "</s>"], "natrual_language": ["Actual", "start", "of", "frame", "is", "virtual_stack_vars_rtx", "this", "is", "offset", "from", "frame", "pointer", "by", "+TARGET_STARTING_FRAME_OFFSET", ".", "Using", "saved", "frame", "=", "virtual_stack_vars_rtx", "-", "TARGET_STARTING_FRAME_OFFSET", "avoids", "creating", "add/sub", "of", "offset", "in", "nonlocal", "goto", "and", "setjmp", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_builtin_setjmp_frame_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30387, "Length": 36}
{"ground_truth": ["<s>", "static", "void", "avr_conditional_register_usage", "(", "void", ")", "{", "if", "(", "AVR_TINY", ")", "{", "unsigned", "int", "i", ";", "const", "int", "tiny_reg_alloc_order", "[", "]", "=", "{", "24", ",", "25", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "17", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "for", "(", "i", "=", "18", ";", "i", "<=", "LAST_CALLEE_SAVED_REG", ";", "i", "++", ")", "{", "call_used_regs", "[", "i", "]", "=", "0", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "tiny_reg_alloc_order", ")", ";", "i", "++", ")", "{", "reg_alloc_order", "[", "i", "]", "=", "tiny_reg_alloc_order", "[", "i", "]", ";", "}", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "ADDW_REGS", "]", ")", ";", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "NO_LD_REGS", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_CONDITIONAL_REGISTER_USAGE", "'", "."], "TS_V_token": ["avr", "24", "25", "22", "23", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "0", "17", "1", "1", "18", "0", "0"], "File": "avr4", "Func": "avr_conditional_register_usage", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30388, "Length": 199}
{"ground_truth": ["<s>", "static", "rtx", "avr_default_expand_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ",", "xop", "[", "3", "]", ";", "int", "n", ",", "n_args", "=", "call_expr_nargs", "(", "exp", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "gcc_assert", "(", "n_args", ">=", "1", "&&", "n_args", "<=", "3", ")", ";", "if", "(", "target", "==", "NULL_RTX", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "target", ",", "tmode", ")", ")", "{", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "for", "(", "n", "=", "0", ";", "n", "<", "n_args", ";", "n", "++", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "n", ")", ";", "rtx", "op", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "machine_mode", "opmode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "mode", ";", "if", "(", "(", "opmode", "==", "SImode", "||", "opmode", "==", "VOIDmode", ")", "&&", "mode", "==", "HImode", ")", "{", "opmode", "=", "HImode", ";", "op", "=", "gen_lowpart", "(", "HImode", ",", "op", ")", ";", "}", "gcc_assert", "(", "opmode", "==", "mode", "||", "opmode", "==", "VOIDmode", ")", ";", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "predicate", "(", "op", ",", "mode", ")", ")", "op", "=", "copy_to_mode_reg", "(", "mode", ",", "op", ")", ";", "xop", "[", "n", "]", "=", "op", ";", "}", "switch", "(", "n_args", ")", "{", "case", "1", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ")", ";", "break", ";", "case", "3", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ",", "xop", "[", "2", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "pat", "==", "NULL_RTX", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>"], "natrual_language": ["Subroutine", "of", "avr_expand_builtin", "to", "expand", "vanilla", "builtins", "with", "non-void", "result", "and", "1", "...", "3", "arguments", "."], "TS_V_token": ["avr", "3", "0", "1", "3", "0", "0", "1", "1", "1", "0", "2", "0", "1", "3", "0", "1", "2"], "File": "avr4", "Func": "avr_default_expand_builtin", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30389, "Length": 348}
{"ground_truth": ["<s>", "bool", "avr_emit_movmemhi", "(", "rtx", "*", "xop", ")", "{", "HOST_WIDE_INT", "count", ";", "machine_mode", "loop_mode", ";", "addr_space_t", "as", "=", "MEM_ADDR_SPACE", "(", "xop", "[", "1", "]", ")", ";", "rtx", "loop_reg", ",", "addr1", ",", "a_src", ",", "a_dest", ",", "insn", ",", "xas", ";", "rtx", "a_hi8", "=", "NULL_RTX", ";", "if", "(", "avr_mem_flash_p", "(", "xop", "[", "0", "]", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", "return", "false", ";", "count", "=", "INTVAL", "(", "xop", "[", "2", "]", ")", ";", "if", "(", "count", "<=", "0", ")", "return", "false", ";", "a_src", "=", "XEXP", "(", "xop", "[", "1", "]", ",", "0", ")", ";", "a_dest", "=", "XEXP", "(", "xop", "[", "0", "]", ",", "0", ")", ";", "if", "(", "PSImode", "==", "GET_MODE", "(", "a_src", ")", ")", "{", "gcc_assert", "(", "as", "==", "ADDR_SPACE_MEMX", ")", ";", "loop_mode", "=", "(", "count", "<", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "gen_rtx_REG", "(", "loop_mode", ",", "24", ")", ";", "emit_move_insn", "(", "loop_reg", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "addr1", "=", "simplify_gen_subreg", "(", "HImode", ",", "a_src", ",", "PSImode", ",", "0", ")", ";", "a_hi8", "=", "simplify_gen_subreg", "(", "QImode", ",", "a_src", ",", "PSImode", ",", "2", ")", ";", "}", "else", "{", "int", "segment", "=", "avr_addrspace", "[", "as", "]", ".", "segment", ";", "if", "(", "segment", "&&", "avr_n_flash", ">", "1", ")", "{", "a_hi8", "=", "GEN_INT", "(", "segment", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "a_hi8", "=", "copy_to_mode_reg", "(", "QImode", ",", "a_hi8", ")", ")", ";", "}", "else", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "as", "=", "ADDR_SPACE_FLASH", ";", "}", "addr1", "=", "a_src", ";", "loop_mode", "=", "(", "count", "<=", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "copy_to_mode_reg", "(", "loop_mode", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "}", "xas", "=", "GEN_INT", "(", "as", ")", ";", "emit_move_insn", "(", "lpm_addr_reg_rtx", ",", "addr1", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "HImode", ",", "REG_X", ")", ",", "a_dest", ")", ";", "gcc_assert", "(", "TMP_REGNO", "==", "LPM_REGNO", ")", ";", "if", "(", "as", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_movmem_qi", ":", "gen_movmem_hi", ";", "insn", "=", "fun", "(", "xas", ",", "loop_reg", ",", "loop_reg", ")", ";", "}", "else", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_movmemx_qi", ":", "gen_movmemx_hi", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "QImode", ",", "23", ")", ",", "a_hi8", ")", ";", "insn", "=", "fun", "(", "xas", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "}", "set_mem_addr_space", "(", "SET_SRC", "(", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", ")", ",", "as", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "movmemhi", "expander", ".", "XOP", "[", "0", "]", "Destination", "as", "MEM", ":", "BLK", "XOP", "[", "1", "]", "Source", "``", "``", "XOP", "[", "2", "]", "#", "Bytes", "to", "copy", "Return", "TRUE", "if", "the", "expansion", "is", "accomplished", ".", "Return", "FALSE", "if", "the", "operand", "compination", "is", "not", "supported", "."], "TS_V_token": ["avr", "1", "0", "2", "2", "0", "1", "0", "0", "0", "0x100", "24", "0", "2", "1", "0x100", "23", "0", "0"], "File": "avr4", "Func": "avr_emit_movmemhi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30390, "Length": 426}
{"ground_truth": ["<s>", "static", "void", "avr_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "new_decl_p", ")", "{", "if", "(", "new_decl_p", "&&", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "NULL_TREE", "==", "DECL_INITIAL", "(", "decl", ")", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "warning", "(", "OPT_Wuninitialized", ",", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", ",", "decl", ")", ";", "}", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "new_decl_p", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", "&&", "MEM_P", "(", "rtl", ")", "&&", "SYMBOL_REF", "==", "GET_CODE", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ")", "{", "rtx", "sym", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "type", "==", "error_mark_node", ")", "return", ";", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "type", ")", ";", "if", "(", "-", "1", "==", "avr_progmem_p", "(", "decl", ",", "attr", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "AVR_SYMBOL_SET_ADDR_SPACE", "(", "sym", ",", "as", ")", ";", "tree", "io_low_attr", "=", "lookup_attribute", "(", "\"io_low\"", ",", "attr", ")", ";", "tree", "io_attr", "=", "lookup_attribute", "(", "\"io\"", ",", "attr", ")", ";", "tree", "addr_attr", ";", "if", "(", "io_low_attr", "&&", "TREE_VALUE", "(", "io_low_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_low_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "if", "(", "io_attr", "&&", "TREE_VALUE", "(", "io_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "addr_attr", "=", "lookup_attribute", "(", "\"address\"", ",", "attr", ")", ";", "if", "(", "io_low_attr", "||", "(", "io_attr", "&&", "addr_attr", "&&", "low_io_address_operand", "(", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "addr_attr", ")", ")", ")", ")", ",", "QImode", ")", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO_LOW", ";", "if", "(", "io_attr", "||", "io_low_attr", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO", ";", "if", "(", "addr_attr", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_ADDRESS", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ENCODE_SECTION_INFO", "'", "."], "TS_V_token": ["avr", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", "0", "0", "1", "\"io_low\"", "\"io\"", "\"address\""], "File": "avr4", "Func": "avr_encode_section_info", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30391, "Length": 312}
{"ground_truth": ["<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0"], "File": "avr4", "Func": "avr_expand_builtin", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30392, "Length": 455}
{"ground_truth": ["<s>", "void", "avr_expand_prologue", "(", "void", ")", "{", "HARD_REG_SET", "set", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "cfun", "->", "machine", "->", "stack_usage", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_enable_interrupt", "(", ")", ")", ";", "emit_push_byte", "(", "AVR_ZERO_REGNO", ",", "true", ")", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "true", ")", ";", "emit_push_sfr", "(", "sreg_rtx", ",", "false", ",", "false", ")", ";", "emit_move_insn", "(", "zero_reg_rtx", ",", "const0_rtx", ")", ";", "emit_use", "(", "zero_reg_rtx", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "emit_push_sfr", "(", "rampd_rtx", ",", "false", ",", "true", ")", ";", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampx_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "emit_push_sfr", "(", "rampy_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampz_rtx", ",", "false", ",", "AVR_HAVE_RAMPD", ")", ";", "}", "}", "avr_prologue_setup_frame", "(", "size", ",", "set", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "cfun", "->", "machine", "->", "stack_usage", ";", "}", "</s>"], "natrual_language": ["Output", "function", "prologue", "."], "TS_V_token": ["avr", "0", "1", "1", "1"], "File": "avr4", "Func": "avr_expand_prologue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30393, "Length": 246}
{"ground_truth": ["<s>", "void", "avr_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: cost = %d.  */\\n\"", ",", "set_src_cost", "(", "SET_SRC", "(", "set", ")", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "INSN", ",", "0", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "insn", "cost", "for", "next", "insn", "."], "TS_V_token": ["avr", "\"/* DEBUG: cost = %d.  */\\n\"", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", "0"], "File": "avr4", "Func": "avr_final_prescan_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30394, "Length": 81}
{"ground_truth": ["<s>", "static", "rtx", "avr_find_unused_d_reg", "(", "rtx_insn", "*", "insn", ",", "rtx", "exclude", ")", "{", "int", "regno", ";", "bool", "isr_p", "=", "(", "avr_interrupt_function_p", "(", "current_function_decl", ")", "||", "avr_signal_function_p", "(", "current_function_decl", ")", ")", ";", "for", "(", "regno", "=", "16", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "rtx", "reg", "=", "all_regs_rtx", "[", "regno", "]", ";", "if", "(", "(", "exclude", "&&", "reg_overlap_mentioned_p", "(", "exclude", ",", "reg", ")", ")", "||", "fixed_regs", "[", "regno", "]", ")", "{", "continue", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", "||", "(", "!", "isr_p", "&&", "call_used_regs", "[", "regno", "]", ")", ")", ")", "{", "return", "reg", ";", "}", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "reg_unused_after", "(", "insn", ",", "reg", ")", ")", "{", "return", "reg", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Fixme", ":", "This", "is", "a", "hack", "because", "secondary", "reloads", "do", "n't", "works", "as", "expected", ".", "Find", "an", "unused", "d-register", "to", "be", "used", "as", "scratch", "in", "INSN", ".", "EXCLUDE", "is", "either", "NULL_RTX", "or", "some", "register", ".", "In", "the", "case", "where", "EXCLUDE", "is", "a", "register", ",", "skip", "all", "possible", "return", "values", "that", "overlap", "EXCLUDE", ".", "The", "policy", "for", "the", "returned", "register", "is", "similar", "to", "that", "of", "`", "reg_unused_after", "'", ",", "i.e", ".", "the", "returned", "register", "may", "overlap", "the", "SET_DEST", "of", "INSN", ".", "Return", "a", "QImode", "d-register", "or", "NULL_RTX", "if", "nothing", "found", "."], "TS_V_token": ["avr", "16", "32"], "File": "avr4", "Func": "avr_find_unused_d_reg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30395, "Length": 140}
{"ground_truth": ["<s>", "static", "rtx", "avr_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Controls", "whether", "a", "function", "argument", "is", "passed", "in", "a", "register", ",", "and", "which", "register", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_function_arg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30396, "Length": 65}
{"ground_truth": ["<s>", "static", "void", "avr_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", "&&", "!", "call_used_regs", "[", "cum", "->", "regno", "]", ")", "{", "cfun", "->", "machine", "->", "sibcall_fails", "=", "1", ";", "}", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "cum", "->", "regno", ";", "regno", "<", "cum", "->", "regno", "+", "bytes", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "warning", "(", "0", ",", "\"fixed register %s used to pass parameter to function\"", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>"], "natrual_language": ["Update", "the", "summarizer", "variable", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", "."], "TS_V_token": ["avr", "8", "0", "1", "8", "0", "0", "\"fixed register %s used to pass parameter to function\"", "0", "0"], "File": "avr4", "Func": "avr_function_arg_advance", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30397, "Length": 161}
{"ground_truth": ["<s>", "int", "avr_function_arg_regno_p", "(", "int", "r", ")", "{", "return", "(", "AVR_TINY", "?", "r", ">=", "20", "&&", "r", "<=", "25", ":", "r", ">=", "8", "&&", "r", "<=", "25", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "REGNO", "is", "the", "number", "of", "a", "hard", "register", "in", "which", "function", "arguments", "are", "sometimes", "passed", "."], "TS_V_token": ["avr", "20", "25", "8", "25"], "File": "avr4", "Func": "avr_function_arg_regno_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30398, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "avr_function_ok_for_sibcall", "(", "tree", "decl_callee", ",", "tree", "exp_callee", ")", "{", "tree", "fntype_callee", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_fails", "||", "TARGET_CALL_PROLOGUES", ")", "{", "return", "false", ";", "}", "fntype_callee", "=", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp_callee", ")", ")", ";", "if", "(", "decl_callee", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "else", "{", "decl_callee", "=", "fntype_callee", ";", "while", "(", "FUNCTION_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", "&&", "METHOD_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "}", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_naked", "||", "avr_naked_function_p", "(", "decl_callee", ")", "||", "(", "avr_OS_task_function_p", "(", "decl_callee", ")", "!=", "cfun", "->", "machine", "->", "is_OS_task", ")", "||", "(", "avr_OS_main_function_p", "(", "decl_callee", ")", "!=", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_function_ok_for_sibcall", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30399, "Length": 144}
{"ground_truth": ["<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<", "18", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "18", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "."], "TS_V_token": ["avr", "0", "18", "18"], "File": "avr4", "Func": "avr_hard_regno_call_part_clobbered", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30400, "Length": 72}
{"ground_truth": ["<s>", "int", "avr_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "1", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "&&", "regno", ">=", "REG_X", ")", "return", "0", ";", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "a", "value", "of", "mode", "MODE", "can", "be", "stored", "starting", "with", "hard", "register", "number", "REGNO", ".", "On", "the", "enhanced", "core", ",", "anything", "larger", "than", "1", "byte", "must", "start", "in", "even", "numbered", "register", "for", "``", "movw", "''", "to", "work", "(", "this", "way", "we", "do", "n't", "have", "to", "check", "for", "odd", "registers", "everywhere", ")", "."], "TS_V_token": ["avr", "1", "1", "4", "0", "1"], "File": "avr4", "Func": "avr_hard_regno_mode_ok", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30401, "Length": 47}
{"ground_truth": ["<s>", "bool", "avr_has_nibble_0xf", "(", "rtx", "ival", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "ival", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "return", "0", "!=", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "IVAL", "has", "a", "0xf", "in", "its", "hexadecimal", "representation", "and", "false", ",", "otherwise", ".", "Only", "nibbles", "0", "..", "7", "are", "taken", "into", "account", ".", "Used", "as", "constraint", "helper", "for", "C0f", "and", "Cxf", "."], "TS_V_token": ["avr", "0"], "File": "avr4", "Func": "avr_has_nibble_0xf", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30402, "Length": 32}
{"ground_truth": ["<s>", "void", "avr_init_expanders", "(", "void", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "all_regs_rtx", "[", "regno", "]", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "lpm_reg_rtx", "=", "all_regs_rtx", "[", "LPM_REGNO", "]", ";", "tmp_reg_rtx", "=", "all_regs_rtx", "[", "AVR_TMP_REGNO", "]", ";", "zero_reg_rtx", "=", "all_regs_rtx", "[", "AVR_ZERO_REGNO", "]", ";", "lpm_addr_reg_rtx", "=", "gen_rtx_REG", "(", "HImode", ",", "REG_Z", ")", ";", "sreg_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "sreg", ")", ")", ";", "rampd_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampd", ")", ")", ";", "rampx_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampx", ")", ")", ";", "rampy_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampy", ")", ")", ";", "rampz_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "xstring_empty", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"\"", ")", ";", "xstring_e", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"e\"", ")", ";", "if", "(", "AVR_TINY", ")", "avr_have_dimode", "=", "false", ";", "}", "</s>"], "natrual_language": ["The", "function", "works", "like", "a", "singleton", "."], "TS_V_token": ["avr", "0", "32", "\"\"", "\"e\""], "File": "avr4", "Func": "avr_init_expanders", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30403, "Length": 161}
{"ground_truth": ["<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "avr_pgm_check_var_decl", "(", "node", ")", ";", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "addr_space_t", "as", ";", "tree", "node0", "=", "node", ";", "do", "node0", "=", "TREE_TYPE", "(", "node0", ")", ";", "while", "(", "TREE_CODE", "(", "node0", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "error_mark_node", "==", "node0", ")", "return", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "node", ")", ")", ";", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "error", "(", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_n_flash", ")", ";", "}", "else", "if", "(", "!", "AVR_HAVE_LPM", "&&", "avr_addrspace", "[", "as", "]", ".", "pointer_size", ">", "2", ")", "{", "error", "(", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_arch", "->", "name", ")", ";", "}", "if", "(", "!", "TYPE_READONLY", "(", "node0", ")", "&&", "!", "TREE_READONLY", "(", "node", ")", ")", "{", "const", "char", "*", "reason", "=", "\"__attribute__((progmem))\"", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "reason", "=", "avr_addrspace", "[", "as", "]", ".", "name", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%?: %t\\n%t\\n\"", ",", "node", ",", "node0", ")", ";", "error", "(", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"", ",", "node", ",", "reason", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "."], "TS_V_token": ["avr", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", "2", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", "\"__attribute__((progmem))\"", "\"\\n%?: %t\\n%t\\n\"", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\""], "File": "avr4", "Func": "avr_insert_attributes", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30404, "Length": 224}
{"ground_truth": ["<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "-", "63", "<=", "jump_distance", "&&", "jump_distance", "<=", "62", ")", "return", "1", ";", "else", "if", "(", "-", "2046", "<=", "jump_distance", "&&", "jump_distance", "<=", "2045", ")", "return", "2", ";", "else", "if", "(", "AVR_HAVE_JMP_CALL", ")", "return", "3", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "."], "TS_V_token": ["avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2"], "File": "avr4", "Func": "avr_jump_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30405, "Length": 95}
{"ground_truth": ["<s>", "static", "bool", "avr_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "bool", "ok", "=", "CONSTANT_ADDRESS_P", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "x", ",", "ADDR_SPACE_GENERIC", ",", "MEM", ",", "strict", ")", ";", "if", "(", "strict", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "REG_X", "==", "REGNO", "(", "x", ")", ")", "{", "ok", "=", "false", ";", "}", "break", ";", "case", "POST_INC", ":", "case", "PRE_DEC", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "ADDR_SPACE_GENERIC", ",", "GET_CODE", "(", "x", ")", ",", "strict", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "reg", ")", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "INTVAL", "(", "op1", ")", ">=", "0", ")", "{", "bool", "fit", "=", "IN_RANGE", "(", "INTVAL", "(", "op1", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", ";", "if", "(", "fit", ")", "{", "ok", "=", "(", "!", "strict", "||", "avr_reg_ok_for_addr_p", "(", "reg", ",", "ADDR_SPACE_GENERIC", ",", "PLUS", ",", "strict", ")", ")", ";", "if", "(", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "arg_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "else", "if", "(", "frame_pointer_needed", "&&", "reg", "==", "frame_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "}", "break", ";", "default", ":", "break", ";", "}", "if", "(", "AVR_TINY", "&&", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "ok", "=", "(", "CONST_INT_P", "(", "x", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "0xc0", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "}", "if", "(", "avr_log", ".", "legitimate_address_p", ")", "{", "avr_edump", "(", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", ",", "ok", ",", "mode", ",", "strict", ",", "reload_completed", ",", "reload_in_progress", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", "&&", "reg_renumber", ")", "{", "avr_edump", "(", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "avr_edump", "(", "\"\\n%r\\n\"", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "X", "(", "an", "RTX", ")", "is", "a", "legitimate", "memory", "address", "on", "the", "target", "machine", "for", "a", "memory", "operand", "of", "mode", "MODE", "."], "TS_V_token": ["avr", "4", "0", "0", "1", "0", "0", "0", "0xc0", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "\"(r%d ---> r%d)\"", "0", "0", "\"\\n%r\\n\""], "File": "avr4", "Func": "avr_legitimate_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30406, "Length": 383}
{"ground_truth": ["<s>", "static", "rtx", "avr_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "bool", "big_offset_p", "=", "false", ";", "x", "=", "oldx", ";", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", "&&", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "big_offset_p", "=", "true", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "if", "(", "avr_log", ".", "legitimize_address", ")", "{", "avr_edump", "(", "\"\\n%?: mode=%m\\n %r\\n\"", ",", "mode", ",", "oldx", ")", ";", "if", "(", "x", "!=", "oldx", ")", "avr_edump", "(", "\" %s --> %r\\n\"", ",", "big_offset_p", "?", "\"(big offset)\"", ":", "\"\"", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>"], "natrual_language": ["Attempts", "to", "replace", "X", "with", "a", "valid", "memory", "address", "for", "an", "operand", "of", "mode", "MODE"], "TS_V_token": ["avr", "0", "1", "1", "1", "0", "\"\\n%?: mode=%m\\n %r\\n\"", "\" %s --> %r\\n\"", "\"(big offset)\"", "\"\""], "File": "avr4", "Func": "avr_legitimize_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30407, "Length": 172}
{"ground_truth": ["<s>", "rtx", "avr_legitimize_reload_address", "(", "rtx", "*", "px", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "addr_type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ",", "rtx", "(", "*", "mk_memloc", ")", "(", "rtx", ",", "int", ")", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\"\\n%?:%m %r\\n\"", ",", "mode", ",", "x", ")", ";", "if", "(", "1", "&&", "(", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "0", ",", "0", ",", "opnum", ",", "RELOAD_OTHER", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "0", "==", "reg_equiv_constant", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "1", ")", "{", "bool", "fit", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", ";", "if", "(", "fit", ")", "{", "if", "(", "reg_equiv_address", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "!=", "0", ")", "{", "int", "regno", "=", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "rtx", "mem", "=", "mk_memloc", "(", "x", ",", "regno", ")", ";", "push_reload", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL", ",", "POINTER_REGS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "1", ",", "(", "enum", "reload_type", ")", "addr_type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ")", ";", "push_reload", "(", "mem", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "BASE_POINTER_REGS", ",", "mem", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "else", "if", "(", "!", "(", "frame_pointer_needed", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", ")", ")", "{", "push_reload", "(", "x", ",", "NULL_RTX", ",", "px", ",", "NULL", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "x", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["This", "will", "allow", "register", "R26/27", "to", "be", "used", "where", "it", "is", "no", "worse", "than", "normal", "base", "pointers", "R28/29", "or", "R30/31", ".", "For", "example", ",", "if", "base", "offset", "is", "greater", "than", "63", "bytes", "or", "for", "R++", "or", "--", "R", "addressing", "."], "TS_V_token": ["avr", "\"\\n%?:%m %r\\n\"", "1", "0", "0", "0", "0", "0", "0", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\""], "File": "avr4", "Func": "avr_legitimize_reload_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30408, "Length": 480}
{"ground_truth": ["<s>", "static", "avr_map_op_t", "avr_map_decompose", "(", "unsigned", "int", "f", ",", "const", "avr_map_op_t", "*", "g", ",", "bool", "val_const_p", ")", "{", "int", "i", ";", "bool", "val_used_p", "=", "0", "!=", "avr_map_metric", "(", "f", ",", "MAP_MASK_PREIMAGE_F", ")", ";", "avr_map_op_t", "f_ginv", "=", "*", "g", ";", "unsigned", "int", "ginv", "=", "g", "->", "ginv", ";", "f_ginv", ".", "cost", "=", "-", "1", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "x", "=", "avr_map", "(", "f", ",", "i", ")", ";", "if", "(", "x", "<=", "7", ")", "{", "x", "=", "avr_map", "(", "ginv", ",", "x", ")", ";", "if", "(", "x", ">", "7", ")", "return", "f_ginv", ";", "}", "f_ginv", ".", "map", "=", "(", "f_ginv", ".", "map", "<<", "4", ")", "+", "x", ";", "}", "if", "(", "0", "==", "avr_map_metric", "(", "f_ginv", ".", "map", ",", "MAP_NONFIXED_0_7", ")", ")", "{", "f_ginv", ".", "cost", "=", "2", "+", "(", "val_used_p", "&&", "!", "val_const_p", ")", ";", "}", "else", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "all_regs_rtx", "[", "24", "]", ";", "xop", "[", "1", "]", "=", "gen_int_mode", "(", "f_ginv", ".", "map", ",", "SImode", ")", ";", "xop", "[", "2", "]", "=", "all_regs_rtx", "[", "25", "]", ";", "xop", "[", "3", "]", "=", "val_used_p", "?", "xop", "[", "0", "]", ":", "const0_rtx", ";", "avr_out_insert_bits", "(", "xop", ",", "&", "f_ginv", ".", "cost", ")", ";", "f_ginv", ".", "cost", "+=", "val_const_p", "&&", "val_used_p", "?", "1", ":", "0", ";", "}", "f_ginv", ".", "cost", "+=", "g", "->", "cost", ";", "if", "(", "avr_log", ".", "builtin", ")", "avr_edump", "(", "\" %s%d=%d\"", ",", "g", "->", "str", ",", "g", "->", "arg", ",", "f_ginv", ".", "cost", ")", ";", "return", "f_ginv", ";", "}", "</s>"], "natrual_language": ["Try", "to", "decompose", "F", "as", "F", "=", "(", "F", "o", "G^-1", ")", "o", "G", "as", "described", "above", ".", "The", "result", "is", "a", "struct", "representing", "F", "o", "G^-1", "and", "G.", "If", "result.cost", "<", "0", "then", "such", "a", "decomposition", "does", "not", "exist", "."], "TS_V_token": ["avr", "0", "1", "7", "0", "7", "7", "4", "0", "2", "4", "0", "24", "1", "2", "25", "3", "0", "1", "0", "\" %s%d=%d\""], "File": "avr4", "Func": "avr_map_decompose", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30409, "Length": 260}
{"ground_truth": ["<s>", "static", "void", "avr_move_bits", "(", "rtx", "*", "xop", ",", "unsigned", "int", "map", ",", "bool", "fixp_p", ",", "int", "*", "plen", ")", "{", "int", "bit_dest", ",", "b", ";", "int", "t_bit_src", "=", "-", "1", ";", "for", "(", "b", "=", "0", ";", "b", "<", "8", ";", "b", "++", ")", "for", "(", "bit_dest", "=", "0", ";", "bit_dest", "<", "8", ";", "bit_dest", "++", ")", "{", "int", "bit_src", "=", "avr_map", "(", "map", ",", "bit_dest", ")", ";", "if", "(", "b", "!=", "bit_src", "||", "bit_src", ">=", "8", "||", "(", "bit_dest", "==", "bit_src", "&&", "!", "fixp_p", ")", ")", "continue", ";", "if", "(", "t_bit_src", "!=", "bit_src", ")", "{", "t_bit_src", "=", "bit_src", ";", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_src", ")", ";", "avr_asm_len", "(", "\"bst %T1%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_dest", ")", ";", "avr_asm_len", "(", "\"bld %T0%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "}", "</s>"], "natrual_language": ["Insert", "bits", "from", "XOP", "[", "1", "]", "into", "XOP", "[", "0", "]", "according", "to", "MAP", ".", "XOP", "[", "0", "]", "and", "XOP", "[", "1", "]", "do", "n't", "overlap", ".", "If", "FIXP_P", "=", "true", ":", "Move", "all", "bits", "according", "to", "MAP", "using", "BLD/BST", "sequences", ".", "If", "FIXP_P", "=", "false", ":", "Just", "move", "the", "bit", "if", "its", "position", "in", "the", "destination", "is", "different", "to", "its", "source", "position", "."], "TS_V_token": ["avr", "1", "0", "8", "0", "8", "8", "3", "\"bst %T1%T3\"", "1", "3", "\"bld %T0%T3\"", "1"], "File": "avr4", "Func": "avr_move_bits", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30410, "Length": 145}
{"ground_truth": ["<s>", "static", "addr_space_t", "avr_nonconst_pointer_addrspace", "(", "tree", "typ", ")", "{", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "typ", ")", ")", "typ", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "typ", ")", ")", "{", "addr_space_t", "as", ";", "tree", "target", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "FUNCTION_TYPE", "==", "TREE_CODE", "(", "target", ")", ")", "return", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "target", ")", ")", ";", "while", "(", "TREE_CODE", "(", "target", ")", "==", "ARRAY_TYPE", ")", "target", "=", "TREE_TYPE", "(", "target", ")", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "target", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", "&&", "(", "!", "TYPE_READONLY", "(", "target", ")", "||", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", "||", "(", "!", "AVR_HAVE_LPM", "&&", "avr_addrspace", "[", "as", "]", ".", "pointer_size", ">", "2", ")", ")", ")", "{", "return", "as", ";", "}", "return", "avr_nonconst_pointer_addrspace", "(", "target", ")", ";", "}", "return", "ADDR_SPACE_GENERIC", ";", "}", "</s>"], "natrual_language": ["Scan", "type", "TYP", "for", "pointer", "references", "to", "address", "space", "ASn", ".", "Return", "ADDR_SPACE_GENERIC", "(", "i.e", ".", "0", ")", "if", "all", "pointers", "targeting", "the", "AS", "are", "also", "declared", "to", "be", "CONST", ".", "Otherwise", ",", "return", "the", "respective", "address", "space", ",", "i.e", ".", "a", "value", "!", "=", "0", "."], "TS_V_token": ["avr", "2"], "File": "avr4", "Func": "avr_nonconst_pointer_addrspace", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30411, "Length": 139}
{"ground_truth": ["<s>", "void", "avr_notice_update_cc", "(", "rtx", "body", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", ";", "enum", "attr_cc", "cc", "=", "get_attr_cc", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "break", ";", "case", "CC_PLUS", ":", "case", "CC_LDI", ":", "{", "rtx", "*", "op", "=", "recog_data", ".", "operand", ";", "int", "len_dummy", ",", "icc", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CC_PLUS", ":", "avr_out_plus", "(", "insn", ",", "op", ",", "&", "len_dummy", ",", "&", "icc", ")", ";", "cc", "=", "(", "enum", "attr_cc", ")", "icc", ";", "break", ";", "case", "CC_LDI", ":", "cc", "=", "(", "op", "[", "1", "]", "==", "CONST0_RTX", "(", "GET_MODE", "(", "op", "[", "0", "]", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "zero_reg_rtx", ")", ")", "?", "CC_CLOBBER", ":", "CC_NONE", ";", "break", ";", "}", "break", ";", "}", "}", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "CC_NONE", ":", "break", ";", "case", "CC_SET_N", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_ZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_SET_VZN", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_CZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Update", "the", "condition", "code", "in", "the", "INSN", "."], "TS_V_token": ["avr", "1", "0", "0"], "File": "avr4", "Func": "avr_notice_update_cc", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30412, "Length": 277}
{"ground_truth": ["<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ",", "int", "opno", ",", "bool", "speed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_FIXED", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "code", ",", "outer", ",", "opno", ",", "&", "total", ",", "speed", ")", ";", "return", "total", ";", "}", "</s>"], "natrual_language": ["Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr4", "Func": "avr_operand_rtx_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30413, "Length": 94}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "avr_register_passes", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "0", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr4", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30414, "Length": 198}
{"ground_truth": ["<s>", "static", "inline", "int", "avr_outgoing_args_size", "(", "void", ")", "{", "return", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ";", "}", "</s>"], "natrual_language": ["Report", "contribution", "of", "accumulated", "outgoing", "arguments", "to", "stack", "size", "."], "TS_V_token": ["avr", "0"], "File": "avr4", "Func": "avr_outgoing_args_size", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30415, "Length": 18}
{"ground_truth": ["<s>", "void", "avr_output_addr_vec_elt", "(", "FILE", "*", "stream", ",", "int", "value", ")", "{", "if", "(", "AVR_HAVE_JMP_CALL", ")", "fprintf", "(", "stream", ",", "\"\\t.word gs(.L%d)\\n\"", ",", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\trjmp .L%d\\n\"", ",", "value", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "`", "ASM_OUTPUT_ADDR_VEC_ELT", "'", "."], "TS_V_token": ["avr", "\"\\t.word gs(.L%d)\\n\"", "\"\\trjmp .L%d\\n\""], "File": "avr4", "Func": "avr_output_addr_vec_elt", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30416, "Length": 35}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_addto_sp", "(", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "int", "pc_len", "=", "AVR_2_BYTE_PC", "?", "2", ":", "3", ";", "int", "addend", "=", "INTVAL", "(", "op", "[", "0", "]", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "addend", "<", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP -= %n0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "<=", "-", "pc_len", ")", "{", "addend", "+=", "pc_len", ";", "avr_asm_len", "(", "\"rcall .\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "while", "(", "addend", "++", "<", "0", ")", "avr_asm_len", "(", "\"push __zero_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "addend", ">", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP += %0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "--", ">", "0", ")", "avr_asm_len", "(", "\"pop __tmp_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["PLEN", "==", "NULL", ":", "Output", "code", "to", "add", "CONST_INT", "OP", "[", "0", "]", "to", "SP", ".", "PLEN", "!", "=", "NULL", ":", "Set", "*", "PLEN", "to", "the", "length", "of", "that", "sequence", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "2", "3", "0", "0", "0", "\"SP -= %n0\"", "0", "\"rcall .\"", "1", "0", "\"push __zero_reg__\"", "1", "0", "\"SP += %0\"", "0", "0", "\"pop __tmp_reg__\"", "1", "\"\""], "File": "avr4", "Func": "avr_out_addto_sp", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30417, "Length": 160}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_load_psi_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", "CR_TAB", "\"ld %C0,%1\"", "CR_TAB", "\"ld __tmp_reg__,-%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %A0,%1\"", "CR_TAB", "\"mov %B0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "8", ")", ";", "}", "else", "{", "return", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1+\"", "CR_TAB", "\"ld %C0,%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "reg_dest", "!=", "reg_base", "-", "2", "&&", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "{", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "return", "\"\"", ";", "}", "}", "</s>"], "natrual_language": ["Handle", "loads", "of", "24-bit", "types", "from", "memory", "to", "register", "."], "TS_V_token": ["avr", "0", "1", "0", "2", "\"ld %C0,%1\"", "\"ld __tmp_reg__,-%1\"", "1", "\"ld %A0,%1\"", "\"mov %B0,__tmp_reg__\"", "8", "\"ld %A0,%1+\"", "\"ld %B0,%1+\"", "\"ld %C0,%1\"", "3", "2", "2", "2", "\"\""], "File": "avr4", "Func": "avr_out_load_psi_reg_no_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30418, "Length": 172}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_disp_tiny", "(", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld __tmp_reg__,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "}", "else", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %A0,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", "CR_TAB", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", "+", "1", ")", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "}", "</s>"], "natrual_language": ["Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD"], "TS_V_token": ["avr", "0", "1", "0", "0", "\"ld __tmp_reg__,%b1+\"", "\"ld %B0,%b1\"", "\"mov %A0,__tmp_reg__\"", "5", "\"ld %A0,%b1+\"", "\"ld %B0,%b1\"", "1", "6"], "File": "avr4", "Func": "avr_out_movhi_r_mr_reg_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30419, "Length": 145}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_no_disp_tiny", "(", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_dest", "==", "reg_base", ")", "return", "avr_asm_len", "(", "\"ld __tmp_reg__,%1+\"", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "return", "avr_asm_len", "(", "\"ld %A0,%1\"", "CR_TAB", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "</s>"], "natrual_language": ["Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD"], "TS_V_token": ["avr", "0", "1", "0", "\"ld __tmp_reg__,%1+\"", "\"ld %B0,%1\"", "\"mov %A0,__tmp_reg__\"", "3", "\"ld %A0,%1\"", "1", "\"ld %B0,%1\"", "1", "6"], "File": "avr4", "Func": "avr_out_movhi_r_mr_reg_no_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30420, "Length": 119}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_movmem", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "addr_space_t", "as", "=", "(", "addr_space_t", ")", "INTVAL", "(", "op", "[", "0", "]", ")", ";", "machine_mode", "loop_mode", "=", "GET_MODE", "(", "op", "[", "1", "]", ")", ";", "bool", "sbiw_p", "=", "test_hard_reg_class", "(", "ADDW_REGS", ",", "op", "[", "1", "]", ")", ";", "rtx", "xop", "[", "3", "]", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "xop", "[", "0", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "1", "]", "=", "op", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "tmp_reg_rtx", ";", "avr_asm_len", "(", "\"0:\"", ",", "xop", ",", "plen", ",", "0", ")", ";", "switch", "(", "as", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ADDR_SPACE_GENERIC", ":", "avr_asm_len", "(", "\"ld %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH", ":", "if", "(", "AVR_HAVE_LPMX", ")", "avr_asm_len", "(", "\"lpm %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "else", "avr_asm_len", "(", "\"lpm\"", "CR_TAB", "\"adiw r30,1\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH1", ":", "case", "ADDR_SPACE_FLASH2", ":", "case", "ADDR_SPACE_FLASH3", ":", "case", "ADDR_SPACE_FLASH4", ":", "case", "ADDR_SPACE_FLASH5", ":", "if", "(", "AVR_HAVE_ELPMX", ")", "avr_asm_len", "(", "\"elpm %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "else", "avr_asm_len", "(", "\"elpm\"", "CR_TAB", "\"adiw r30,1\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "break", ";", "}", "avr_asm_len", "(", "\"st X+,%2\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "if", "(", "QImode", "==", "loop_mode", ")", "{", "avr_asm_len", "(", "\"dec %1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "sbiw_p", ")", "{", "avr_asm_len", "(", "\"sbiw %1,1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"subi %A1,1\"", "CR_TAB", "\"sbci %B1,0\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "}", "return", "avr_asm_len", "(", "\"brne 0b\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "</s>"], "natrual_language": ["Print", "assembler", "for", "movmem_qi", ",", "movmem_hi", "insns", "...", "$", "0", ":", "Address", "Space", "$", "1", ",", "$", "2", ":", "Loop", "register", "Z", ":", "Source", "address", "X", ":", "Destination", "address"], "TS_V_token": ["avr", "0", "1", "1", "3", "0", "0", "0", "1", "1", "2", "\"0:\"", "0", "\"ld %2,Z+\"", "1", "\"lpm %2,Z+\"", "1", "\"lpm\"", "\"adiw r30,1\"", "2", "\"elpm %2,Z+\"", "1", "\"elpm\"", "\"adiw r30,1\"", "2", "\"st X+,%2\"", "1", "\"dec %1\"", "1", "\"sbiw %1,1\"", "1", "\"subi %A1,1\"", "\"sbci %B1,0\"", "2", "\"brne 0b\"", "1"], "File": "avr4", "Func": "avr_out_movmem", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30421, "Length": 295}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movqi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "x", "=", "XEXP", "(", "src", ",", "0", ")", ";", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %0,%b1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "dest", ",", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Same", "as", "out_movqi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", "or", "SBIW"], "TS_V_token": ["avr", "0", "1", "0", "\"ld %0,%b1\"", "3", "0", "0", "2", "\"\""], "File": "avr4", "Func": "avr_out_movqi_r_mr_reg_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30422, "Length": 123}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xop", "[", "0", "]", ")", ";", "machine_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "."], "TS_V_token": ["avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\""], "File": "avr4", "Func": "avr_out_round", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30423, "Length": 356}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_store_psi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "int", "n_words", "=", "AVR_TINY", "?", "3", ":", "6", ";", "return", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", "CR_TAB", "\"sts %m0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "n_words", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_no_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "base", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"st %0+,%A1\"", "CR_TAB", "\"st %0+,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "\"sbiw r26,2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "else", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", "CR_TAB", "\"std %0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_disp_tiny", "(", "op", ",", "plen", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "if", "(", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "return", "avr_asm_len", "(", "\"adiw r28,%o0-61\"", "CR_TAB", "\"std Y+61,%A1\"", "CR_TAB", "\"std Y+62,%B1\"", "CR_TAB", "\"std Y+63,%C1\"", "CR_TAB", "\"sbiw r28,%o0-61\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "return", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"std Y+2,%C1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "7", ")", ";", "}", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "XEXP", "(", "base", ",", "0", ")", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X+,%B1\"", "CR_TAB", "\"st X,%C1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "\"sbiw r26,%o0+2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", "CR_TAB", "\"std %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "return", "avr_asm_len", "(", "\"st %0,%C1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Handle", "store", "of", "24-bit", "type", "from", "register", "or", "zero", "to", "memory", "."], "TS_V_token": ["avr", "0", "1", "0", "3", "6", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "\"sts %m0+2,%C1\"", "0", "\"st %0+,%A1\"", "\"st %0+,%B1\"", "\"st %0,%C1\"", "3", "\"sbiw r26,2\"", "1", "\"\"", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "\"std %0+2,%C1\"", "3", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-61\"", "\"std Y+61,%A1\"", "\"std Y+62,%B1\"", "\"std Y+63,%C1\"", "\"sbiw r28,%o0-61\"", "5", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"std Y+2,%C1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "7", "0", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X+,%B1\"", "\"st X,%C1\"", "4", "0", "\"sbiw r26,%o0+2\"", "1", "\"\"", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "\"std %C0,%C1\"", "3", "\"st %0,%C1\"", "\"st %0,%B1\"", "\"st %0,%A1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "\"st %0,%C1\"", "3", "\"unknown move insn:\"", "\"\""], "File": "avr4", "Func": "avr_out_store_psi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30424, "Length": 476}
{"ground_truth": ["<s>", "static", "bool", "avr_pgm_check_var_decl", "(", "tree", "node", ")", "{", "const", "char", "*", "reason", "=", "NULL", ";", "addr_space_t", "as", "=", "ADDR_SPACE_GENERIC", ";", "gcc_assert", "(", "as", "==", "0", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"%?: %t\\n\"", ",", "node", ")", ";", "switch", "(", "TREE_CODE", "(", "node", ")", ")", "{", "default", ":", "break", ";", "case", "VAR_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"variable\"", ";", "break", ";", "case", "PARM_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"function parameter\"", ";", "break", ";", "case", "FIELD_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"structure field\"", ";", "break", ";", "case", "FUNCTION_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", ")", ")", ")", ",", "as", ")", "reason", "=", "\"return type of function\"", ";", "break", ";", "case", "POINTER_TYPE", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "node", ")", ",", "as", ")", "reason", "=", "\"pointer\"", ";", "break", ";", "}", "if", "(", "reason", ")", "{", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"%qT uses address space %qs beyond flash of %d KiB\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_n_flash", ")", ";", "else", "error", "(", "\"%s %q+D uses address space %qs beyond flash of %d KiB\"", ",", "reason", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_n_flash", ")", ";", "}", "else", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"pointer targeting address space %qs must be const in %qT\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "node", ")", ";", "else", "error", "(", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "reason", ",", "node", ")", ";", "}", "}", "return", "reason", "==", "NULL", ";", "}", "</s>"], "natrual_language": ["Sanity", "check", "NODE", "so", "that", "all", "pointers", "targeting", "non-generic", "address", "spaces", "go", "along", "with", "CONST", "qualifier", ".", "Writing", "to", "these", "address", "spaces", "should", "be", "detected", "and", "complained", "about", "as", "early", "as", "possible", "."], "TS_V_token": ["avr", "0", "\"%?: %t\\n\"", "\"variable\"", "\"function parameter\"", "\"structure field\"", "\"return type of function\"", "\"pointer\"", "\"%qT uses address space %qs beyond flash of %d KiB\"", "\"%s %q+D uses address space %qs beyond flash of %d KiB\"", "\"pointer targeting address space %qs must be const in %qT\"", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\""], "File": "avr4", "Func": "avr_pgm_check_var_decl", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30425, "Length": 277}
{"ground_truth": ["<s>", "static", "inline", "int", "avr_popcount", "(", "unsigned", "int", "val", ")", "{", "int", "pop", "=", "0", ";", "while", "(", "val", ")", "{", "val", "&=", "val", "-", "1", ";", "pop", "++", ";", "}", "return", "pop", ";", "}", "</s>"], "natrual_language": ["Custom", "function", "to", "count", "number", "of", "set", "bits", "."], "TS_V_token": ["avr", "0", "1"], "File": "avr4", "Func": "avr_popcount", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30426, "Length": 34}
{"ground_truth": ["<s>", "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "0", "==", "(", "pop_mask", "&", "(", "1", "<<", "avr_popcount", "(", "val8", ")", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "."], "TS_V_token": ["avr", "0", "0", "1"], "File": "avr4", "Func": "avr_popcount_each_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30427, "Length": 101}
{"ground_truth": ["<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "ADDR", "to", "FILE", "as", "address", "."], "TS_V_token": ["avr", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\""], "File": "avr4", "Func": "avr_print_operand_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30428, "Length": 255}
{"ground_truth": ["<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "reg", ",", "count", ";", "int", "int_or_sig_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", "return", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "(", "REG_Y", "+", "1", ")", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>"], "natrual_language": ["Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "."], "TS_V_token": ["avr", "0", "0", "0", "32", "1"], "File": "avr4", "Func": "avr_regs_to_save", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30429, "Length": 162}
{"ground_truth": ["<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "avr_compare_pattern", "(", "insn", ")", ";", "if", "(", "!", "pattern", ")", "continue", ";", "if", "(", "optimize", "&&", "avr_reorg_remove_redundant_compare", "(", "insn", ")", ")", "{", "continue", ";", "}", "if", "(", "compare_diff_p", "(", "insn", ")", ")", "{", "rtx", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "XEXP", "(", "pattern", ",", "1", ")", "==", "const0_rtx", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "const0_rtx", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "}", "</s>"], "natrual_language": ["This", "function", "optimizes", "conditional", "jumps", "."], "TS_V_token": ["avr", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1"], "File": "avr4", "Func": "avr_reorg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30430, "Length": 424}
{"ground_truth": ["<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>"], "natrual_language": ["Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "."], "TS_V_token": ["avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "8"], "File": "avr4", "Func": "avr_return_addr_rtx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30431, "Length": 96}
{"ground_truth": ["<s>", "static", "bool", "avr_rtx_costs", "(", "rtx", "x", ",", "int", "codearg", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "done", "=", "avr_rtx_costs_1", "(", "x", ",", "codearg", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "avr_edump", "(", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", ",", "done", ",", "speed", "?", "\"speed\"", ":", "\"size\"", ",", "*", "total", ",", "outer_code", ",", "x", ")", ";", "}", "return", "done", ";", "}", "</s>"], "natrual_language": ["The", "AVR", "backend", "'s", "rtx_cost", "function", ".", "X", "is", "rtx", "expression", "whose", "cost", "is", "to", "be", "calculated", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "."], "TS_V_token": ["avr", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", "\"speed\"", "\"size\""], "File": "avr4", "Func": "avr_rtx_costs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30432, "Length": 74}
{"ground_truth": ["<s>", "static", "bool", "avr_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "PSImode", "==", "mode", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_SCALAR_MODE_SUPPORTED_P", "'", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_scalar_mode_supported_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30433, "Length": 34}
{"ground_truth": ["<s>", "static", "reg_class_t", "avr_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "reload_class", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "if", "(", "in_p", "&&", "MEM_P", "(", "x", ")", "&&", "!", "ADDR_SPACE_GENERIC_P", "(", "MEM_ADDR_SPACE", "(", "x", ")", ")", "&&", "ADDR_SPACE_MEMX", "!=", "MEM_ADDR_SPACE", "(", "x", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "QImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inqi", ";", "break", ";", "case", "QQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inqq", ";", "break", ";", "case", "UQQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inuqq", ";", "break", ";", "case", "HImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inhi", ";", "break", ";", "case", "HQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inhq", ";", "break", ";", "case", "HAmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inha", ";", "break", ";", "case", "UHQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inuhq", ";", "break", ";", "case", "UHAmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inuha", ";", "break", ";", "case", "PSImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inpsi", ";", "break", ";", "case", "SImode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insi", ";", "break", ";", "case", "SFmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insf", ";", "break", ";", "case", "SQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insq", ";", "break", ";", "case", "SAmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_insa", ";", "break", ";", "case", "USQmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inusq", ";", "break", ";", "case", "USAmode", ":", "sri", "->", "icode", "=", "CODE_FOR_reload_inusa", ";", "break", ";", "}", "}", "return", "NO_REGS", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_SECONDARY_RELOAD", "'"], "TS_V_token": ["avr"], "File": "avr4", "Func": "avr_secondary_reload", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30434, "Length": 230}
{"ground_truth": ["<s>", "static", "bool", "avr_set_core_architecture", "(", "void", ")", "{", "if", "(", "!", "avr_mmcu", ")", "avr_mmcu", "=", "AVR_MMCU_DEFAULT", ";", "avr_arch", "=", "&", "avr_arch_types", "[", "0", "]", ";", "for", "(", "const", "avr_mcu_t", "*", "mcu", "=", "avr_mcu_types", ";", ";", "mcu", "++", ")", "{", "if", "(", "NULL", "==", "mcu", "->", "name", ")", "{", "error", "(", "\"unknown core architecture %qs specified with %qs\"", ",", "avr_mmcu", ",", "\"-mmcu=\"", ")", ";", "avr_inform_core_architectures", "(", ")", ";", "break", ";", "}", "else", "if", "(", "0", "==", "strcmp", "(", "mcu", "->", "name", ",", "avr_mmcu", ")", "&&", "NULL", "==", "mcu", "->", "macro", ")", "{", "avr_arch", "=", "&", "avr_arch_types", "[", "mcu", "->", "arch_id", "]", ";", "if", "(", "avr_n_flash", "<", "0", ")", "avr_n_flash", "=", "mcu", "->", "n_flash", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Set", "`", "avr_arch", "'", "as", "specified", "by", "`", "-mmcu=", "'", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["avr", "0", "\"unknown core architecture %qs specified with %qs\"", "\"-mmcu=\"", "0", "0"], "File": "avr4", "Func": "avr_set_core_architecture", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30435, "Length": 115}
{"ground_truth": ["<s>", "static", "void", "avr_set_current_function", "(", "tree", "decl", ")", "{", "location_t", "loc", ";", "const", "char", "*", "isr", ";", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "loc", "=", "DECL_SOURCE_LOCATION", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_naked", "=", "avr_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_signal", "=", "avr_signal_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_interrupt", "=", "avr_interrupt_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_task", "=", "avr_OS_task_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_main", "=", "avr_OS_main_function_p", "(", "decl", ")", ";", "isr", "=", "cfun", "->", "machine", "->", "is_interrupt", "?", "\"interrupt\"", ":", "\"signal\"", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_task", "+", "cfun", "->", "machine", "->", "is_OS_main", "+", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ">", "1", ")", "error_at", "(", "loc", ",", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", "&&", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wattributes", ",", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "\"naked\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "const", "char", "*", "name", ";", "name", "=", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ":", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "cfun", "->", "machine", "->", "is_signal", "=", "0", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot have arguments\"", ",", "isr", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot return a value\"", ",", "isr", ")", ";", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__vector\"", ")", ")", "warning_at", "(", "loc", ",", "0", ",", "\"%qs appears to be a misspelled %s handler\"", ",", "name", ",", "isr", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>"], "natrual_language": ["Sanity", "cheching", "for", "above", "function", "attributes", "."], "TS_V_token": ["avr", "\"interrupt\"", "\"signal\"", "1", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", "\"OS_task\"", "\"OS_main\"", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", "\"OS_task\"", "\"OS_main\"", "\"naked\"", "0", "\"%qs function cannot have arguments\"", "\"%qs function cannot return a value\"", "\"__vector\"", "0", "\"%qs appears to be a misspelled %s handler\"", "1"], "File": "avr4", "Func": "avr_set_current_function", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30436, "Length": 361}
{"ground_truth": ["<s>", "int", "avr_starting_frame_offset", "(", "void", ")", "{", "return", "1", "+", "avr_outgoing_args_size", "(", ")", ";", "}", "</s>"], "natrual_language": ["This", "is", "the", "offset", "from", "the", "frame", "pointer", "register", "to", "the", "first", "stack", "slot", "that", "contains", "a", "variable", "living", "in", "the", "frame", "."], "TS_V_token": ["avr", "1"], "File": "avr4", "Func": "avr_starting_frame_offset", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30437, "Length": 14}
{"ground_truth": ["<s>", "rtx", "avr_to_int_mode", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "return", "VOIDmode", "==", "mode", "?", "x", ":", "simplify_gen_subreg", "(", "int_mode_for_mode", "(", "mode", ")", ",", "x", ",", "mode", ",", "0", ")", ";", "}", "</s>"], "natrual_language": ["Access", "some", "RTX", "as", "INT_MODE", ".", "If", "X", "is", "a", "CONST_FIXED", "we", "can", "get", "the", "bit", "representation", "of", "X", "by", "``", "casting", "''", "it", "to", "CONST_INT", "."], "TS_V_token": ["avr", "0"], "File": "avr4", "Func": "avr_to_int_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30438, "Length": 37}
{"ground_truth": ["<s>", "static", "void", "emit_pop_byte", "(", "unsigned", "regno", ")", "{", "rtx", "mem", ",", "reg", ";", "mem", "=", "gen_rtx_PRE_INC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "avr_expand_epilogue", ".", "Emit", "a", "pop", "of", "a", "byte", "register", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "emit_pop_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30439, "Length": 53}
{"ground_truth": ["<s>", "static", "void", "emit_push_byte", "(", "unsigned", "regno", ",", "bool", "frame_related_p", ")", "{", "rtx", "mem", ",", "reg", ";", "rtx_insn", "*", "insn", ";", "mem", "=", "gen_rtx_POST_DEC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mem", ",", "reg", ")", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfun", "->", "machine", "->", "stack_usage", "++", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "byte", "register", "."], "TS_V_token": ["avr", "1"], "File": "avr4", "Func": "emit_push_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30440, "Length": 80}
{"ground_truth": ["<s>", "static", "void", "emit_push_sfr", "(", "rtx", "sfr", ",", "bool", "frame_related_p", ",", "bool", "clr_p", ")", "{", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "MEM_P", "(", "sfr", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "tmp_reg_rtx", ",", "sfr", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "frame_related_p", ")", ";", "if", "(", "clr_p", ")", "{", "insn", "=", "emit_move_insn", "(", "sfr", ",", "const0_rtx", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "SFR", "via", "tmp_reg", ".", "SFR", "is", "a", "MEM", "representing", "the", "memory", "location", "of", "the", "SFR", ".", "If", "CLR_P", "then", "clear", "the", "SFR", "after", "the", "push", "using", "zero_reg", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr4", "Func": "emit_push_sfr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30441, "Length": 80}
{"ground_truth": ["<s>", "int", "extra_constraint_Q", "(", "rtx", "x", ")", "{", "int", "ok", "=", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "ok", "=", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", "||", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", ";", "if", "(", "avr_log", ".", "constraints", ")", "avr_edump", "(", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"", ",", "ok", ",", "reload_completed", ",", "reload_in_progress", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Test", "for", "extra", "memory", "constraint", "'", "Q", "'", ".", "It", "'s", "a", "memory", "address", "based", "on", "Y", "or", "Z", "pointer", "with", "valid", "displacement", "."], "TS_V_token": ["avr", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\""], "File": "avr4", "Func": "extra_constraint_Q", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30442, "Length": 155}
{"ground_truth": ["<s>", "int", "get_sequence_length", "(", "rtx_insn", "*", "insns", ")", "{", "rtx_insn", "*", "insn", ";", "int", "length", ";", "for", "(", "insn", "=", "insns", ",", "length", "=", "0", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "length", "+=", "get_attr_length", "(", "insn", ")", ";", "return", "length", ";", "}", "</s>"], "natrual_language": ["Obtain", "the", "length", "sequence", "of", "insns", "."], "TS_V_token": ["avr", "0"], "File": "avr4", "Func": "get_sequence_length", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30443, "Length": 45}
{"ground_truth": ["<s>", "const", "char", "*", "lshrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0x0f\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x7\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x3\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"rol %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"rol %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "logic", "shift", "right", "(", "(", "unsigned", "char", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsr %0\"", "2", "2", "\"lsr %0\"", "\"lsr %0\"", "3", "3", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0x0f\"", "4", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "5", "0", "3", "\"swap %0\"", "\"lsr %0\"", "\"andi %0,0x7\"", "5", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "6", "0", "4", "\"swap %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"andi %0,0x3\"", "6", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "7", "3", "\"rol %0\"", "\"clr %0\"", "\"rol %0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"lsr %0\"", "1", "\"\""], "File": "avr4", "Func": "lshrqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30444, "Length": 324}
{"ground_truth": ["<s>", "const", "char", "*", "lshrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "4", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %A0\"", "CR_TAB", "\"sbrc %D0,7\"", "CR_TAB", "\"inc %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "logic", "shift", "right", "(", "(", "unsigned", "int", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"clr %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "2", "\"clr %C0\"", "\"clr %D0\"", "3", "\"movw %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "4", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "24", "4", "\"mov %A0,%D1\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "31", "6", "\"clr %A0\"", "\"sbrc %D0,7\"", "\"inc %A0\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "\"lsr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\""], "File": "avr4", "Func": "lshrsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30445, "Length": 326}
{"ground_truth": ["<s>", "int", "reg_unused_after", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ")", "{", "return", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", "||", "(", "REG_P", "(", "reg", ")", "&&", "_reg_unused_after", "(", "insn", ",", "reg", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "."], "TS_V_token": ["avr"], "File": "avr4", "Func": "reg_unused_after", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30446, "Length": 36}
{"ground_truth": ["<s>", "static", "int", "sequent_regs_live", "(", "void", ")", "{", "int", "reg", ";", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<=", "LAST_CALLEE_SAVED_REG", ";", "++", "reg", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "{", "if", "(", "live_seq", "!=", "0", ")", "return", "0", ";", "else", "continue", ";", "}", "if", "(", "!", "call_used_regs", "[", "reg", "]", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", "+", "1", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>"], "natrual_language": ["This", "function", "checks", "sequence", "of", "live", "registers"], "TS_V_token": ["avr", "0", "0", "0", "0", "0", "0", "0", "1", "0", "2", "2", "0"], "File": "avr4", "Func": "sequent_regs_live", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30447, "Length": 158}
{"ground_truth": ["<s>", "void", "avr_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: cost = %d.  */\\n\"", ",", "set_src_cost", "(", "SET_SRC", "(", "set", ")", ",", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ",", "INSN", ",", "0", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "insn", "cost", "for", "next", "insn", "."], "TS_V_token": ["avr", "\"/* DEBUG: cost = %d.  */\\n\"", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", "0"], "File": "avr5", "Func": "avr_final_prescan_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30448, "Length": 91}
{"ground_truth": ["<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "(", "LAST_CALLEE_SAVED_REG", "+", "1", ")", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "."], "TS_V_token": ["avr", "0", "1"], "File": "avr5", "Func": "avr_hard_regno_call_part_clobbered", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30449, "Length": 76}
{"ground_truth": ["<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "avr_pgm_check_var_decl", "(", "node", ")", ";", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "addr_space_t", "as", ";", "tree", "node0", "=", "node", ";", "do", "node0", "=", "TREE_TYPE", "(", "node0", ")", ";", "while", "(", "TREE_CODE", "(", "node0", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "error_mark_node", "==", "node0", ")", "return", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "node", ")", ")", ";", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "error", "(", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "64", "*", "avr_n_flash", ")", ";", "}", "else", "if", "(", "!", "AVR_HAVE_LPM", "&&", "avr_addrspace", "[", "as", "]", ".", "pointer_size", ">", "2", ")", "{", "error", "(", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "avr_arch", "->", "name", ")", ";", "}", "if", "(", "!", "TYPE_READONLY", "(", "node0", ")", "&&", "!", "TREE_READONLY", "(", "node", ")", ")", "{", "const", "char", "*", "reason", "=", "\"__attribute__((progmem))\"", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "reason", "=", "avr_addrspace", "[", "as", "]", ".", "name", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%?: %t\\n%t\\n\"", ",", "node", ",", "node0", ")", ";", "error", "(", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"", ",", "node", ",", "reason", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "."], "TS_V_token": ["avr", "\"variable %q+D located in address space %qs beyond flash \"", "\"of %d KiB\"", "64", "2", "\"variable %q+D located in address space %qs\"", "\" which is not supported for architecture %qs\"", "\"__attribute__((progmem))\"", "\"\\n%?: %t\\n%t\\n\"", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\""], "File": "avr5", "Func": "avr_insert_attributes", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30450, "Length": 226}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "maybe_set_param_value", "(", "PARAM_ALLOW_STORE_DATA_RACES", ",", "1", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "avr_register_passes", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "0", "1", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr5", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30451, "Length": 213}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xop", "[", "0", "]", ")", ";", "machine_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "."], "TS_V_token": ["avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\""], "File": "avr5", "Func": "avr_out_round", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30452, "Length": 352}
{"ground_truth": ["<s>", "static", "bool", "avr_pgm_check_var_decl", "(", "tree", "node", ")", "{", "const", "char", "*", "reason", "=", "NULL", ";", "addr_space_t", "as", "=", "ADDR_SPACE_GENERIC", ";", "gcc_assert", "(", "as", "==", "0", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"%?: %t\\n\"", ",", "node", ")", ";", "switch", "(", "TREE_CODE", "(", "node", ")", ")", "{", "default", ":", "break", ";", "case", "VAR_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"variable\"", ";", "break", ";", "case", "PARM_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"function parameter\"", ";", "break", ";", "case", "FIELD_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "\"structure field\"", ";", "break", ";", "case", "FUNCTION_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", ")", ")", ")", ",", "as", ")", "reason", "=", "\"return type of function\"", ";", "break", ";", "case", "POINTER_TYPE", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "node", ")", ",", "as", ")", "reason", "=", "\"pointer\"", ";", "break", ";", "}", "if", "(", "reason", ")", "{", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"%qT uses address space %qs beyond flash of %d KiB\"", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "64", "*", "avr_n_flash", ")", ";", "else", "error", "(", "\"%s %q+D uses address space %qs beyond flash of %d KiB\"", ",", "reason", ",", "node", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "64", "*", "avr_n_flash", ")", ";", "}", "else", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"pointer targeting address space %qs must be const in %qT\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "node", ")", ";", "else", "error", "(", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "reason", ",", "node", ")", ";", "}", "}", "return", "reason", "==", "NULL", ";", "}", "</s>"], "natrual_language": ["Sanity", "check", "NODE", "so", "that", "all", "pointers", "targeting", "non-generic", "address", "spaces", "go", "along", "with", "CONST", "qualifier", ".", "Writing", "to", "these", "address", "spaces", "should", "be", "detected", "and", "complained", "about", "as", "early", "as", "possible", "."], "TS_V_token": ["avr", "0", "\"%?: %t\\n\"", "\"variable\"", "\"function parameter\"", "\"structure field\"", "\"return type of function\"", "\"pointer\"", "\"%qT uses address space %qs beyond flash of %d KiB\"", "64", "\"%s %q+D uses address space %qs beyond flash of %d KiB\"", "64", "\"pointer targeting address space %qs must be const in %qT\"", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\""], "File": "avr5", "Func": "avr_pgm_check_var_decl", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30453, "Length": 281}
{"ground_truth": ["<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "ADDR", "to", "FILE", "as", "address", "."], "TS_V_token": ["avr", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\""], "File": "avr5", "Func": "avr_print_operand_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30454, "Length": 257}
{"ground_truth": ["<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "avr_compare_pattern", "(", "insn", ")", ";", "if", "(", "!", "pattern", ")", "continue", ";", "if", "(", "optimize", "&&", "avr_reorg_remove_redundant_compare", "(", "insn", ")", ")", "{", "continue", ";", "}", "if", "(", "compare_diff_p", "(", "insn", ")", ")", "{", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "XEXP", "(", "pattern", ",", "1", ")", "==", "const0_rtx", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "const0_rtx", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "}", "</s>"], "natrual_language": ["This", "function", "optimizes", "conditional", "jumps", "."], "TS_V_token": ["avr", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1"], "File": "avr5", "Func": "avr_reorg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30455, "Length": 425}
{"ground_truth": ["<s>", "static", "bool", "avr_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", "ATTRIBUTE_UNUSED", ",", "enum", "by_pieces_operation", "op", ",", "bool", "speed_p", ")", "{", "if", "(", "op", "!=", "MOVE_BY_PIECES", "||", "(", "speed_p", "&&", "(", "size", ">", "(", "MOVE_MAX_PIECES", ")", ")", ")", ")", "return", "default_use_by_pieces_infrastructure_p", "(", "size", ",", "align", ",", "op", ",", "speed_p", ")", ";", "return", "size", "<=", "(", "MOVE_MAX_PIECES", ")", ";", "}", "</s>"], "natrual_language": ["Prefer", "sequence", "of", "loads/stores", "for", "moves", "of", "size", "upto", "two", "-", "two", "pairs", "of", "load/store", "instructions", "are", "always", "better", "than", "the", "5", "instruction", "sequence", "for", "a", "loop", "(", "1", "instruction", "for", "loop", "counter", "setup", ",", "and", "4", "for", "the", "body", "of", "the", "loop", ")", "."], "TS_V_token": ["avr"], "File": "avr5", "Func": "avr_use_by_pieces_infrastructure_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30456, "Length": 59}
{"ground_truth": ["<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "cost", "=", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "SUBREG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "cost", "=", "18", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "optimize", ">", "0", "&&", "io_address_operand", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_absdata_p", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "}", "if", "(", "avr_log", ".", "address_cost", ")", "avr_edump", "(", "\"\\n%?: %d = %r\\n\"", ",", "cost", ",", "x", ")", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Calculate", "the", "cost", "of", "a", "memory", "address", "."], "TS_V_token": ["avr", "4", "1", "0", "0", "1", "18", "0", "2", "2", "\"\\n%?: %d = %r\\n\""], "File": "avr6", "Func": "avr_address_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30457, "Length": 150}
{"ground_truth": ["<s>", "static", "void", "avr_asm_init_sections", "(", "void", ")", "{", "readonly_data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "bss_section", "->", "unnamed", ".", "callback", "=", "avr_output_bss_section_asm_op", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_INIT_SECTIONS", "'", "."], "TS_V_token": ["avr"], "File": "avr6", "Func": "avr_asm_init_sections", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30458, "Length": 32}
{"ground_truth": ["<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.word\\tgs(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "PSImode", ")", "{", "fputs", "(", "\"\\t.byte\\tlo8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thi8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thh8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "CONST_FIXED_P", "(", "x", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "<", "size", ";", "n", "++", ")", "{", "rtx", "xn", "=", "simplify_gen_subreg", "(", "QImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "n", ")", ";", "default_assemble_integer", "(", "xn", ",", "1", ",", "aligned_p", ")", ";", "}", "return", "true", ";", "}", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_pm_p", "(", "x", ")", ")", "{", "x", "=", "plus_constant", "(", "Pmode", ",", "x", ",", "AVR_TINY_PM_OFFSET", ")", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>"], "natrual_language": ["Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "."], "TS_V_token": ["avr", "\"\\t.word\\tgs(\"", "\")\\n\"", "\"\\t.byte\\tlo8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thi8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thh8(\"", "\")\"", "\"need binutils PR13503\\n\"", "0", "1"], "File": "avr6", "Func": "avr_assemble_integer", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30459, "Length": 230}
{"ground_truth": ["<s>", "bool", "avr_casei_sequence_check_operands", "(", "rtx", "*", "xop", ")", "{", "rtx", "sub_5", "=", "NULL_RTX", ";", "if", "(", "AVR_HAVE_EIJMP_EICALL", "&&", "xop", "[", "8", "]", "==", "all_regs_rtx", "[", "24", "]", ")", "{", "sub_5", "=", "xop", "[", "6", "]", ";", "}", "if", "(", "!", "AVR_HAVE_EIJMP_EICALL", "&&", "PLUS", "==", "GET_CODE", "(", "xop", "[", "6", "]", ")", "&&", "LABEL_REF", "==", "GET_CODE", "(", "XEXP", "(", "xop", "[", "6", "]", ",", "1", ")", ")", "&&", "rtx_equal_p", "(", "xop", "[", "3", "]", ",", "XEXP", "(", "XEXP", "(", "xop", "[", "6", "]", ",", "1", ")", ",", "0", ")", ")", "&&", "xop", "[", "8", "]", "==", "const0_rtx", ")", "{", "sub_5", "=", "XEXP", "(", "xop", "[", "6", "]", ",", "0", ")", ";", "}", "if", "(", "sub_5", "&&", "SUBREG_P", "(", "sub_5", ")", "&&", "0", "==", "SUBREG_BYTE", "(", "sub_5", ")", "&&", "rtx_equal_p", "(", "xop", "[", "5", "]", ",", "SUBREG_REG", "(", "sub_5", ")", ")", ")", "return", "true", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\"", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Perform", "some", "extra", "checks", "on", "operands", "of", "casesi_", "<", "mode", ">", "_sequence", ".", "Not", "all", "operand", "dependencies", "can", "be", "described", "by", "means", "of", "predicates", ".", "This", "function", "performs", "left", "over", "checks", "and", "should", "always", "return", "true", ".", "Returning", "false", "means", "that", "someone", "changed", "the", "casesi", "expander", "but", "did", "not", "adjust", "casesi_", "<", "mode", ">", "_sequence", "."], "TS_V_token": ["avr", "8", "24", "6", "6", "6", "1", "3", "6", "1", "0", "8", "6", "0", "0", "5", "\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\""], "File": "avr6", "Func": "avr_casei_sequence_check_operands", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30460, "Length": 157}
{"ground_truth": ["<s>", "static", "void", "avr_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "new_decl_p", ")", "{", "tree", "addr_attr", "=", "NULL_TREE", ";", "if", "(", "new_decl_p", "&&", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "NULL_TREE", "==", "DECL_INITIAL", "(", "decl", ")", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "tree", "asmname", "=", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ";", "varpool_node", "*", "node", "=", "varpool_node", "::", "get_for_asmname", "(", "asmname", ")", ";", "bool", "alias_p", "=", "node", "&&", "node", "->", "alias", ";", "if", "(", "!", "alias_p", ")", "warning", "(", "OPT_Wuninitialized", ",", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", ",", "decl", ")", ";", "}", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "new_decl_p", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", "&&", "MEM_P", "(", "rtl", ")", "&&", "SYMBOL_REF_P", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ")", "{", "rtx", "sym", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "decl", ")", ";", "tree", "attr", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "if", "(", "type", "==", "error_mark_node", ")", "return", ";", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "type", ")", ";", "if", "(", "!", "AVR_TINY", "&&", "-", "1", "==", "avr_progmem_p", "(", "decl", ",", "attr", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "AVR_SYMBOL_SET_ADDR_SPACE", "(", "sym", ",", "as", ")", ";", "tree", "io_low_attr", "=", "lookup_attribute", "(", "\"io_low\"", ",", "attr", ")", ";", "tree", "io_attr", "=", "lookup_attribute", "(", "\"io\"", ",", "attr", ")", ";", "if", "(", "io_low_attr", "&&", "TREE_VALUE", "(", "io_low_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_low_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "if", "(", "io_attr", "&&", "TREE_VALUE", "(", "io_attr", ")", "&&", "TREE_VALUE", "(", "TREE_VALUE", "(", "io_attr", ")", ")", ")", "addr_attr", "=", "io_attr", ";", "else", "addr_attr", "=", "lookup_attribute", "(", "\"address\"", ",", "attr", ")", ";", "if", "(", "io_low_attr", "||", "(", "io_attr", "&&", "addr_attr", "&&", "low_io_address_operand", "(", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "addr_attr", ")", ")", ")", ")", ",", "QImode", ")", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO_LOW", ";", "if", "(", "io_attr", "||", "io_low_attr", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_IO", ";", "if", "(", "addr_attr", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "SYMBOL_FLAG_ADDRESS", ";", "}", "if", "(", "AVR_TINY", "&&", "decl", "&&", "VAR_DECL", "==", "TREE_CODE", "(", "decl", ")", "&&", "MEM_P", "(", "rtl", ")", "&&", "SYMBOL_REF_P", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ")", "{", "rtx", "sym", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "bool", "progmem_p", "=", "-", "1", "==", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "if", "(", "progmem_p", ")", "{", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "AVR_SYMBOL_FLAG_TINY_PM", ";", "}", "if", "(", "avr_decl_absdata_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "||", "(", "TARGET_ABSDATA", "&&", "!", "progmem_p", "&&", "!", "addr_attr", "&&", "avr_decl_maybe_lds_p", "(", "decl", ")", ")", "||", "(", "addr_attr", "&&", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "addr_attr", ")", ")", ")", "<", "0xc0", ")", ")", "{", "SYMBOL_REF_FLAGS", "(", "sym", ")", "|=", "AVR_SYMBOL_FLAG_TINY_ABSDATA", ";", "}", "if", "(", "progmem_p", "&&", "avr_decl_absdata_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "error", "(", "\"%q+D has incompatible attributes %qs and %qs\"", ",", "decl", ",", "\"progmem\"", ",", "\"absdata\"", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ENCODE_SECTION_INFO", "'", "."], "TS_V_token": ["avr", "\"uninitialized variable %q+D put into \"", "\"program memory area\"", "0", "0", "1", "\"io_low\"", "\"io\"", "\"address\"", "0", "0", "1", "0xc0", "\"%q+D has incompatible attributes %qs and %qs\"", "\"progmem\"", "\"absdata\""], "File": "avr6", "Func": "avr_encode_section_info", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30461, "Length": 497}
{"ground_truth": ["<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_NOPS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_nops", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0"], "File": "avr6", "Func": "avr_expand_builtin", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30462, "Length": 506}
{"ground_truth": ["<s>", "void", "avr_expand_prologue", "(", "void", ")", "{", "HARD_REG_SET", "set", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "cfun", "->", "machine", "->", "stack_usage", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_enable_interrupt", "(", ")", ")", ";", "emit_push_byte", "(", "AVR_ZERO_REGNO", ",", "true", ")", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "true", ")", ";", "emit_push_sfr", "(", "sreg_rtx", ",", "false", ",", "false", ")", ";", "emit_move_insn", "(", "zero_reg_rtx", ",", "const0_rtx", ")", ";", "emit_use", "(", "zero_reg_rtx", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "emit_push_sfr", "(", "rampd_rtx", ",", "false", ",", "true", ")", ";", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampx_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "emit_push_sfr", "(", "rampy_rtx", ",", "false", ",", "true", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampz_rtx", ",", "false", ",", "AVR_HAVE_RAMPD", ")", ";", "}", "}", "avr_prologue_setup_frame", "(", "size", ",", "set", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "cfun", "->", "machine", "->", "stack_usage", "+", "INCOMING_FRAME_SP_OFFSET", ";", "}", "</s>"], "natrual_language": ["Output", "function", "prologue", "."], "TS_V_token": ["avr", "0", "1", "1", "1"], "File": "avr6", "Func": "avr_expand_prologue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30463, "Length": 248}
{"ground_truth": ["<s>", "static", "rtx", "avr_find_unused_d_reg", "(", "rtx_insn", "*", "insn", ",", "rtx", "exclude", ")", "{", "bool", "isr_p", "=", "(", "avr_interrupt_function_p", "(", "current_function_decl", ")", "||", "avr_signal_function_p", "(", "current_function_decl", ")", ")", ";", "for", "(", "int", "regno", "=", "16", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "rtx", "reg", "=", "all_regs_rtx", "[", "regno", "]", ";", "if", "(", "(", "exclude", "&&", "reg_overlap_mentioned_p", "(", "exclude", ",", "reg", ")", ")", "||", "fixed_regs", "[", "regno", "]", ")", "{", "continue", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", "||", "(", "!", "isr_p", "&&", "call_used_regs", "[", "regno", "]", ")", ")", ")", "{", "return", "reg", ";", "}", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "reg_unused_after", "(", "insn", ",", "reg", ")", ")", "{", "return", "reg", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Fixme", ":", "This", "is", "a", "hack", "because", "secondary", "reloads", "do", "n't", "works", "as", "expected", ".", "Find", "an", "unused", "d-register", "to", "be", "used", "as", "scratch", "in", "INSN", ".", "EXCLUDE", "is", "either", "NULL_RTX", "or", "some", "register", ".", "In", "the", "case", "where", "EXCLUDE", "is", "a", "register", ",", "skip", "all", "possible", "return", "values", "that", "overlap", "EXCLUDE", ".", "The", "policy", "for", "the", "returned", "register", "is", "similar", "to", "that", "of", "`", "reg_unused_after", "'", ",", "i.e", ".", "the", "returned", "register", "may", "overlap", "the", "SET_DEST", "of", "INSN", ".", "Return", "a", "QImode", "d-register", "or", "NULL_RTX", "if", "nothing", "found", "."], "TS_V_token": ["avr", "16", "32"], "File": "avr6", "Func": "avr_find_unused_d_reg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30464, "Length": 138}
{"ground_truth": ["<s>", "static", "void", "avr_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", "&&", "!", "call_used_regs", "[", "cum", "->", "regno", "]", ")", "{", "cfun", "->", "machine", "->", "sibcall_fails", "=", "1", ";", "}", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", ")", "{", "for", "(", "int", "regno", "=", "cum", "->", "regno", ";", "regno", "<", "cum", "->", "regno", "+", "bytes", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "warning", "(", "0", ",", "\"fixed register %s used to pass parameter to function\"", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>"], "natrual_language": ["Update", "the", "summarizer", "variable", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", "."], "TS_V_token": ["avr", "8", "0", "1", "8", "0", "0", "\"fixed register %s used to pass parameter to function\"", "0", "0"], "File": "avr6", "Func": "avr_function_arg_advance", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30465, "Length": 159}
{"ground_truth": ["<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "."], "TS_V_token": ["avr", "0", "1"], "File": "avr6", "Func": "avr_hard_regno_call_part_clobbered", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30466, "Length": 74}
{"ground_truth": ["<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "avr_pgm_check_var_decl", "(", "node", ")", ";", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "addr_space_t", "as", ";", "tree", "node0", "=", "node", ";", "do", "node0", "=", "TREE_TYPE", "(", "node0", ")", ";", "while", "(", "TREE_CODE", "(", "node0", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "error_mark_node", "==", "node0", ")", "return", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "node", ")", ")", ";", "if", "(", "!", "TYPE_READONLY", "(", "node0", ")", "&&", "!", "TREE_READONLY", "(", "node", ")", ")", "{", "const", "char", "*", "reason", "=", "\"__attribute__((progmem))\"", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "reason", "=", "avr_addrspace", "[", "as", "]", ".", "name", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%?: %t\\n%t\\n\"", ",", "node", ",", "node0", ")", ";", "error", "(", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"", ",", "node", ",", "reason", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "."], "TS_V_token": ["avr", "\"__attribute__((progmem))\"", "\"\\n%?: %t\\n%t\\n\"", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\""], "File": "avr6", "Func": "avr_insert_attributes", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30467, "Length": 158}
{"ground_truth": ["<s>", "static", "bool", "avr_is_casesi_sequence", "(", "basic_block", "bb", ",", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "insns", "[", "6", "]", ")", "{", "rtx", "set_5", ",", "set_0", ";", "if", "(", "!", "(", "JUMP_P", "(", "insns", "[", "5", "]", "=", "insn", ")", "&&", "(", "set_5", "=", "single_set", "(", "insns", "[", "5", "]", ")", ")", "&&", "UNSPEC", "==", "GET_CODE", "(", "SET_SRC", "(", "set_5", ")", ")", "&&", "UNSPEC_INDEX_JMP", "==", "XINT", "(", "SET_SRC", "(", "set_5", ")", ",", "1", ")", "&&", "(", "insns", "[", "4", "]", "=", "prev_real_insn", "(", "insns", "[", "5", "]", ")", ")", "&&", "(", "insns", "[", "3", "]", "=", "prev_real_insn", "(", "insns", "[", "4", "]", ")", ")", "&&", "(", "insns", "[", "2", "]", "=", "prev_real_insn", "(", "insns", "[", "3", "]", ")", ")", "&&", "(", "insns", "[", "1", "]", "=", "prev_real_insn", "(", "insns", "[", "2", "]", ")", ")", "&&", "(", "insns", "[", "0", "]", "=", "prev_real_insn", "(", "insns", "[", "1", "]", ")", ")", "&&", "(", "set_0", "=", "single_set", "(", "insns", "[", "0", "]", ")", ")", "&&", "extend_operator", "(", "SET_SRC", "(", "set_0", ")", ",", "SImode", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", ",", "bb", "->", "index", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "6", ";", "i", "++", ")", "print_rtl_single", "(", "dump_file", ",", "insns", "[", "i", "]", ")", ";", "}", "rtx_insn", "*", "xinsn", "=", "avr_parallel_insn_from_insns", "(", "insns", ")", ";", "INSN_CODE", "(", "xinsn", ")", "=", "recog", "(", "PATTERN", "(", "xinsn", ")", ",", "xinsn", ",", "NULL", ")", ";", "if", "(", "INSN_CODE", "(", "xinsn", ")", "<", "0", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; Sequence not recognized, giving up.\\n\\n\"", ")", ";", "return", "false", ";", "}", "gcc_assert", "(", "CODE_FOR_casesi_qi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", "||", "CODE_FOR_casesi_hi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", ")", ";", "extract_insn", "(", "xinsn", ")", ";", "gcc_assert", "(", "11", "==", "recog_data", ".", "n_operands", ")", ";", "gcc_assert", "(", "4", "==", "recog_data", ".", "n_dups", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Operands extracted:\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "avr_fdump", "(", "dump_file", ",", "\";; $%d = %r\\n\"", ",", "i", ",", "recog_data", ".", "operand", "[", "i", "]", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "we", "see", "an", "insn", "stream", "generated", "by", "casesi", "expander", "together", "with", "an", "extension", "to", "SImode", "of", "the", "switch", "value", ".", "If", "this", "is", "the", "case", ",", "fill", "in", "the", "insns", "from", "casesi", "to", "INSNS", "[", "1", "..", "5", "]", "and", "the", "SImode", "extension", "to", "INSNS", "[", "0", "]", ".", "Moreover", ",", "extract", "the", "operands", "of", "pattern", "casesi_", "<", "mode", ">", "_sequence", "forged", "from", "the", "sequence", "to", "recog_data", "."], "TS_V_token": ["avr", "6", "5", "5", "1", "4", "5", "3", "4", "2", "3", "1", "2", "0", "1", "0", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", "0", "6", "0", "\";; Sequence not recognized, giving up.\\n\\n\"", "11", "4", "\";; Operands extracted:\\n\"", "0", "\";; $%d = %r\\n\"", "\"\\n\""], "File": "avr6", "Func": "avr_is_casesi_sequence", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30468, "Length": 364}
{"ground_truth": ["<s>", "static", "avr_map_op_t", "avr_map_decompose", "(", "unsigned", "int", "f", ",", "const", "avr_map_op_t", "*", "g", ",", "bool", "val_const_p", ")", "{", "bool", "val_used_p", "=", "0", "!=", "avr_map_metric", "(", "f", ",", "MAP_MASK_PREIMAGE_F", ")", ";", "avr_map_op_t", "f_ginv", "=", "*", "g", ";", "unsigned", "int", "ginv", "=", "g", "->", "ginv", ";", "f_ginv", ".", "cost", "=", "-", "1", ";", "for", "(", "int", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "x", "=", "avr_map", "(", "f", ",", "i", ")", ";", "if", "(", "x", "<=", "7", ")", "{", "x", "=", "avr_map", "(", "ginv", ",", "x", ")", ";", "if", "(", "x", ">", "7", ")", "return", "f_ginv", ";", "}", "f_ginv", ".", "map", "=", "(", "f_ginv", ".", "map", "<<", "4", ")", "+", "x", ";", "}", "if", "(", "0", "==", "avr_map_metric", "(", "f_ginv", ".", "map", ",", "MAP_NONFIXED_0_7", ")", ")", "{", "f_ginv", ".", "cost", "=", "2", "+", "(", "val_used_p", "&&", "!", "val_const_p", ")", ";", "}", "else", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "all_regs_rtx", "[", "24", "]", ";", "xop", "[", "1", "]", "=", "gen_int_mode", "(", "f_ginv", ".", "map", ",", "SImode", ")", ";", "xop", "[", "2", "]", "=", "all_regs_rtx", "[", "25", "]", ";", "xop", "[", "3", "]", "=", "val_used_p", "?", "xop", "[", "0", "]", ":", "const0_rtx", ";", "avr_out_insert_bits", "(", "xop", ",", "&", "f_ginv", ".", "cost", ")", ";", "f_ginv", ".", "cost", "+=", "val_const_p", "&&", "val_used_p", "?", "1", ":", "0", ";", "}", "f_ginv", ".", "cost", "+=", "g", "->", "cost", ";", "if", "(", "avr_log", ".", "builtin", ")", "avr_edump", "(", "\" %s%d=%d\"", ",", "g", "->", "str", ",", "g", "->", "arg", ",", "f_ginv", ".", "cost", ")", ";", "return", "f_ginv", ";", "}", "</s>"], "natrual_language": ["Try", "to", "decompose", "F", "as", "F", "=", "(", "F", "o", "G^-1", ")", "o", "G", "as", "described", "above", ".", "The", "result", "is", "a", "struct", "representing", "F", "o", "G^-1", "and", "G.", "If", "result.cost", "<", "0", "then", "such", "a", "decomposition", "does", "not", "exist", "."], "TS_V_token": ["avr", "0", "1", "7", "0", "7", "7", "4", "0", "2", "4", "0", "24", "1", "2", "25", "3", "0", "1", "0", "\" %s%d=%d\""], "File": "avr6", "Func": "avr_map_decompose", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30469, "Length": 258}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "flag_delete_null_pointer_checks", "=", "0", ";", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "maybe_set_param_value", "(", "PARAM_ALLOW_STORE_DATA_RACES", ",", "1", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "0", "1", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr6", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30470, "Length": 209}
{"ground_truth": ["<s>", "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "0", "==", "(", "pop_mask", "&", "(", "1", "<<", "popcount_hwi", "(", "val8", ")", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "."], "TS_V_token": ["avr", "0", "0", "1"], "File": "avr6", "Func": "avr_popcount_each_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30471, "Length": 99}
{"ground_truth": ["<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_pm_p", "(", "addr", ")", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "addr", ",", "AVR_TINY_PM_OFFSET", ")", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "ADDR", "to", "FILE", "as", "address", "."], "TS_V_token": ["avr", "\"%s\"", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\""], "File": "avr6", "Func": "avr_print_operand_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30472, "Length": 279}
{"ground_truth": ["<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "count", ";", "int", "int_or_sig_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", "return", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>"], "natrual_language": ["Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "."], "TS_V_token": ["avr", "0", "0", "0", "32", "1"], "File": "avr6", "Func": "avr_regs_to_save", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30473, "Length": 159}
{"ground_truth": ["<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>"], "natrual_language": ["Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "."], "TS_V_token": ["avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "8"], "File": "avr6", "Func": "avr_return_addr_rtx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30474, "Length": 96}
{"ground_truth": ["<s>", "static", "bool", "avr_set_core_architecture", "(", "void", ")", "{", "if", "(", "!", "avr_mmcu", ")", "avr_mmcu", "=", "AVR_MMCU_DEFAULT", ";", "avr_arch", "=", "&", "avr_arch_types", "[", "0", "]", ";", "for", "(", "const", "avr_mcu_t", "*", "mcu", "=", "avr_mcu_types", ";", ";", "mcu", "++", ")", "{", "if", "(", "NULL", "==", "mcu", "->", "name", ")", "{", "error", "(", "\"unknown core architecture %qs specified with %qs\"", ",", "avr_mmcu", ",", "\"-mmcu=\"", ")", ";", "avr_inform_core_architectures", "(", ")", ";", "break", ";", "}", "else", "if", "(", "0", "==", "strcmp", "(", "mcu", "->", "name", ",", "avr_mmcu", ")", "&&", "NULL", "==", "mcu", "->", "macro", ")", "{", "avr_arch", "=", "&", "avr_arch_types", "[", "mcu", "->", "arch_id", "]", ";", "if", "(", "avr_n_flash", "<", "0", ")", "avr_n_flash", "=", "1", "+", "(", "mcu", "->", "flash_size", "-", "1", ")", "/", "0x10000", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Set", "`", "avr_arch", "'", "as", "specified", "by", "`", "-mmcu=", "'", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["avr", "0", "\"unknown core architecture %qs specified with %qs\"", "\"-mmcu=\"", "0", "0", "1", "1", "0x10000"], "File": "avr6", "Func": "avr_set_core_architecture", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30475, "Length": 123}
{"ground_truth": ["<s>", "static", "void", "avr_set_current_function", "(", "tree", "decl", ")", "{", "location_t", "loc", ";", "const", "char", "*", "isr", ";", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "loc", "=", "DECL_SOURCE_LOCATION", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_naked", "=", "avr_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_signal", "=", "avr_signal_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_interrupt", "=", "avr_interrupt_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_task", "=", "avr_OS_task_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_main", "=", "avr_OS_main_function_p", "(", "decl", ")", ";", "isr", "=", "cfun", "->", "machine", "->", "is_interrupt", "?", "\"interrupt\"", ":", "\"signal\"", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_task", "+", "cfun", "->", "machine", "->", "is_OS_main", "+", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ">", "1", ")", "error_at", "(", "loc", ",", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", "&&", "(", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wattributes", ",", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", ",", "\"OS_task\"", ",", "\"OS_main\"", ",", "\"naked\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "const", "char", "*", "name", ";", "name", "=", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ":", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "cfun", "->", "machine", "->", "is_signal", "=", "0", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot have arguments\"", ",", "isr", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot return a value\"", ",", "isr", ")", ";", "if", "(", "!", "STR_PREFIX_P", "(", "name", ",", "\"__vector\"", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wmisspelled_isr", ",", "\"%qs appears to be a misspelled \"", "\"%s handler, missing __vector prefix\"", ",", "name", ",", "isr", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>"], "natrual_language": ["Sanity", "cheching", "for", "above", "function", "attributes", "."], "TS_V_token": ["avr", "\"interrupt\"", "\"signal\"", "1", "\"function attributes %qs, %qs and %qs are mutually\"", "\" exclusive\"", "\"OS_task\"", "\"OS_main\"", "\"function attributes %qs and %qs have\"", "\" no effect on %qs function\"", "\"OS_task\"", "\"OS_main\"", "\"naked\"", "0", "\"%qs function cannot have arguments\"", "\"%qs function cannot return a value\"", "\"__vector\"", "\"%qs appears to be a misspelled \"", "\"%s handler, missing __vector prefix\"", "1"], "File": "avr6", "Func": "avr_set_current_function", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30476, "Length": 362}
{"ground_truth": ["<s>", "static", "int", "sequent_regs_live", "(", "void", ")", "{", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<=", "LAST_CALLEE_SAVED_REG", ";", "++", "reg", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "{", "if", "(", "live_seq", "!=", "0", ")", "return", "0", ";", "else", "continue", ";", "}", "if", "(", "!", "call_used_regs", "[", "reg", "]", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", "+", "1", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>"], "natrual_language": ["This", "function", "checks", "sequence", "of", "live", "registers"], "TS_V_token": ["avr", "0", "0", "0", "0", "0", "0", "0", "1", "0", "2", "2", "0"], "File": "avr6", "Func": "sequent_regs_live", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30477, "Length": 156}
{"ground_truth": ["<s>", "static", "rtx", "avr_builtin_setjmp_frame_value", "(", "void", ")", "{", "rtx", "xval", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_subhi3", "(", "xval", ",", "virtual_stack_vars_rtx", ",", "gen_int_mode", "(", "avr_starting_frame_offset", "(", ")", ",", "Pmode", ")", ")", ")", ";", "return", "xval", ";", "}", "</s>"], "natrual_language": ["Actual", "start", "of", "frame", "is", "virtual_stack_vars_rtx", "this", "is", "offset", "from", "frame", "pointer", "by", "+TARGET_STARTING_FRAME_OFFSET", ".", "Using", "saved", "frame", "=", "virtual_stack_vars_rtx", "-", "TARGET_STARTING_FRAME_OFFSET", "avoids", "creating", "add/sub", "of", "offset", "in", "nonlocal", "goto", "and", "setjmp", "."], "TS_V_token": ["avr"], "File": "avr7", "Func": "avr_builtin_setjmp_frame_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30478, "Length": 38}
{"ground_truth": ["<s>", "static", "bool", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "."], "TS_V_token": ["avr", "0", "1"], "File": "avr7", "Func": "avr_hard_regno_call_part_clobbered", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30479, "Length": 75}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "maybe_set_param_value", "(", "PARAM_ALLOW_STORE_DATA_RACES", ",", "1", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"-fpic is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"-fPIC is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"-fpie is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"-fPIE is not supported\"", ")", ";", "avr_gasisr_prologues", "=", "0", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "1", "0", "1", "\"-fpic is not supported\"", "2", "\"-fPIC is not supported\"", "1", "\"-fpie is not supported\"", "2", "\"-fPIE is not supported\"", "0", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr7", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30480, "Length": 209}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "maybe_set_param_value", "(", "PARAM_ALLOW_STORE_DATA_RACES", ",", "1", ",", "global_options", ".", "x_param_values", ",", "global_options_set", ".", "x_param_values", ")", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"%<-fpic%> is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"%<-fPIC%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"%<-fpie%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"%<-fPIE%> is not supported\"", ")", ";", "avr_gasisr_prologues", "=", "0", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "1", "0", "1", "\"%<-fpic%> is not supported\"", "2", "\"%<-fPIC%> is not supported\"", "1", "\"%<-fpie%> is not supported\"", "2", "\"%<-fPIE%> is not supported\"", "0", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr8", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30481, "Length": 209}
{"ground_truth": ["<s>", "const", "char", "*", "ashlqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsl %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0xf0\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xe0\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"andi %0,0xc0\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"lsl %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"ror %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"ror %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsl %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "shift", "left", "(", "(", "char", ")", "x", "<", "<", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsl %0\"", "2", "2", "\"lsl %0\"", "\"lsl %0\"", "3", "3", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0xf0\"", "4", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "5", "0", "3", "\"swap %0\"", "\"lsl %0\"", "\"andi %0,0xe0\"", "5", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "6", "0", "4", "\"swap %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"andi %0,0xc0\"", "6", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "\"lsl %0\"", "7", "3", "\"ror %0\"", "\"clr %0\"", "\"ror %0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"lsl %0\"", "1", "\"\""], "File": "avr", "Func": "ashlqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30482, "Length": 322}
{"ground_truth": ["<s>", "const", "char", "*", "ashlsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "(", "\"mov %D0,%C1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %D0,%C1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "==", "reg1", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %C0,%A1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %C0,%A1\"", "CR_TAB", "\"mov %D0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "case", "24", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %D0,%A1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", "CR_TAB", "\"rol %D0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "shift", "left", "(", "(", "long", ")", "x", "<", "<", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %D0,%C1\"", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "\"mov %D0,%C1\"", "16", "0", "1", "2", "2", "\"clr %B0\"", "\"clr %A0\"", "3", "\"movw %C0,%A1\"", "\"clr %B0\"", "\"clr %A0\"", "4", "\"mov %C0,%A1\"", "\"mov %D0,%B1\"", "\"clr %B0\"", "\"clr %A0\"", "24", "4", "\"mov %D0,%A1\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "31", "6", "\"clr %D0\"", "\"lsr %A0\"", "\"ror %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "\"rol %D0\"", "4", "\"\""], "File": "avr", "Func": "ashlsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30483, "Length": 324}
{"ground_truth": ["<s>", "const", "char", "*", "ashrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"asr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "4", ":", "*", "len", "=", "4", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "5", ":", "*", "len", "=", "5", ";", "return", "(", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", "CR_TAB", "\"asr %0\"", ")", ";", "case", "6", ":", "*", "len", "=", "4", ";", "return", "(", "\"bst %0,6\"", "CR_TAB", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", "CR_TAB", "\"bld %0,0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "case", "7", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsl %0\"", "CR_TAB", "\"sbc %0,%0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"asr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "arithmetic", "shift", "right", "(", "(", "signed", "char", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "1", "1", "\"asr %0\"", "2", "2", "\"asr %0\"", "\"asr %0\"", "3", "3", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "4", "4", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "5", "5", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "\"asr %0\"", "6", "4", "\"bst %0,6\"", "\"lsl %0\"", "\"sbc %0,%0\"", "\"bld %0,0\"", "2", "8", "7", "2", "\"lsl %0\"", "\"sbc %0,%0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"asr %0\"", "1", "\"\""], "File": "avr", "Func": "ashrqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30484, "Length": 224}
{"ground_truth": ["<s>", "const", "char", "*", "ashrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "6", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %C0,7\"", "CR_TAB", "\"dec %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %D1,7\"", "CR_TAB", "\"dec %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "4", ",", "(", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "5", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "else", "return", "*", "len", "=", "6", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "6", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %D0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"com %D0\"", "CR_TAB", "\"mov %B0,%D0\"", "CR_TAB", "\"mov %C0,%D0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "case", "31", ":", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "4", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"movw %C0,%A0\"", ")", ";", "else", "return", "*", "len", "=", "5", ",", "(", "\"lsl %D0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"mov %C0,%A0\"", "CR_TAB", "\"mov %D0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "arithmetic", "shift", "right", "(", "(", "signed", "long", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "8", "0", "1", "6", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"sbrc %C0,7\"", "\"dec %D0\"", "\"clr %D0\"", "\"sbrc %D1,7\"", "\"dec %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "4", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "5", "\"movw %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "6", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %D0\"", "\"sbrc %B0,7\"", "\"com %D0\"", "\"mov %C0,%D0\"", "24", "6", "\"mov %A0,%D1\"", "\"clr %D0\"", "\"sbrc %A0,7\"", "\"com %D0\"", "\"mov %B0,%D0\"", "\"mov %C0,%D0\"", "2", "32", "31", "4", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"movw %C0,%A0\"", "5", "\"lsl %D0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"mov %C0,%A0\"", "\"mov %D0,%A0\"", "\"asr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\""], "File": "avr", "Func": "ashrsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30485, "Length": 333}
{"ground_truth": ["<s>", "static", "bool", "avr_2word_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "TARGET_SKIP_BUG", "||", "!", "insn", "||", "get_attr_length", "(", "insn", ")", "!=", "2", ")", "{", "return", "false", ";", "}", "switch", "(", "INSN_CODE", "(", "insn", ")", ")", "{", "default", ":", "return", "false", ";", "case", "CODE_FOR_movqi_insn", ":", "case", "CODE_FOR_movuqq_insn", ":", "case", "CODE_FOR_movqq_insn", ":", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", "&&", "(", "REG_P", "(", "src", ")", "||", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "dest", ")", ")", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "dest", ",", "0", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "{", "return", "CONSTANT_ADDRESS_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ";", "}", "return", "false", ";", "}", "case", "CODE_FOR_call_insn", ":", "case", "CODE_FOR_call_value_insn", ":", "return", "true", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "for", "jump_over_one_insn_p", ":", "Test", "if", "INSN", "is", "a", "2-word", "instruction", "and", "thus", "is", "suitable", "to", "be", "skipped", "by", "CPSE", ",", "SBRC", ",", "etc", "."], "TS_V_token": ["avr", "2", "0", "0"], "File": "avr", "Func": "avr_2word_insn_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30486, "Length": 153}
{"ground_truth": ["<s>", "int", "avr_accumulate_outgoing_args", "(", "void", ")", "{", "if", "(", "!", "cfun", ")", "return", "TARGET_ACCUMULATE_OUTGOING_ARGS", ";", "return", "(", "TARGET_ACCUMULATE_OUTGOING_ARGS", "&&", "!", "(", "cfun", "->", "calls_setjmp", "||", "cfun", "->", "has_nonlocal_label", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "ACCUMULATE_OUTGOING_ARGS", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_accumulate_outgoing_args", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30487, "Length": 31}
{"ground_truth": ["<s>", "static", "int", "avr_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "int", "cost", "=", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "SUBREG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", "{", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "cost", "=", "18", ";", "}", "else", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "if", "(", "io_address_operand", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_absdata_p", "(", "x", ",", "QImode", ")", ")", "cost", "=", "2", ";", "}", "if", "(", "avr_log", ".", "address_cost", ")", "avr_edump", "(", "\"\\n%?: %d = %r\\n\"", ",", "cost", ",", "x", ")", ";", "return", "cost", ";", "}", "</s>"], "natrual_language": ["Calculate", "the", "cost", "of", "a", "memory", "address", "."], "TS_V_token": ["avr", "4", "1", "0", "0", "1", "18", "2", "2", "\"\\n%?: %d = %r\\n\""], "File": "avr", "Func": "avr_address_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30488, "Length": 146}
{"ground_truth": ["<s>", "static", "bool", "avr_address_tiny_absdata_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "CONST", "==", "GET_CODE", "(", "x", ")", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "AVR_SYMBOL_FLAG_TINY_ABSDATA", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "x", ")", ",", "0", ",", "0xc0", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "rtx", "X", "is", "a", "CONST_INT", ",", "CONST", "or", "SYMBOL_REF", "address", "with", "the", "`", "absdata", "'", "variable", "attribute", ",", "i.e", ".", "respective", "data", "can", "be", "read", "/", "written", "by", "LDS", "/", "STS", "instruction", ".", "This", "is", "used", "only", "for", "AVR_TINY", "."], "TS_V_token": ["avr", "0", "0", "0", "0xc0"], "File": "avr", "Func": "avr_address_tiny_absdata_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30489, "Length": 80}
{"ground_truth": ["<s>", "static", "bool", "avr_address_tiny_pm_p", "(", "rtx", "x", ")", "{", "if", "(", "CONST", "==", "GET_CODE", "(", "x", ")", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "AVR_SYMBOL_FLAG_TINY_PM", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "rtx", "X", "is", "a", "CONST", "or", "SYMBOL_REF", "with", "progmem", ".", "This", "must", "be", "used", "for", "AVR_TINY", "only", "because", "on", "other", "cores", "the", "flash", "memory", "is", "not", "visible", "in", "the", "RAM", "address", "range", "and", "can", "not", "be", "read", "by", ",", "say", ",", "LD", "instruction", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr", "Func": "avr_address_tiny_pm_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30490, "Length": 50}
{"ground_truth": ["<s>", "static", "scalar_int_mode", "avr_addr_space_address_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addrspace", "[", "as", "]", ".", "pointer_size", "==", "3", "?", "PSImode", ":", "HImode", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_ADDRESS_MODE", "'", "."], "TS_V_token": ["avr", "3"], "File": "avr", "Func": "avr_addr_space_address_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30491, "Length": 23}
{"ground_truth": ["<s>", "static", "rtx", "avr_addr_space_convert", "(", "rtx", "src", ",", "tree", "type_from", ",", "tree", "type_to", ")", "{", "addr_space_t", "as_from", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_from", ")", ")", ";", "addr_space_t", "as_to", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type_to", ")", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", ",", "src", ",", "type_from", ",", "type_to", ")", ";", "if", "(", "as_from", "!=", "ADDR_SPACE_MEMX", "&&", "as_to", "==", "ADDR_SPACE_MEMX", ")", "{", "int", "msb", ";", "rtx", "sym", "=", "src", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "PSImode", ")", ";", "while", "(", "CONST", "==", "GET_CODE", "(", "sym", ")", "||", "PLUS", "==", "GET_CODE", "(", "sym", ")", ")", "sym", "=", "XEXP", "(", "sym", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "sym", ")", "&&", "ADDR_SPACE_FLASH", "==", "AVR_SYMBOL_GET_ADDR_SPACE", "(", "sym", ")", ")", "{", "as_from", "=", "ADDR_SPACE_FLASH", ";", "}", "msb", "=", "ADDR_SPACE_GENERIC_P", "(", "as_from", ")", "?", "0x80", ":", "avr_addrspace", "[", "as_from", "]", ".", "segment", ";", "src", "=", "force_reg", "(", "Pmode", ",", "src", ")", ";", "emit_insn", "(", "msb", "==", "0", "?", "gen_zero_extendhipsi2", "(", "reg", ",", "src", ")", ":", "gen_n_extendhipsi2", "(", "reg", ",", "gen_int_mode", "(", "msb", ",", "QImode", ")", ",", "src", ")", ")", ";", "return", "reg", ";", "}", "if", "(", "as_from", "==", "ADDR_SPACE_MEMX", "&&", "as_to", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "new_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "src", "=", "force_reg", "(", "PSImode", ",", "src", ")", ";", "emit_move_insn", "(", "new_src", ",", "simplify_gen_subreg", "(", "Pmode", ",", "src", ",", "PSImode", ",", "0", ")", ")", ";", "return", "new_src", ";", "}", "return", "src", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_CONVERT", "'", "."], "TS_V_token": ["avr", "\"\\n%!: op = %r\\nfrom = %t\\nto = %t\\n\"", "0", "0x80", "0", "0"], "File": "avr", "Func": "avr_addr_space_convert", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30492, "Length": 234}
{"ground_truth": ["<s>", "static", "void", "avr_addr_space_diagnose_usage", "(", "addr_space_t", "as", ",", "location_t", "loc", ")", "{", "(", "void", ")", "avr_addr_space_supported_p", "(", "as", ",", "loc", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_DIAGNOSE_USAGE", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_addr_space_diagnose_usage", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30493, "Length": 22}
{"ground_truth": ["<s>", "static", "bool", "avr_addr_space_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ",", "addr_space_t", "as", ")", "{", "bool", "ok", "=", "false", ";", "switch", "(", "as", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ADDR_SPACE_GENERIC", ":", "return", "avr_legitimate_address_p", "(", "mode", ",", "x", ",", "strict", ")", ";", "case", "ADDR_SPACE_FLASH", ":", "case", "ADDR_SPACE_FLASH1", ":", "case", "ADDR_SPACE_FLASH2", ":", "case", "ADDR_SPACE_FLASH3", ":", "case", "ADDR_SPACE_FLASH4", ":", "case", "ADDR_SPACE_FLASH5", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "ok", "=", "avr_reg_ok_for_pgm_addr", "(", "x", ",", "strict", ")", ";", "break", ";", "case", "POST_INC", ":", "ok", "=", "avr_reg_ok_for_pgm_addr", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "case", "ADDR_SPACE_MEMX", ":", "if", "(", "REG_P", "(", "x", ")", ")", "ok", "=", "(", "!", "strict", "&&", "can_create_pseudo_p", "(", ")", ")", ";", "if", "(", "LO_SUM", "==", "GET_CODE", "(", "x", ")", ")", "{", "rtx", "hi", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "lo", "=", "XEXP", "(", "x", ",", "1", ")", ";", "ok", "=", "(", "REG_P", "(", "hi", ")", "&&", "(", "!", "strict", "||", "REGNO", "(", "hi", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "&&", "REG_P", "(", "lo", ")", "&&", "REGNO", "(", "lo", ")", "==", "REG_Z", ")", ";", "}", "break", ";", "}", "if", "(", "avr_log", ".", "legitimate_address_p", ")", "{", "avr_edump", "(", "\"\\n%?: ret=%b, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", ",", "ok", ",", "mode", ",", "strict", ",", "reload_completed", ",", "reload_in_progress", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", "&&", "reg_renumber", ")", "{", "avr_edump", "(", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "avr_edump", "(", "\"\\n%r\\n\"", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P", "'", "."], "TS_V_token": ["avr", "0", "0", "1", "\"\\n%?: ret=%b, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "\"(r%d ---> r%d)\"", "0", "0", "\"\\n%r\\n\""], "File": "avr", "Func": "avr_addr_space_legitimate_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30494, "Length": 319}
{"ground_truth": ["<s>", "static", "rtx", "avr_addr_space_legitimize_address", "(", "rtx", "x", ",", "rtx", "old_x", ",", "machine_mode", "mode", ",", "addr_space_t", "as", ")", "{", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "return", "avr_legitimize_address", "(", "x", ",", "old_x", ",", "mode", ")", ";", "if", "(", "avr_log", ".", "legitimize_address", ")", "{", "avr_edump", "(", "\"\\n%?: mode=%m\\n %r\\n\"", ",", "mode", ",", "old_x", ")", ";", "}", "return", "old_x", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS", "'", "."], "TS_V_token": ["avr", "\"\\n%?: mode=%m\\n %r\\n\""], "File": "avr", "Func": "avr_addr_space_legitimize_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30495, "Length": 55}
{"ground_truth": ["<s>", "static", "scalar_int_mode", "avr_addr_space_pointer_mode", "(", "addr_space_t", "as", ")", "{", "return", "avr_addr_space_address_mode", "(", "as", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_POINTER_MODE", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_addr_space_pointer_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30496, "Length": 15}
{"ground_truth": ["<s>", "static", "bool", "avr_addr_space_subset_p", "(", "addr_space_t", "subset", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "superset", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ADDR_SPACE_SUBSET_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_addr_space_subset_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30497, "Length": 17}
{"ground_truth": ["<s>", "bool", "avr_addr_space_supported_p", "(", "addr_space_t", "as", ",", "location_t", "loc", ")", "{", "if", "(", "AVR_TINY", ")", "{", "if", "(", "loc", "!=", "UNKNOWN_LOCATION", ")", "error_at", "(", "loc", ",", "\"address spaces are not supported for reduced \"", "\"Tiny devices\"", ")", ";", "return", "false", ";", "}", "else", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "{", "if", "(", "loc", "!=", "UNKNOWN_LOCATION", ")", "error_at", "(", "loc", ",", "\"address space %qs not supported for devices with \"", "\"flash size up to %d KiB\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "64", "*", "avr_n_flash", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "we", "support", "address", "space", "AS", "for", "the", "architecture", "in", "effect", "and", "false", ",", "otherwise", ".", "If", "LOC", "is", "not", "UNKNOWN_LOCATION", "then", "also", "issue", "a", "respective", "error", "."], "TS_V_token": ["avr", "\"address spaces are not supported for reduced \"", "\"Tiny devices\"", "\"address space %qs not supported for devices with \"", "\"flash size up to %d KiB\"", "64"], "File": "avr", "Func": "avr_addr_space_supported_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30498, "Length": 79}
{"ground_truth": ["<s>", "void", "avr_adjust_reg_alloc_order", "(", "void", ")", "{", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_0", "[", "]", "=", "{", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_1", "[", "]", "=", "{", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "(", "AVR_TINY", "?", "tiny_order_1", ":", "order_1", ")", ":", "TARGET_ORDER_2", "?", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_2", ")", ":", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_0", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>"], "natrual_language": ["Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "."], "TS_V_token": ["avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0"], "File": "avr", "Func": "avr_adjust_reg_alloc_order", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30499, "Length": 474}
{"ground_truth": ["<s>", "static", "void", "avr_adjust_type_node", "(", "tree", "*", "node", ",", "machine_mode", "mode", ",", "int", "sat_p", ")", "{", "*", "node", "=", "make_node", "(", "FIXED_POINT_TYPE", ")", ";", "TYPE_SATURATING", "(", "*", "node", ")", "=", "sat_p", ";", "TYPE_UNSIGNED", "(", "*", "node", ")", "=", "UNSIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", ";", "TYPE_IBIT", "(", "*", "node", ")", "=", "GET_MODE_IBIT", "(", "mode", ")", ";", "TYPE_FBIT", "(", "*", "node", ")", "=", "GET_MODE_FBIT", "(", "mode", ")", ";", "TYPE_PRECISION", "(", "*", "node", ")", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "SET_TYPE_ALIGN", "(", "*", "node", ",", "8", ")", ";", "SET_TYPE_MODE", "(", "*", "node", ",", "mode", ")", ";", "layout_type", "(", "*", "node", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "the", "function", "below", "."], "TS_V_token": ["avr", "8"], "File": "avr", "Func": "avr_adjust_type_node", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30500, "Length": 98}
{"ground_truth": ["<s>", "static", "bool", "avr_allocate_stack_slots_for_args", "(", "void", ")", "{", "return", "!", "cfun", "->", "machine", "->", "is_naked", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS", "'"], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_allocate_stack_slots_for_args", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30501, "Length": 16}
{"ground_truth": ["<s>", "static", "void", "avr_asm_final_postscan_insn", "(", "FILE", "*", "stream", ",", "rtx_insn", "*", "insn", ",", "rtx", "*", ",", "int", ")", "{", "if", "(", "cfun", "->", "machine", "->", "gasisr", ".", "yes", "&&", "!", "next_real_insn", "(", "insn", ")", ")", "{", "app_disable", "(", ")", ";", "fprintf", "(", "stream", ",", "\"\\t__gcc_isr %d,r%d\\n\"", ",", "GASISR_Done", ",", "cfun", "->", "machine", "->", "gasisr", ".", "regno", ")", ";", "}", "}", "</s>"], "natrual_language": ["When", "GAS", "generates", "(", "parts", "of", ")", "ISR", "prologue", "/", "epilogue", "for", "us", ",", "we", "must", "hint", "GAS", "about", "the", "end", "of", "the", "code", "to", "scan", ".", "There", "migh", "be", "code", "located", "after", "the", "last", "epilogue", "."], "TS_V_token": ["avr", "\"\\t__gcc_isr %d,r%d\\n\""], "File": "avr", "Func": "avr_asm_final_postscan_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30502, "Length": 58}
{"ground_truth": ["<s>", "static", "void", "avr_asm_function_begin_epilogue", "(", "FILE", "*", "file", ")", "{", "app_disable", "(", ")", ";", "fprintf", "(", "file", ",", "\"/* epilogue start */\\n\"", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_FUNCTION_BEGIN_EPILOGUE", "'", "."], "TS_V_token": ["avr", "\"/* epilogue start */\\n\""], "File": "avr", "Func": "avr_asm_function_begin_epilogue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30503, "Length": 21}
{"ground_truth": ["<s>", "static", "void", "avr_asm_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "fputs", "(", "\"/* prologue: naked */\\n\"", ",", "file", ")", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "fputs", "(", "\"/* prologue: Interrupt */\\n\"", ",", "file", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "is_signal", ")", "{", "fputs", "(", "\"/* prologue: Signal */\\n\"", ",", "file", ")", ";", "}", "else", "fputs", "(", "\"/* prologue: function */\\n\"", ",", "file", ")", ";", "}", "if", "(", "ACCUMULATE_OUTGOING_ARGS", ")", "fprintf", "(", "file", ",", "\"/* outgoing args size = %d */\\n\"", ",", "avr_outgoing_args_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* frame size = \"", "HOST_WIDE_INT_PRINT_DEC", "\" */\\n\"", ",", "(", "HOST_WIDE_INT", ")", "get_frame_size", "(", ")", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "gasisr", ".", "yes", ")", "{", "fprintf", "(", "file", ",", "\"/* stack size = %d */\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "}", "else", "{", "int", "used_by_gasisr", "=", "3", "+", "(", "cfun", "->", "machine", "->", "gasisr", ".", "regno", "!=", "AVR_TMP_REGNO", ")", ";", "int", "to", "=", "cfun", "->", "machine", "->", "stack_usage", ";", "int", "from", "=", "to", "-", "used_by_gasisr", ";", "fprintf", "(", "file", ",", "\"/* stack size = %d...%d */\\n\"", ",", "from", ",", "to", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d + __gcc_isr.n_pushed\\n\"", ",", "from", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "summary", "at", "end", "of", "function", "prologue", "."], "TS_V_token": ["avr", "\"/* prologue: naked */\\n\"", "\"/* prologue: Interrupt */\\n\"", "\"/* prologue: Signal */\\n\"", "\"/* prologue: function */\\n\"", "\"/* outgoing args size = %d */\\n\"", "\"/* frame size = \"", "\" */\\n\"", "\"/* stack size = %d */\\n\"", "\".L__stack_usage = %d\\n\"", "3", "\"/* stack size = %d...%d */\\n\"", "\".L__stack_usage = %d + __gcc_isr.n_pushed\\n\""], "File": "avr", "Func": "avr_asm_function_end_prologue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30504, "Length": 199}
{"ground_truth": ["<s>", "static", "void", "avr_asm_init_sections", "(", "void", ")", "{", "if", "(", "avr_arch", "->", "flash_pm_offset", "==", "0", ")", "readonly_data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "bss_section", "->", "unnamed", ".", "callback", "=", "avr_output_bss_section_asm_op", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_INIT_SECTIONS", "'", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "avr_asm_init_sections", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30505, "Length": 40}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_asm_len", "(", "const", "char", "*", "tpl", ",", "rtx", "*", "operands", ",", "int", "*", "plen", ",", "int", "n_words", ")", "{", "if", "(", "plen", "==", "NULL", ")", "output_asm_insn", "(", "tpl", ",", "operands", ")", ";", "else", "{", "if", "(", "n_words", "<", "0", ")", "*", "plen", "=", "-", "n_words", ";", "else", "*", "plen", "+=", "n_words", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "to", "print", "assembler", "resp", ".", "track", "instruction", "sequence", "lengths", ".", "Always", "return", "``", "''", ".", "If", "PLEN", "==", "NULL", ":", "Output", "assembler", "code", "from", "template", "TPL", "with", "operands", "supplied", "by", "OPERANDS", ".", "This", "is", "just", "forwarding", "to", "output_asm_insn", ".", "If", "PLEN", "!", "=", "NULL", ":", "If", "N_WORDS", ">", "=", "0", "Add", "N_WORDS", "to", "*", "PLEN", ".", "If", "N_WORDS", "<", "0", "Set", "*", "PLEN", "to", "-N_WORDS", ".", "Do", "n't", "output", "anything", "."], "TS_V_token": ["avr", "0", "\"\""], "File": "avr", "Func": "avr_asm_len", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30506, "Length": 61}
{"ground_truth": ["<s>", "static", "void", "avr_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", ")", "{", "if", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "{", "addr_space_t", "as", "=", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "/", "SECTION_MACH_DEP", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "startswith", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "default_elf_asm_named_section", "(", "sname", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "default_elf_asm_named_section", "(", "new_prefix", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "avr_need_copy_data_p", ")", "avr_need_copy_data_p", "=", "(", "startswith", "(", "name", ",", "\".data\"", ")", "||", "startswith", "(", "name", ",", "\".gnu.linkonce.d\"", ")", ")", ";", "if", "(", "!", "avr_need_copy_data_p", "&&", "avr_arch", "->", "flash_pm_offset", "==", "0", ")", "avr_need_copy_data_p", "=", "(", "startswith", "(", "name", ",", "\".rodata\"", ")", "||", "startswith", "(", "name", ",", "\".gnu.linkonce.r\"", ")", ")", ";", "if", "(", "!", "avr_need_clear_bss_p", ")", "avr_need_clear_bss_p", "=", "startswith", "(", "name", ",", "\".bss\"", ")", ";", "default_elf_asm_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "}", "</s>"], "natrual_language": ["Track", "need", "of", "__do_clear_bss", ",", "__do_copy_data", "for", "named", "sections", "."], "TS_V_token": ["avr", "\".rodata\"", "\".data\"", "\".gnu.linkonce.d\"", "0", "\".rodata\"", "\".gnu.linkonce.r\"", "\".bss\""], "File": "avr", "Func": "avr_asm_named_section", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30507, "Length": 185}
{"ground_truth": ["<s>", "void", "avr_asm_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", ",", "bool", "local_p", ")", "{", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "rtx", "symbol", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "SYMBOL_REF_P", "(", "(", "symbol", "=", "XEXP", "(", "mem", ",", "0", ")", ")", ")", "&&", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "(", "SYMBOL_FLAG_IO", "|", "SYMBOL_FLAG_ADDRESS", ")", ")", ")", "{", "if", "(", "!", "local_p", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.globl\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "if", "(", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "SYMBOL_FLAG_ADDRESS", ")", "{", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\" = %ld\\n\"", ",", "(", "long", ")", "INTVAL", "(", "avr_eval_addr_attrib", "(", "symbol", ")", ")", ")", ";", "}", "else", "if", "(", "local_p", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"static IO declaration for %q+D needs an address\"", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "startswith", "(", "name", ",", "\"__gnu_lto\"", ")", ")", "avr_need_clear_bss_p", "=", "true", ";", "if", "(", "local_p", ")", "ASM_OUTPUT_ALIGNED_LOCAL", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "else", "ASM_OUTPUT_ALIGNED_COMMON", "(", "stream", ",", "name", ",", "size", ",", "align", ")", ";", "}", "</s>"], "natrual_language": ["Track", "need", "of", "__do_clear_bss", "."], "TS_V_token": ["avr", "0", "\"\\t.globl\\t\"", "\"\\n\"", "\" = %ld\\n\"", "\"static IO declaration for %q+D needs an address\"", "\"__gnu_lto\""], "File": "avr", "Func": "avr_asm_output_aligned_decl_common", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30508, "Length": 209}
{"ground_truth": ["<s>", "static", "void", "avr_asm_out_ctor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "fputs", "(", "\"\\t.global __do_global_ctors\\n\"", ",", "asm_out_file", ")", ";", "default_ctor_section_asm_out_constructor", "(", "symbol", ",", "priority", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_ASM_CONSTRUCTOR", "."], "TS_V_token": ["avr", "\"\\t.global __do_global_ctors\\n\""], "File": "avr", "Func": "avr_asm_out_ctor", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30509, "Length": 26}
{"ground_truth": ["<s>", "static", "void", "avr_asm_out_dtor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "fputs", "(", "\"\\t.global __do_global_dtors\\n\"", ",", "asm_out_file", ")", ";", "default_dtor_section_asm_out_destructor", "(", "symbol", ",", "priority", ")", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_ASM_DESTRUCTOR", "."], "TS_V_token": ["avr", "\"\\t.global __do_global_dtors\\n\""], "File": "avr", "Func": "avr_asm_out_dtor", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30510, "Length": 26}
{"ground_truth": ["<s>", "static", "section", "*", "avr_asm_select_section", "(", "tree", "decl", ",", "int", "reloc", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "section", "*", "sect", "=", "default_elf_select_section", "(", "decl", ",", "reloc", ",", "align", ")", ";", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "if", "(", "sect", "->", "common", ".", "flags", "&", "SECTION_NAMED", ")", "{", "const", "char", "*", "name", "=", "sect", "->", "named", ".", "name", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "startswith", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "return", "get_section", "(", "sname", ",", "sect", "->", "common", ".", "flags", "&", "~", "SECTION_DECLARED", ",", "sect", "->", "named", ".", "decl", ")", ";", "}", "}", "if", "(", "!", "progmem_section", "[", "as", "]", ")", "{", "progmem_section", "[", "as", "]", "=", "get_unnamed_section", "(", "0", ",", "avr_output_progmem_section_asm_op", ",", "avr_addrspace", "[", "as", "]", ".", "section_name", ")", ";", "}", "return", "progmem_section", "[", "as", "]", ";", "}", "return", "sect", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_ASM_SELECT_SECTION", "'"], "TS_V_token": ["avr", "\".rodata\"", "0"], "File": "avr", "Func": "avr_asm_select_section", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30511, "Length": 206}
{"ground_truth": ["<s>", "static", "bool", "avr_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "aligned_p", "&&", "text_segment_operand", "(", "x", ",", "VOIDmode", ")", ")", "{", "fputs", "(", "\"\\t.word\\tgs(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "PSImode", ")", "{", "fputs", "(", "\"\\t.byte\\tlo8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thi8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.byte\\thh8(\"", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\"", "ASM_COMMENT_START", "\"need binutils PR13503\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "else", "if", "(", "CONST_FIXED_P", "(", "x", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "<", "size", ";", "n", "++", ")", "{", "rtx", "xn", "=", "simplify_gen_subreg", "(", "QImode", ",", "x", ",", "GET_MODE", "(", "x", ")", ",", "n", ")", ";", "default_assemble_integer", "(", "xn", ",", "1", ",", "aligned_p", ")", ";", "}", "return", "true", ";", "}", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_pm_p", "(", "x", ")", ")", "{", "x", "=", "plus_constant", "(", "Pmode", ",", "x", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>"], "natrual_language": ["Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "AVR", "version", "needs", "special", "handling", "for", "references", "to", "certain", "labels", "."], "TS_V_token": ["avr", "\"\\t.word\\tgs(\"", "\")\\n\"", "\"\\t.byte\\tlo8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thi8(\"", "\")\"", "\"need binutils PR13503\\n\"", "\"\\t.byte\\thh8(\"", "\")\"", "\"need binutils PR13503\\n\"", "0", "1"], "File": "avr", "Func": "avr_assemble_integer", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30512, "Length": 232}
{"ground_truth": ["<s>", "static", "tree", "avr_build_builtin_va_list", "(", "void", ")", "{", "avr_adjust_type_node", "(", "&", "ta_type_node", ",", "TAmode", ",", "0", ")", ";", "avr_adjust_type_node", "(", "&", "uta_type_node", ",", "UTAmode", ",", "0", ")", ";", "avr_adjust_type_node", "(", "&", "sat_ta_type_node", ",", "TAmode", ",", "1", ")", ";", "avr_adjust_type_node", "(", "&", "sat_uta_type_node", ",", "UTAmode", ",", "1", ")", ";", "unsigned_long_long_accum_type_node", "=", "uta_type_node", ";", "long_long_accum_type_node", "=", "ta_type_node", ";", "sat_unsigned_long_long_accum_type_node", "=", "sat_uta_type_node", ";", "sat_long_long_accum_type_node", "=", "sat_ta_type_node", ";", "return", "std_build_builtin_va_list", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_BUILD_BUILTIN_VA_LIST", "'", "."], "TS_V_token": ["avr", "0", "0", "1", "1"], "File": "avr", "Func": "avr_build_builtin_va_list", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30513, "Length": 69}
{"ground_truth": ["<s>", "static", "tree", "avr_builtin_decl", "(", "unsigned", "id", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", "return", "avr_bdesc", "[", "id", "]", ".", "fndecl", ";", "return", "error_mark_node", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_BUILTIN_DECL", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_builtin_decl", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30514, "Length": 30}
{"ground_truth": ["<s>", "static", "bool", "avr_cannot_modify_jumps_p", "(", "void", ")", "{", "if", "(", "reload_completed", "&&", "cfun", "->", "machine", "&&", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_CANNOT_MODITY_JUMPS_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_cannot_modify_jumps_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30515, "Length": 30}
{"ground_truth": ["<s>", "static", "bool", "avr_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "frame_pointer_needed", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "frame_pointer_needed", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "register", "FROM", "can", "be", "eliminated", "via", "register", "TO", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_can_eliminate", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30516, "Length": 29}
{"ground_truth": ["<s>", "bool", "avr_casei_sequence_check_operands", "(", "rtx", "*", "xop", ")", "{", "rtx", "sub_5", "=", "NULL_RTX", ";", "if", "(", "AVR_HAVE_EIJMP_EICALL", "&&", "xop", "[", "8", "]", "==", "all_regs_rtx", "[", "24", "]", ")", "{", "sub_5", "=", "xop", "[", "6", "]", ";", "}", "if", "(", "!", "AVR_HAVE_EIJMP_EICALL", "&&", "PLUS", "==", "GET_CODE", "(", "xop", "[", "6", "]", ")", "&&", "LABEL_REF", "==", "GET_CODE", "(", "XEXP", "(", "xop", "[", "6", "]", ",", "1", ")", ")", "&&", "rtx_equal_p", "(", "xop", "[", "3", "]", ",", "XEXP", "(", "XEXP", "(", "xop", "[", "6", "]", ",", "1", ")", ",", "0", ")", ")", "&&", "xop", "[", "8", "]", "==", "const0_rtx", ")", "{", "sub_5", "=", "XEXP", "(", "xop", "[", "6", "]", ",", "0", ")", ";", "}", "if", "(", "sub_5", "&&", "SUBREG_P", "(", "sub_5", ")", "&&", "SUBREG_BYTE", "(", "sub_5", ")", "==", "0", "&&", "rtx_equal_p", "(", "xop", "[", "5", "]", ",", "SUBREG_REG", "(", "sub_5", ")", ")", ")", "return", "true", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\"", ")", ";", "return", "false", ";", "}", "</s>"], "natrual_language": ["Perform", "some", "extra", "checks", "on", "operands", "of", "casesi_", "<", "mode", ">", "_sequence", ".", "Not", "all", "operand", "dependencies", "can", "be", "described", "by", "means", "of", "predicates", ".", "This", "function", "performs", "left", "over", "checks", "and", "should", "always", "return", "true", ".", "Returning", "false", "means", "that", "someone", "changed", "the", "casesi", "expander", "but", "did", "not", "adjust", "casesi_", "<", "mode", ">", "_sequence", "."], "TS_V_token": ["avr", "8", "24", "6", "6", "6", "1", "3", "6", "1", "0", "8", "6", "0", "0", "5", "\"\\n;; Failed condition for casesi_<mode>_sequence\\n\\n\""], "File": "avr", "Func": "avr_casei_sequence_check_operands", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30517, "Length": 157}
{"ground_truth": ["<s>", "static", "unsigned", "int", "avr_case_values_threshold", "(", "void", ")", "{", "return", "7", ";", "}", "</s>"], "natrual_language": ["Supply", "the", "default", "for", "--", "param", "case-values-threshold=0"], "TS_V_token": ["avr", "7"], "File": "avr", "Func": "avr_case_values_threshold", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30518, "Length": 12}
{"ground_truth": ["<s>", "static", "bool", "avr_class_likely_spilled_p", "(", "reg_class_t", "c", ")", "{", "return", "(", "c", "!=", "ALL_REGS", "&&", "(", "AVR_TINY", "?", "1", ":", "c", "!=", "ADDW_REGS", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "value", "is", "nonzero", "if", "pseudos", "that", "have", "been", "assigned", "to", "registers", "of", "class", "CLASS", "would", "likely", "be", "spilled", "because", "registers", "of", "CLASS", "are", "needed", "for", "spill", "registers", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_class_likely_spilled_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30519, "Length": 26}
{"ground_truth": ["<s>", "static", "unsigned", "char", "avr_class_max_nregs", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", ")", "{", "if", "(", "rclass", "==", "CC_REG", "&&", "mode", "==", "CCmode", ")", "return", "1", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_CLASS_MAX_NREGS", ".", "Reasons", "described", "in", "comments", "for", "avr_hard_regno_nregs", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_class_max_nregs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30520, "Length": 37}
{"ground_truth": ["<s>", "static", "rtx", "avr_compare_pattern", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", "&&", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "REG_P", "(", "SET_DEST", "(", "pattern", ")", ")", "&&", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", "==", "REG_CC", "&&", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "==", "COMPARE", ")", "{", "machine_mode", "mode0", "=", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "0", ")", ")", ";", "machine_mode", "mode1", "=", "GET_MODE", "(", "XEXP", "(", "SET_SRC", "(", "pattern", ")", ",", "1", ")", ")", ";", "if", "(", "(", "mode0", "==", "VOIDmode", "||", "GET_MODE_SIZE", "(", "mode0", ")", "<=", "4", ")", "&&", "(", "mode1", "==", "VOIDmode", "||", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "4", ")", ")", "return", "pattern", ";", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "`", "avr_reorg", "'", "."], "TS_V_token": ["avr", "0", "1", "4", "4"], "File": "avr", "Func": "avr_compare_pattern", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30521, "Length": 123}
{"ground_truth": ["<s>", "static", "void", "avr_conditional_register_usage", "(", "void", ")", "{", "if", "(", "AVR_TINY", ")", "{", "const", "int", "tiny_reg_alloc_order", "[", "]", "=", "{", "24", ",", "25", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<=", "17", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "for", "(", "size_t", "i", "=", "18", ";", "i", "<=", "LAST_CALLEE_SAVED_REG", ";", "i", "++", ")", "{", "call_used_regs", "[", "i", "]", "=", "0", ";", "}", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "tiny_reg_alloc_order", ")", ";", "i", "++", ")", "{", "reg_alloc_order", "[", "i", "]", "=", "tiny_reg_alloc_order", "[", "i", "]", ";", "}", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "ADDW_REGS", "]", ")", ";", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "NO_LD_REGS", "]", ")", ";", "}", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_CONDITIONAL_REGISTER_USAGE", "'", "."], "TS_V_token": ["avr", "24", "25", "22", "23", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "0", "17", "1", "1", "18", "0", "0"], "File": "avr", "Func": "avr_conditional_register_usage", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30522, "Length": 198}
{"ground_truth": ["<s>", "static", "tree", "avr_convert_to_type", "(", "tree", "type", ",", "tree", "expr", ")", "{", "if", "(", "avr_warn_addr_space_convert", "&&", "expr", "!=", "error_mark_node", "&&", "POINTER_TYPE_P", "(", "type", ")", "&&", "POINTER_TYPE_P", "(", "TREE_TYPE", "(", "expr", ")", ")", ")", "{", "addr_space_t", "as_old", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "expr", ")", ")", ")", ";", "addr_space_t", "as_new", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"%?: type = %t\\nexpr = %t\\n\\n\"", ",", "type", ",", "expr", ")", ";", "if", "(", "as_new", "!=", "ADDR_SPACE_MEMX", "&&", "as_new", "!=", "as_old", ")", "{", "location_t", "loc", "=", "EXPR_LOCATION", "(", "expr", ")", ";", "const", "char", "*", "name_old", "=", "avr_addrspace", "[", "as_old", "]", ".", "name", ";", "const", "char", "*", "name_new", "=", "avr_addrspace", "[", "as_new", "]", ".", "name", ";", "warning", "(", "OPT_Waddr_space_convert", ",", "\"conversion from address space %qs to address space %qs\"", ",", "ADDR_SPACE_GENERIC_P", "(", "as_old", ")", "?", "\"generic\"", ":", "name_old", ",", "ADDR_SPACE_GENERIC_P", "(", "as_new", ")", "?", "\"generic\"", ":", "name_new", ")", ";", "return", "fold_build1_loc", "(", "loc", ",", "ADDR_SPACE_CONVERT_EXPR", ",", "type", ",", "expr", ")", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_CONVERT_TO_TYPE", "'", "."], "TS_V_token": ["avr", "\"%?: type = %t\\nexpr = %t\\n\\n\"", "\"conversion from address space %qs to address space %qs\"", "\"generic\"", "\"generic\""], "File": "avr", "Func": "avr_convert_to_type", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30523, "Length": 159}
{"ground_truth": ["<s>", "static", "bool", "avr_decl_absdata_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "return", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "NULL_TREE", "!=", "lookup_attribute", "(", "\"absdata\"", ",", "attributes", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "DECL", "has", "attribute", "`", "absdata", "'", "set", ".", "This", "function", "should", "only", "be", "used", "for", "AVR_TINY", "."], "TS_V_token": ["avr", "\"absdata\""], "File": "avr", "Func": "avr_decl_absdata_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30524, "Length": 31}
{"ground_truth": ["<s>", "static", "bool", "avr_decl_flash_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "||", "TREE_TYPE", "(", "decl", ")", "==", "error_mark_node", ")", "{", "return", "false", ";", "}", "return", "!", "ADDR_SPACE_GENERIC_P", "(", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "DECL", "is", "a", "VAR_DECL", "located", "in", "flash", "and", "FALSE", ",", "otherwise", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_decl_flash_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30525, "Length": 43}
{"ground_truth": ["<s>", "static", "bool", "avr_decl_maybe_lds_p", "(", "tree", "node", ")", "{", "if", "(", "!", "node", "||", "TREE_CODE", "(", "node", ")", "!=", "VAR_DECL", "||", "DECL_SECTION_NAME", "(", "node", ")", "!=", "NULL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "node", ")", ")", "return", "false", ";", "do", "node", "=", "TREE_TYPE", "(", "node", ")", ";", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "node", ")", ")", ";", "return", "(", "node", "!=", "error_mark_node", "&&", "!", "TYPE_READONLY", "(", "node", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "helper", "for", "the", "next", "function", ".", "NODE", "is", "a", "decl", "that", "is", "associated", "with", "a", "symbol", ".", "Return", "TRUE", "if", "the", "respective", "object", "may", "be", "accessed", "by", "LDS", ".", "There", "might", "still", "be", "other", "reasons", "for", "why", "LDS", "is", "not", "appropriate", ".", "This", "function", "is", "only", "appropriate", "for", "AVR_TINY", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_decl_maybe_lds_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30526, "Length": 72}
{"ground_truth": ["<s>", "static", "bool", "avr_decl_memx_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "||", "TREE_TYPE", "(", "decl", ")", "==", "error_mark_node", ")", "{", "return", "false", ";", "}", "return", "(", "ADDR_SPACE_MEMX", "==", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "DECL", "is", "a", "VAR_DECL", "located", "in", "the", "24-bit", "flash", "address", "space", "and", "FALSE", ",", "otherwise", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_decl_memx_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30527, "Length": 43}
{"ground_truth": ["<s>", "static", "rtx", "avr_default_expand_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ",", "xop", "[", "3", "]", ";", "int", "n_args", "=", "call_expr_nargs", "(", "exp", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "gcc_assert", "(", "n_args", ">=", "1", "&&", "n_args", "<=", "3", ")", ";", "if", "(", "target", "==", "NULL_RTX", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "target", ",", "tmode", ")", ")", "{", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "for", "(", "int", "n", "=", "0", ";", "n", "<", "n_args", ";", "n", "++", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "n", ")", ";", "rtx", "op", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "machine_mode", "opmode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "mode", ";", "if", "(", "(", "opmode", "==", "SImode", "||", "opmode", "==", "VOIDmode", ")", "&&", "mode", "==", "HImode", ")", "{", "opmode", "=", "HImode", ";", "op", "=", "gen_lowpart", "(", "HImode", ",", "op", ")", ";", "}", "gcc_assert", "(", "opmode", "==", "mode", "||", "opmode", "==", "VOIDmode", ")", ";", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "predicate", "(", "op", ",", "mode", ")", ")", "op", "=", "copy_to_mode_reg", "(", "mode", ",", "op", ")", ";", "xop", "[", "n", "]", "=", "op", ";", "}", "switch", "(", "n_args", ")", "{", "case", "1", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ")", ";", "break", ";", "case", "3", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ",", "xop", "[", "2", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "pat", "==", "NULL_RTX", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>"], "natrual_language": ["Subroutine", "of", "avr_expand_builtin", "to", "expand", "vanilla", "builtins", "with", "non-void", "result", "and", "1", "...", "3", "arguments", "."], "TS_V_token": ["avr", "3", "0", "1", "3", "0", "0", "1", "1", "1", "0", "2", "0", "1", "3", "0", "1", "2"], "File": "avr", "Func": "avr_default_expand_builtin", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30528, "Length": 347}
{"ground_truth": ["<s>", "bool", "avr_emit3_fix_outputs", "(", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "rtx", "*", "op", ",", "unsigned", "opmask", ",", "unsigned", "rmask", ")", "{", "const", "int", "n", "=", "3", ";", "rtx", "hreg", "[", "n", "]", ";", "static", "bool", "lock", "=", "false", ";", "gcc_assert", "(", "opmask", "<", "(", "1u", "<<", "n", ")", ")", ";", "if", "(", "lock", ")", "return", "false", ";", "avr_fix_operands", "(", "op", ",", "hreg", ",", "opmask", ",", "rmask", ")", ";", "lock", "=", "true", ";", "emit_insn", "(", "gen", "(", "op", "[", "0", "]", ",", "op", "[", "1", "]", ",", "op", "[", "2", "]", ")", ")", ";", "lock", "=", "false", ";", "return", "avr_move_fixed_operands", "(", "op", ",", "hreg", ",", "opmask", ")", ";", "}", "</s>"], "natrual_language": ["PR63633", ":", "The", "middle-end", "might", "come", "up", "with", "hard", "regs", "as", "output", "operands", ".", "GEN", "is", "a", "sequence", "generating", "function", "like", "gen_mulsi3", "with", "3", "operands", "OP", "[", "]", ".", "RMASK", "is", "a", "bit", "mask", "representing", "a", "subset", "of", "hard", "registers", "R0", "...", "R31", ":", "Rn", "is", "an", "element", "of", "that", "set", "iff", "bit", "n", "of", "RMASK", "is", "set", ".", "OPMASK", "describes", "a", "subset", "of", "OP", "[", "]", ":", "If", "bit", "n", "of", "OPMASK", "is", "1", "then", "OP", "[", "n", "]", "has", "to", "be", "fixed", ";", "otherwise", "OP", "[", "n", "]", "is", "left", "alone", ".", "Emit", "the", "insn", "sequence", "as", "generated", "by", "GEN", "(", ")", "with", "all", "elements", "of", "OPMASK", "which", "are", "hard", "registers", "overlapping", "RMASK", "replaced", "by", "newly", "created", "pseudo", "registers", ".", "After", "the", "sequence", "has", "been", "emitted", ",", "emit", "insns", "that", "move", "the", "contents", "of", "respective", "pseudos", "to", "their", "hard", "regs", "."], "TS_V_token": ["avr", "3", "1u", "0", "1", "2"], "File": "avr", "Func": "avr_emit3_fix_outputs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30529, "Length": 114}
{"ground_truth": ["<s>", "bool", "avr_emit_cpymemhi", "(", "rtx", "*", "xop", ")", "{", "HOST_WIDE_INT", "count", ";", "machine_mode", "loop_mode", ";", "addr_space_t", "as", "=", "MEM_ADDR_SPACE", "(", "xop", "[", "1", "]", ")", ";", "rtx", "loop_reg", ",", "addr1", ",", "a_src", ",", "a_dest", ",", "insn", ",", "xas", ";", "rtx", "a_hi8", "=", "NULL_RTX", ";", "if", "(", "avr_mem_flash_p", "(", "xop", "[", "0", "]", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", "return", "false", ";", "count", "=", "INTVAL", "(", "xop", "[", "2", "]", ")", ";", "if", "(", "count", "<=", "0", ")", "return", "false", ";", "a_src", "=", "XEXP", "(", "xop", "[", "1", "]", ",", "0", ")", ";", "a_dest", "=", "XEXP", "(", "xop", "[", "0", "]", ",", "0", ")", ";", "if", "(", "PSImode", "==", "GET_MODE", "(", "a_src", ")", ")", "{", "gcc_assert", "(", "as", "==", "ADDR_SPACE_MEMX", ")", ";", "loop_mode", "=", "(", "count", "<", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "gen_rtx_REG", "(", "loop_mode", ",", "24", ")", ";", "emit_move_insn", "(", "loop_reg", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "addr1", "=", "simplify_gen_subreg", "(", "HImode", ",", "a_src", ",", "PSImode", ",", "0", ")", ";", "a_hi8", "=", "simplify_gen_subreg", "(", "QImode", ",", "a_src", ",", "PSImode", ",", "2", ")", ";", "}", "else", "{", "int", "segment", "=", "avr_addrspace", "[", "as", "]", ".", "segment", ";", "if", "(", "segment", "&&", "avr_n_flash", ">", "1", ")", "{", "a_hi8", "=", "GEN_INT", "(", "segment", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "a_hi8", "=", "copy_to_mode_reg", "(", "QImode", ",", "a_hi8", ")", ")", ";", "}", "else", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "as", "=", "ADDR_SPACE_FLASH", ";", "}", "addr1", "=", "a_src", ";", "loop_mode", "=", "(", "count", "<=", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "copy_to_mode_reg", "(", "loop_mode", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "}", "xas", "=", "GEN_INT", "(", "as", ")", ";", "emit_move_insn", "(", "lpm_addr_reg_rtx", ",", "addr1", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "HImode", ",", "REG_X", ")", ",", "a_dest", ")", ";", "gcc_assert", "(", "TMP_REGNO", "==", "LPM_REGNO", ")", ";", "if", "(", "as", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_cpymem_qi", ":", "gen_cpymem_hi", ";", "insn", "=", "fun", "(", "xas", ",", "loop_reg", ",", "loop_reg", ")", ";", "}", "else", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_cpymemx_qi", ":", "gen_cpymemx_hi", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "QImode", ",", "23", ")", ",", "a_hi8", ")", ";", "insn", "=", "fun", "(", "xas", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "}", "set_mem_addr_space", "(", "SET_SRC", "(", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", ")", ",", "as", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "cpymemhi", "expander", ".", "XOP", "[", "0", "]", "Destination", "as", "MEM", ":", "BLK", "XOP", "[", "1", "]", "Source", "``", "``", "XOP", "[", "2", "]", "#", "Bytes", "to", "copy", "Return", "TRUE", "if", "the", "expansion", "is", "accomplished", ".", "Return", "FALSE", "if", "the", "operand", "compination", "is", "not", "supported", "."], "TS_V_token": ["avr", "1", "0", "2", "2", "0", "1", "0", "0", "0", "0x100", "24", "0", "2", "1", "0x100", "23", "0", "0"], "File": "avr", "Func": "avr_emit_cpymemhi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30530, "Length": 426}
{"ground_truth": ["<s>", "int", "avr_epilogue_uses", "(", "int", "regno", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "reload_completed", "&&", "cfun", "->", "machine", "&&", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "EPILOGUE_USES", "'", "."], "TS_V_token": ["avr", "1", "0"], "File": "avr", "Func": "avr_epilogue_uses", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30531, "Length": 37}
{"ground_truth": ["<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_NOPS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_nops", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>"], "natrual_language": ["Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "."], "TS_V_token": ["avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0"], "File": "avr", "Func": "avr_expand_builtin", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30532, "Length": 506}
{"ground_truth": ["<s>", "void", "avr_expand_prologue", "(", "void", ")", "{", "HARD_REG_SET", "set", ";", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", ";", "cfun", "->", "machine", "->", "stack_usage", "=", "0", ";", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "return", ";", "}", "avr_regs_to_save", "(", "&", "set", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "int", "treg", "=", "AVR_TMP_REGNO", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "emit_insn", "(", "gen_enable_interrupt", "(", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "gasisr", ".", "maybe", ")", "{", "cfun", "->", "machine", "->", "gasisr", ".", "yes", "=", "1", ";", "treg", "=", "avr_hregs_split_reg", "(", "&", "set", ")", ";", "if", "(", "treg", "<", "0", ")", "treg", "=", "AVR_TMP_REGNO", ";", "cfun", "->", "machine", "->", "gasisr", ".", "regno", "=", "treg", ";", "cfun", "->", "machine", "->", "stack_usage", "+=", "3", "+", "(", "treg", "!=", "AVR_TMP_REGNO", ")", ";", "emit_insn", "(", "gen_gasisr", "(", "GEN_INT", "(", "GASISR_Prologue", ")", ",", "GEN_INT", "(", "treg", ")", ")", ")", ";", "}", "else", "{", "emit_push_byte", "(", "AVR_ZERO_REGNO", ",", "true", ")", ";", "emit_push_byte", "(", "AVR_TMP_REGNO", ",", "true", ")", ";", "emit_push_sfr", "(", "sreg_rtx", ",", "false", ",", "false", ",", "AVR_TMP_REGNO", ")", ";", "emit_move_insn", "(", "zero_reg_rtx", ",", "const0_rtx", ")", ";", "emit_use", "(", "zero_reg_rtx", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPD", ")", "emit_push_sfr", "(", "rampd_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "if", "(", "AVR_HAVE_RAMPX", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_X", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampx_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPY", "&&", "(", "frame_pointer_needed", "||", "(", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "emit_push_sfr", "(", "rampy_rtx", ",", "false", ",", "true", ",", "treg", ")", ";", "}", "if", "(", "AVR_HAVE_RAMPZ", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "set", ",", "REG_Z", "+", "1", ")", ")", "{", "emit_push_sfr", "(", "rampz_rtx", ",", "false", ",", "AVR_HAVE_RAMPD", ",", "treg", ")", ";", "}", "}", "avr_prologue_setup_frame", "(", "size", ",", "set", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "cfun", "->", "machine", "->", "stack_usage", "+", "INCOMING_FRAME_SP_OFFSET", ";", "}", "</s>"], "natrual_language": ["Output", "function", "prologue", "."], "TS_V_token": ["avr", "0", "1", "0", "3", "1", "1", "1"], "File": "avr", "Func": "avr_expand_prologue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30533, "Length": 346}
{"ground_truth": ["<s>", "static", "void", "avr_file_end", "(", "void", ")", "{", "if", "(", "avr_need_copy_data_p", ")", "fputs", "(", "\".global __do_copy_data\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "avr_need_clear_bss_p", ")", "fputs", "(", "\".global __do_clear_bss\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>"], "natrual_language": ["Outputs", "to", "the", "stdio", "stream", "FILE", "some", "appropriate", "text", "to", "go", "at", "the", "end", "of", "an", "assembler", "file", "."], "TS_V_token": ["avr", "\".global __do_copy_data\\n\"", "\".global __do_clear_bss\\n\""], "File": "avr", "Func": "avr_file_end", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30534, "Length": 30}
{"ground_truth": ["<s>", "static", "void", "avr_file_start", "(", "void", ")", "{", "int", "sfr_offset", "=", "avr_arch", "->", "sfr_offset", ";", "if", "(", "avr_arch", "->", "asm_only", ")", "error", "(", "\"architecture %qs supported for assembler only\"", ",", "avr_mmcu", ")", ";", "default_file_start", "(", ")", ";", "if", "(", "AVR_HAVE_SPH", ")", "fprintf", "(", "asm_out_file", ",", "\"__SP_H__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sp_h", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__SP_L__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sp_l", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__SREG__ = 0x%02x\\n\"", ",", "avr_addr", ".", "sreg", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPZ", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPZ__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampz", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPY", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPY__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampy", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPX", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPX__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampx", "-", "sfr_offset", ")", ";", "if", "(", "AVR_HAVE_RAMPD", ")", "fprintf", "(", "asm_out_file", ",", "\"__RAMPD__ = 0x%02x\\n\"", ",", "avr_addr", ".", "rampd", "-", "sfr_offset", ")", ";", "if", "(", "AVR_XMEGA", "||", "AVR_TINY", ")", "fprintf", "(", "asm_out_file", ",", "\"__CCP__ = 0x%02x\\n\"", ",", "avr_addr", ".", "ccp", "-", "sfr_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__tmp_reg__ = %d\\n\"", ",", "AVR_TMP_REGNO", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"__zero_reg__ = %d\\n\"", ",", "AVR_ZERO_REGNO", ")", ";", "}", "</s>"], "natrual_language": ["Outputs", "some", "appropriate", "text", "to", "go", "at", "the", "start", "of", "an", "assembler", "file", "."], "TS_V_token": ["avr", "\"architecture %qs supported for assembler only\"", "\"__SP_H__ = 0x%02x\\n\"", "\"__SP_L__ = 0x%02x\\n\"", "\"__SREG__ = 0x%02x\\n\"", "\"__RAMPZ__ = 0x%02x\\n\"", "\"__RAMPY__ = 0x%02x\\n\"", "\"__RAMPX__ = 0x%02x\\n\"", "\"__RAMPD__ = 0x%02x\\n\"", "\"__CCP__ = 0x%02x\\n\"", "\"__tmp_reg__ = %d\\n\"", "\"__zero_reg__ = %d\\n\""], "File": "avr", "Func": "avr_file_start", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30535, "Length": 180}
{"ground_truth": ["<s>", "void", "avr_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: cost = %d.  */\\n\"", ",", "set_src_cost", "(", "SET_SRC", "(", "set", ")", ",", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ",", "INSN", ",", "0", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "}", "if", "(", "avr_log", ".", "insn_addresses", ")", "fprintf", "(", "asm_out_file", ",", "\";; ADDR = %d\\n\"", ",", "(", "int", ")", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Output", "insn", "cost", "for", "next", "insn", "."], "TS_V_token": ["avr", "\"/* DEBUG: cost = %d.  */\\n\"", "\"/* DEBUG: pattern-cost = %d.  */\\n\"", "0", "\";; ADDR = %d\\n\""], "File": "avr", "Func": "avr_final_prescan_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30536, "Length": 115}
{"ground_truth": ["<s>", "static", "rtx", "avr_find_unused_d_reg", "(", "rtx_insn", "*", "insn", ",", "rtx", "exclude", ")", "{", "bool", "isr_p", "=", "(", "avr_interrupt_function_p", "(", "current_function_decl", ")", "||", "avr_signal_function_p", "(", "current_function_decl", ")", ")", ";", "for", "(", "int", "regno", "=", "16", ";", "regno", "<", "32", ";", "regno", "++", ")", "{", "rtx", "reg", "=", "all_regs_rtx", "[", "regno", "]", ";", "if", "(", "(", "exclude", "&&", "reg_overlap_mentioned_p", "(", "exclude", ",", "reg", ")", ")", "||", "fixed_regs", "[", "regno", "]", ")", "{", "continue", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", "||", "(", "!", "isr_p", "&&", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", ")", "{", "return", "reg", ";", "}", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "reg_unused_after", "(", "insn", ",", "reg", ")", ")", "{", "return", "reg", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Fixme", ":", "This", "is", "a", "hack", "because", "secondary", "reloads", "do", "n't", "works", "as", "expected", ".", "Find", "an", "unused", "d-register", "to", "be", "used", "as", "scratch", "in", "INSN", ".", "EXCLUDE", "is", "either", "NULL_RTX", "or", "some", "register", ".", "In", "the", "case", "where", "EXCLUDE", "is", "a", "register", ",", "skip", "all", "possible", "return", "values", "that", "overlap", "EXCLUDE", ".", "The", "policy", "for", "the", "returned", "register", "is", "similar", "to", "that", "of", "`", "reg_unused_after", "'", ",", "i.e", ".", "the", "returned", "register", "may", "overlap", "the", "SET_DEST", "of", "INSN", ".", "Return", "a", "QImode", "d-register", "or", "NULL_RTX", "if", "nothing", "found", "."], "TS_V_token": ["avr", "16", "32"], "File": "avr", "Func": "avr_find_unused_d_reg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30537, "Length": 138}
{"ground_truth": ["<s>", "static", "void", "avr_fix_operands", "(", "rtx", "*", "op", ",", "rtx", "*", "hreg", ",", "unsigned", "opmask", ",", "unsigned", "rmask", ")", "{", "for", "(", ";", "opmask", ";", "opmask", ">>=", "1", ",", "op", "++", ")", "{", "rtx", "reg", "=", "*", "op", ";", "if", "(", "hreg", ")", "*", "hreg", "=", "NULL_RTX", ";", "if", "(", "(", "opmask", "&", "1", ")", "&&", "REG_P", "(", "reg", ")", "&&", "REGNO", "(", "reg", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "(", "rmask", "&", "regmask", "(", "GET_MODE", "(", "reg", ")", ",", "REGNO", "(", "reg", ")", ")", ")", ")", "{", "*", "op", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "reg", ")", ")", ";", "if", "(", "hreg", "==", "NULL", ")", "emit_move_insn", "(", "*", "op", ",", "reg", ")", ";", "else", "*", "hreg", "=", "reg", ";", "}", "if", "(", "hreg", ")", "hreg", "++", ";", "}", "}", "</s>"], "natrual_language": ["PR63633", ":", "The", "middle-end", "might", "come", "up", "with", "hard", "regs", "as", "input", "operands", ".", "RMASK", "is", "a", "bit", "mask", "representing", "a", "subset", "of", "hard", "registers", "R0", "...", "R31", ":", "Rn", "is", "an", "element", "of", "that", "set", "iff", "bit", "n", "of", "RMASK", "is", "set", ".", "OPMASK", "describes", "a", "subset", "of", "OP", "[", "]", ":", "If", "bit", "n", "of", "OPMASK", "is", "1", "then", "OP", "[", "n", "]", "has", "to", "be", "fixed", ";", "otherwise", "OP", "[", "n", "]", "is", "left", "alone", ".", "For", "each", "element", "of", "OPMASK", "which", "is", "a", "hard", "register", "overlapping", "RMASK", ",", "replace", "OP", "[", "n", "]", "with", "a", "newly", "created", "pseudo", "register", "HREG", "==", "0", ":", "Also", "emit", "a", "move", "insn", "that", "copies", "the", "contents", "of", "that", "hard", "register", "into", "the", "new", "pseudo", ".", "HREG", "!", "=", "0", ":", "Also", "set", "HREG", "[", "n", "]", "to", "the", "hard", "register", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr", "Func": "avr_fix_operands", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30538, "Length": 126}
{"ground_truth": ["<s>", "bool", "avr_float_lib_compare_returns_bool", "(", "machine_mode", "mode", ",", "enum", "rtx_code", ")", "{", "if", "(", "mode", "==", "DFmode", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "`", "FLOAT_LIB_COMPARE_RETURNS_BOOL", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_float_lib_compare_returns_bool", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30539, "Length": 25}
{"ground_truth": ["<s>", "static", "tree", "avr_fold_absfx", "(", "tree", "tval", ")", "{", "if", "(", "FIXED_CST", "!=", "TREE_CODE", "(", "tval", ")", ")", "return", "NULL_TREE", ";", "FIXED_VALUE_TYPE", "fval", "=", "TREE_FIXED_CST", "(", "tval", ")", ";", "unsigned", "int", "bits", "=", "GET_MODE_BITSIZE", "(", "fval", ".", "mode", ")", ";", "double_int", "ival", "=", "fval", ".", "data", ".", "sext", "(", "bits", ")", ";", "if", "(", "!", "ival", ".", "is_negative", "(", ")", ")", "return", "tval", ";", "fval", ".", "data", "=", "(", "ival", "==", "double_int", "::", "min_value", "(", "bits", ",", "false", ")", ".", "sext", "(", "bits", ")", ")", "?", "double_int", "::", "max_value", "(", "bits", ",", "false", ")", ":", "-", "ival", ";", "return", "build_fixed", "(", "TREE_TYPE", "(", "tval", ")", ",", "fval", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "`", "avr_fold_builtin", "'", "that", "folds", "absfx", "(", "FIXED_CST", ")", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_fold_absfx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30540, "Length": 109}
{"ground_truth": ["<s>", "static", "bool", "avr_frame_pointer_required_p", "(", "void", ")", "{", "return", "(", "cfun", "->", "calls_alloca", "||", "cfun", "->", "calls_setjmp", "||", "cfun", "->", "has_nonlocal_label", "||", "crtl", "->", "args", ".", "info", ".", "nregs", "==", "0", "||", "get_frame_size", "(", ")", ">", "0", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "frame", "pointer", "for", "current", "function", "required", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr", "Func": "avr_frame_pointer_required_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30541, "Length": 39}
{"ground_truth": ["<s>", "static", "rtx", "avr_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["Controls", "whether", "a", "function", "argument", "is", "passed", "in", "a", "register", ",", "and", "which", "register", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_function_arg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30542, "Length": 66}
{"ground_truth": ["<s>", "static", "void", "avr_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", "&&", "!", "call_used_or_fixed_reg_p", "(", "cum", "->", "regno", ")", ")", "{", "cfun", "->", "machine", "->", "sibcall_fails", "=", "1", ";", "}", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", ")", "{", "for", "(", "int", "regno", "=", "cum", "->", "regno", ";", "regno", "<", "cum", "->", "regno", "+", "bytes", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "warning", "(", "0", ",", "\"fixed register %s used to pass parameter to function\"", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>"], "natrual_language": ["Update", "the", "summarizer", "variable", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", "."], "TS_V_token": ["avr", "8", "0", "1", "8", "0", "0", "\"fixed register %s used to pass parameter to function\"", "0", "0"], "File": "avr", "Func": "avr_function_arg_advance", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30543, "Length": 158}
{"ground_truth": ["<s>", "int", "avr_function_arg_regno_p", "(", "int", "r", ")", "{", "return", "AVR_TINY", "?", "IN_RANGE", "(", "r", ",", "20", ",", "25", ")", ":", "IN_RANGE", "(", "r", ",", "8", ",", "25", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "REGNO", "is", "the", "number", "of", "a", "hard", "register", "in", "which", "function", "arguments", "are", "sometimes", "passed", "."], "TS_V_token": ["avr", "20", "25", "8", "25"], "File": "avr", "Func": "avr_function_arg_regno_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30544, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "avr_function_ok_for_sibcall", "(", "tree", "decl_callee", ",", "tree", "exp_callee", ")", "{", "tree", "fntype_callee", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_fails", "||", "TARGET_CALL_PROLOGUES", ")", "{", "return", "false", ";", "}", "fntype_callee", "=", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp_callee", ")", ")", ";", "if", "(", "decl_callee", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "else", "{", "decl_callee", "=", "fntype_callee", ";", "while", "(", "FUNCTION_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", "&&", "METHOD_TYPE", "!=", "TREE_CODE", "(", "decl_callee", ")", ")", "{", "decl_callee", "=", "TREE_TYPE", "(", "decl_callee", ")", ";", "}", "}", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_naked", "||", "avr_naked_function_p", "(", "decl_callee", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_function_ok_for_sibcall", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30545, "Length": 118}
{"ground_truth": ["<s>", "static", "rtx", "avr_function_value", "(", "const_tree", "type", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "offs", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "!=", "BLKmode", ")", "return", "avr_libcall_value", "(", "TYPE_MODE", "(", "type", ")", ",", "NULL_RTX", ")", ";", "offs", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "if", "(", "offs", ">", "2", "&&", "offs", "<", "GET_MODE_SIZE", "(", "SImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "else", "if", "(", "offs", ">", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offs", "<", "GET_MODE_SIZE", "(", "DImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "return", "gen_rtx_REG", "(", "BLKmode", ",", "avr_ret_register", "(", ")", "+", "2", "-", "offs", ")", ";", "}", "</s>"], "natrual_language": ["Create", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "a", "value", "of", "data", "type", "VALTYPE", "."], "TS_V_token": ["avr", "2", "2", "2", "2"], "File": "avr", "Func": "avr_function_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30546, "Length": 116}
{"ground_truth": ["<s>", "static", "bool", "avr_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "avr_ret_register", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_FUNCTION_VALUE_REGNO_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_function_value_regno_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30547, "Length": 20}
{"ground_truth": ["<s>", "static", "tree", "avr_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["avr", "\"%qE attribute only applies to functions\""], "File": "avr", "Func": "avr_handle_fndecl_attribute", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30548, "Length": 54}
{"ground_truth": ["<s>", "static", "tree", "avr_handle_progmem_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "TYPE_DECL", ")", "{", "tree", "type", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "tree", "attr", "=", "tree_cons", "(", "name", ",", "args", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "tree", "newtype", "=", "build_type_attribute_variant", "(", "type", ",", "attr", ")", ";", "TYPE_MAIN_VARIANT", "(", "newtype", ")", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "TREE_TYPE", "(", "*", "node", ")", "=", "newtype", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_STATIC", "(", "*", "node", ")", "||", "DECL_EXTERNAL", "(", "*", "node", ")", ")", "{", "*", "no_add_attrs", "=", "false", ";", "}", "else", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>"], "natrual_language": ["Handle", "a", "``", "progmem", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "."], "TS_V_token": ["avr", "\"%qE attribute ignored\""], "File": "avr", "Func": "avr_handle_progmem_attribute", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30549, "Length": 146}
{"ground_truth": ["<s>", "static", "bool", "avr_hard_regno_call_part_clobbered", "(", "unsigned", ",", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<=", "LAST_CALLEE_SAVED_REG", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "1", "+", "LAST_CALLEE_SAVED_REG", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "."], "TS_V_token": ["avr", "0", "1"], "File": "avr", "Func": "avr_hard_regno_call_part_clobbered", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30550, "Length": 77}
{"ground_truth": ["<s>", "static", "bool", "avr_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_CC", ")", "return", "mode", "==", "CCmode", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "1", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "&&", "regno", ">=", "REG_X", ")", "return", "false", ";", "return", "!", "(", "regno", "&", "1", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "1", "if", "a", "value", "of", "mode", "MODE", "can", "be", "stored", "starting", "with", "hard", "register", "number", "REGNO", ".", "On", "the", "enhanced", "core", ",", "anything", "larger", "than", "1", "byte", "must", "start", "in", "even", "numbered", "register", "for", "``", "movw", "''", "to", "work", "(", "this", "way", "we", "do", "n't", "have", "to", "check", "for", "odd", "registers", "everywhere", ")", "."], "TS_V_token": ["avr", "1", "4", "1"], "File": "avr", "Func": "avr_hard_regno_mode_ok", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30551, "Length": 60}
{"ground_truth": ["<s>", "static", "unsigned", "int", "avr_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "REG_CC", "&&", "mode", "==", "CCmode", ")", "return", "1", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "TARGET_HARD_REGNO_NREGS", ".", "CCmode", "is", "four", "units", "for", "historical", "reasons", ".", "If", "this", "hook", "is", "not", "defined", ",", "TARGET_HARD_REGNO_NREGS", "reports", "that", "CCmode", "requires", "four", "registers", ".", "Define", "this", "hook", "to", "allow", "CCmode", "to", "fit", "in", "a", "single", "REG_CC", ".", "For", "other", "modes", "and", "regs", ",", "return", "the", "number", "of", "words", "in", "mode", "(", "i.e", "whatever", "the", "default", "implementation", "of", "the", "hook", "returned", ")", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_hard_regno_nregs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30552, "Length": 38}
{"ground_truth": ["<s>", "int", "avr_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "if", "(", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "&&", "(", "old_reg", "==", "REG_Y", "||", "old_reg", "==", "REG_Y", "+", "1", "||", "new_reg", "==", "REG_Y", "||", "new_reg", "==", "REG_Y", "+", "1", ")", ")", "{", "return", "0", ";", "}", "return", "1", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "."], "TS_V_token": ["avr", "0", "1", "1", "0", "1"], "File": "avr", "Func": "avr_hard_regno_rename_ok", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30553, "Length": 77}
{"ground_truth": ["<s>", "static", "bool", "avr_hard_regno_scratch_ok", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "&&", "!", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "false", ";", "if", "(", "(", "!", "reload_completed", "||", "frame_pointer_needed", ")", "&&", "(", "regno", "==", "REG_Y", "||", "regno", "==", "REG_Y", "+", "1", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Returns", "true", "if", "SCRATCH", "are", "safe", "to", "be", "allocated", "as", "a", "scratch", "registers", "(", "for", "a", "define_peephole2", ")", "in", "the", "current", "function", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_hard_regno_scratch_ok", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30554, "Length": 64}
{"ground_truth": ["<s>", "bool", "avr_has_nibble_0xf", "(", "rtx", "ival", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "ival", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "return", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", "!=", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "IVAL", "has", "a", "0xf", "in", "its", "hexadecimal", "representation", "and", "false", ",", "otherwise", ".", "Only", "nibbles", "0", "..", "7", "are", "taken", "into", "account", ".", "Used", "as", "constraint", "helper", "for", "C0f", "and", "Cxf", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "avr_has_nibble_0xf", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30555, "Length": 32}
{"ground_truth": ["<s>", "static", "int", "avr_hregs_split_reg", "(", "HARD_REG_SET", "*", "set", ")", "{", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "regno", ")", ")", "{", "if", "(", "AVR_HAVE_RAMPX", "&&", "(", "REG_X", "==", "regno", "||", "REG_X", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_X", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_X", "+", "1", ")", ")", "continue", ";", "if", "(", "AVR_HAVE_RAMPY", "&&", "!", "frame_pointer_needed", "&&", "(", "REG_Y", "==", "regno", "||", "REG_Y", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Y", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Y", "+", "1", ")", ")", "continue", ";", "if", "(", "AVR_HAVE_RAMPZ", "&&", "(", "REG_Z", "==", "regno", "||", "REG_Z", "+", "1", "==", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Z", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "set", ",", "REG_Z", "+", "1", ")", ")", "continue", ";", "CLEAR_HARD_REG_BIT", "(", "*", "set", ",", "regno", ")", ";", "return", "regno", ";", "}", "return", "-", "1", ";", "}", "</s>"], "natrual_language": ["Unset", "a", "bit", "in", "*", "SET", ".", "If", "successful", ",", "return", "the", "respective", "bit", "number", ".", "Otherwise", ",", "return", "-1", "and", "*", "SET", "is", "unaltered", "."], "TS_V_token": ["avr", "0", "32", "1", "1", "1", "1", "1", "1", "1"], "File": "avr", "Func": "avr_hregs_split_reg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30556, "Length": 162}
{"ground_truth": ["<s>", "rtx", "avr_incoming_return_addr_rtx", "(", "void", ")", "{", "return", "gen_frame_mem", "(", "HImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "1", ")", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "INCOMING_RETURN_ADDR_RTX", "'", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_incoming_return_addr_rtx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30557, "Length": 22}
{"ground_truth": ["<s>", "int", "avr_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "0", ";", "else", "{", "int", "offset", "=", "frame_pointer_needed", "?", "2", ":", "0", ";", "int", "avr_pc_size", "=", "AVR_HAVE_EIJMP_EICALL", "?", "3", ":", "2", ";", "offset", "+=", "avr_regs_to_save", "(", "NULL", ")", ";", "return", "(", "get_frame_size", "(", ")", "+", "avr_outgoing_args_size", "(", ")", "+", "avr_pc_size", "+", "1", "+", "offset", ")", ";", "}", "}", "</s>"], "natrual_language": ["Compute", "offset", "between", "arg_pointer", "and", "frame_pointer", "."], "TS_V_token": ["avr", "0", "2", "0", "3", "2", "1"], "File": "avr", "Func": "avr_initial_elimination_offset", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30558, "Length": 69}
{"ground_truth": ["<s>", "void", "avr_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "nregs", "=", "AVR_TINY", "?", "6", ":", "18", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "if", "(", "!", "libname", "&&", "stdarg_p", "(", "fntype", ")", ")", "cum", "->", "nregs", "=", "0", ";", "cfun", "->", "machine", "->", "sibcall_fails", "=", "0", ";", "}", "</s>"], "natrual_language": ["Initializing", "the", "variable", "cum", "for", "the", "state", "at", "the", "beginning", "of", "the", "argument", "list", "."], "TS_V_token": ["avr", "6", "18", "0", "0"], "File": "avr", "Func": "avr_init_cumulative_args", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30559, "Length": 59}
{"ground_truth": ["<s>", "void", "avr_init_expanders", "(", "void", ")", "{", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "32", ";", "regno", "++", ")", "all_regs_rtx", "[", "regno", "]", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "lpm_reg_rtx", "=", "all_regs_rtx", "[", "LPM_REGNO", "]", ";", "tmp_reg_rtx", "=", "all_regs_rtx", "[", "AVR_TMP_REGNO", "]", ";", "zero_reg_rtx", "=", "all_regs_rtx", "[", "AVR_ZERO_REGNO", "]", ";", "cc_reg_rtx", "=", "gen_rtx_REG", "(", "CCmode", ",", "REG_CC", ")", ";", "lpm_addr_reg_rtx", "=", "gen_rtx_REG", "(", "HImode", ",", "REG_Z", ")", ";", "sreg_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "sreg", ")", ")", ";", "rampd_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampd", ")", ")", ";", "rampx_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampx", ")", ")", ";", "rampy_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampy", ")", ")", ";", "rampz_rtx", "=", "gen_rtx_MEM", "(", "QImode", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "xstring_empty", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"\"", ")", ";", "xstring_e", "=", "gen_rtx_CONST_STRING", "(", "VOIDmode", ",", "\"e\"", ")", ";", "if", "(", "AVR_TINY", ")", "avr_have_dimode", "=", "false", ";", "}", "</s>"], "natrual_language": ["The", "function", "works", "like", "a", "singleton", "."], "TS_V_token": ["avr", "0", "32", "\"\"", "\"e\""], "File": "avr", "Func": "avr_init_expanders", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30560, "Length": 168}
{"ground_truth": ["<s>", "static", "struct", "machine_function", "*", "avr_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>"], "natrual_language": ["Function", "to", "set", "up", "the", "backend", "function", "structure", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_init_machine_status", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30561, "Length": 18}
{"ground_truth": ["<s>", "static", "void", "avr_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "avr_pgm_check_var_decl", "(", "node", ")", ";", "if", "(", "TARGET_MAIN_IS_OS_TASK", "&&", "TREE_CODE", "(", "node", ")", "==", "FUNCTION_DECL", "&&", "MAIN_NAME_P", "(", "DECL_NAME", "(", "node", ")", ")", "&&", "INTEGRAL_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", ")", ")", ")", "&&", "NULL", "==", "lookup_attribute", "(", "\"OS_task\"", ",", "*", "attributes", ")", ")", "{", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"OS_task\"", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "}", "if", "(", "TREE_CODE", "(", "node", ")", "==", "VAR_DECL", "&&", "(", "TREE_STATIC", "(", "node", ")", "||", "DECL_EXTERNAL", "(", "node", ")", ")", "&&", "avr_progmem_p", "(", "node", ",", "*", "attributes", ")", ")", "{", "addr_space_t", "as", ";", "tree", "node0", "=", "node", ";", "do", "node0", "=", "TREE_TYPE", "(", "node0", ")", ";", "while", "(", "TREE_CODE", "(", "node0", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "error_mark_node", "==", "node0", ")", "return", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "node", ")", ")", ";", "if", "(", "!", "TYPE_READONLY", "(", "node0", ")", "&&", "!", "TREE_READONLY", "(", "node", ")", ")", "{", "const", "char", "*", "reason", "=", "\"__attribute__((progmem))\"", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "reason", "=", "avr_addrspace", "[", "as", "]", ".", "name", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"\\n%?: %t\\n%t\\n\"", ",", "node", ",", "node0", ")", ";", "error", "(", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\"", ",", "node", ",", "reason", ")", ";", "}", "}", "}", "</s>"], "natrual_language": ["Add", "the", "section", "attribute", "if", "the", "variable", "is", "in", "progmem", "."], "TS_V_token": ["avr", "\"OS_task\"", "\"OS_task\"", "\"__attribute__((progmem))\"", "\"\\n%?: %t\\n%t\\n\"", "\"variable %q+D must be const in order to be put into\"", "\" read-only section by means of %qs\""], "File": "avr", "Func": "avr_insert_attributes", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30562, "Length": 216}
{"ground_truth": ["<s>", "static", "int", "avr_interrupt_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"interrupt\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt", "''", "attribute", "."], "TS_V_token": ["avr", "\"interrupt\""], "File": "avr", "Func": "avr_interrupt_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30563, "Length": 17}
{"ground_truth": ["<s>", "static", "bool", "avr_is_casesi_sequence", "(", "basic_block", "bb", ",", "rtx_insn", "*", "insn", ",", "rtx_insn", "*", "insns", "[", "5", "]", ")", "{", "rtx", "set_4", ",", "set_0", ";", "if", "(", "!", "(", "JUMP_P", "(", "insns", "[", "4", "]", "=", "insn", ")", "&&", "(", "set_4", "=", "single_set", "(", "insns", "[", "4", "]", ")", ")", "&&", "UNSPEC", "==", "GET_CODE", "(", "SET_SRC", "(", "set_4", ")", ")", "&&", "UNSPEC_INDEX_JMP", "==", "XINT", "(", "SET_SRC", "(", "set_4", ")", ",", "1", ")", "&&", "(", "insns", "[", "3", "]", "=", "prev_real_insn", "(", "insns", "[", "4", "]", ")", ")", "&&", "(", "insns", "[", "2", "]", "=", "prev_real_insn", "(", "insns", "[", "3", "]", ")", ")", "&&", "(", "insns", "[", "1", "]", "=", "prev_real_insn", "(", "insns", "[", "2", "]", ")", ")", "&&", "(", "insns", "[", "0", "]", "=", "prev_real_insn", "(", "insns", "[", "1", "]", ")", ")", "&&", "(", "set_0", "=", "single_set", "(", "insns", "[", "0", "]", ")", ")", "&&", "extend_operator", "(", "SET_SRC", "(", "set_0", ")", ",", "SImode", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", ",", "bb", "->", "index", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "print_rtl_single", "(", "dump_file", ",", "insns", "[", "i", "]", ")", ";", "}", "rtx_insn", "*", "xinsn", "=", "avr_parallel_insn_from_insns", "(", "insns", ")", ";", "INSN_CODE", "(", "xinsn", ")", "=", "recog", "(", "PATTERN", "(", "xinsn", ")", ",", "xinsn", ",", "NULL", ")", ";", "if", "(", "INSN_CODE", "(", "xinsn", ")", "<", "0", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; Sequence not recognized, giving up.\\n\\n\"", ")", ";", "return", "false", ";", "}", "gcc_assert", "(", "CODE_FOR_casesi_qi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", "||", "CODE_FOR_casesi_hi_sequence", "==", "INSN_CODE", "(", "xinsn", ")", ")", ";", "extract_insn", "(", "xinsn", ")", ";", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "11", ")", ";", "gcc_assert", "(", "recog_data", ".", "n_dups", "==", "4", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; Operands extracted:\\n\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "avr_fdump", "(", "dump_file", ",", "\";; $%d = %r\\n\"", ",", "i", ",", "recog_data", ".", "operand", "[", "i", "]", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "we", "see", "an", "insn", "stream", "generated", "by", "casesi", "expander", "together", "with", "an", "extension", "to", "SImode", "of", "the", "switch", "value", ".", "If", "this", "is", "the", "case", ",", "fill", "in", "the", "insns", "from", "casesi", "to", "INSNS", "[", "1", "..", "5", "]", "and", "the", "SImode", "extension", "to", "INSNS", "[", "0", "]", ".", "Moreover", ",", "extract", "the", "operands", "of", "pattern", "casesi_", "<", "mode", ">", "_sequence", "forged", "from", "the", "sequence", "to", "recog_data", "."], "TS_V_token": ["avr", "5", "4", "4", "1", "3", "4", "2", "3", "1", "2", "0", "1", "0", "\";; Sequence from casesi in \"", "\"[bb %d]:\\n\\n\"", "0", "5", "0", "\";; Sequence not recognized, giving up.\\n\\n\"", "11", "4", "\";; Operands extracted:\\n\"", "0", "\";; $%d = %r\\n\"", "\"\\n\""], "File": "avr", "Func": "avr_is_casesi_sequence", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30564, "Length": 349}
{"ground_truth": ["<s>", "int", "avr_jump_mode", "(", "rtx", "x", ",", "rtx_insn", "*", "insn", ")", "{", "int", "dest_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "?", "XEXP", "(", "x", ",", "0", ")", ":", "x", ")", ")", ";", "int", "cur_addr", "=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "jump_distance", "=", "cur_addr", "-", "dest_addr", ";", "if", "(", "IN_RANGE", "(", "jump_distance", ",", "-", "63", ",", "62", ")", ")", "return", "1", ";", "else", "if", "(", "IN_RANGE", "(", "jump_distance", ",", "-", "2046", ",", "2045", ")", ")", "return", "2", ";", "else", "if", "(", "AVR_HAVE_JMP_CALL", ")", "return", "3", ";", "return", "2", ";", "}", "</s>"], "natrual_language": ["Choose", "mode", "for", "jump", "insn", ":", "1", "-", "relative", "jump", "in", "range", "-63", "<", "=", "x", "<", "=", "62", ";", "2", "-", "relative", "jump", "in", "range", "-2046", "<", "=", "x", "<", "=", "2045", ";", "3", "-", "absolute", "jump", "(", "only", "for", "ATmega", "[", "16", "]", "03", ")", "."], "TS_V_token": ["avr", "0", "63", "62", "1", "2046", "2045", "2", "3", "2"], "File": "avr", "Func": "avr_jump_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30565, "Length": 97}
{"ground_truth": ["<s>", "static", "bool", "avr_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "bool", "ok", "=", "CONSTANT_ADDRESS_P", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "x", ",", "ADDR_SPACE_GENERIC", ",", "MEM", ",", "strict", ")", ";", "if", "(", "strict", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", "&&", "REG_X", "==", "REGNO", "(", "x", ")", ")", "{", "ok", "=", "false", ";", "}", "break", ";", "case", "POST_INC", ":", "case", "PRE_DEC", ":", "ok", "=", "avr_reg_ok_for_addr_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "ADDR_SPACE_GENERIC", ",", "GET_CODE", "(", "x", ")", ",", "strict", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "REG_P", "(", "reg", ")", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "INTVAL", "(", "op1", ")", ">=", "0", ")", "{", "bool", "fit", "=", "IN_RANGE", "(", "INTVAL", "(", "op1", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", ";", "if", "(", "fit", ")", "{", "ok", "=", "(", "!", "strict", "||", "avr_reg_ok_for_addr_p", "(", "reg", ",", "ADDR_SPACE_GENERIC", ",", "PLUS", ",", "strict", ")", ")", ";", "if", "(", "reg", "==", "frame_pointer_rtx", "||", "reg", "==", "arg_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "else", "if", "(", "frame_pointer_needed", "&&", "reg", "==", "frame_pointer_rtx", ")", "{", "ok", "=", "true", ";", "}", "}", "}", "break", ";", "default", ":", "break", ";", "}", "if", "(", "AVR_TINY", "&&", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "{", "ok", "=", "avr_address_tiny_absdata_p", "(", "x", ",", "mode", ")", ";", "}", "if", "(", "avr_log", ".", "legitimate_address_p", ")", "{", "avr_edump", "(", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", ",", "ok", ",", "mode", ",", "strict", ",", "reload_completed", ",", "reload_in_progress", ",", "reg_renumber", "?", "\"(reg_renumber)\"", ":", "\"\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "0", ",", "MAX_LD_OFFSET", "(", "mode", ")", ")", "&&", "reg_renumber", ")", "{", "avr_edump", "(", "\"(r%d ---> r%d)\"", ",", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ",", "true_regnum", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "}", "avr_edump", "(", "\"\\n%r\\n\"", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "X", "(", "an", "RTX", ")", "is", "a", "legitimate", "memory", "address", "on", "the", "target", "machine", "for", "a", "memory", "operand", "of", "mode", "MODE", "."], "TS_V_token": ["avr", "4", "0", "0", "1", "0", "0", "\"\\n%?: ret=%d, mode=%m strict=%d \"", "\"reload_completed=%d reload_in_progress=%d %s:\"", "\"(reg_renumber)\"", "\"\"", "0", "1", "1", "0", "\"(r%d ---> r%d)\"", "0", "0", "\"\\n%r\\n\""], "File": "avr", "Func": "avr_legitimate_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30566, "Length": 366}
{"ground_truth": ["<s>", "static", "bool", "avr_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "{", "const_rtx", "op", "=", "*", "iter", ";", "if", "(", "SUBREG_P", "(", "op", ")", "&&", "MEM_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "op", ")", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", ")", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["PR78883", ":", "Filter", "out", "paradoxical", "SUBREGs", "of", "MEM", "which", "are", "not", "handled", "properly", "by", "following", "passes", ".", "As", "INSN_SCHEDULING", "is", "off", "and", "hence", "general_operand", "accepts", "such", "expressions", ",", "ditch", "them", "now", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_legitimate_combined_insn", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30567, "Length": 80}
{"ground_truth": ["<s>", "static", "rtx", "avr_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", ",", "machine_mode", "mode", ")", "{", "bool", "big_offset_p", "=", "false", ";", "x", "=", "oldx", ";", "if", "(", "AVR_TINY", ")", "{", "if", "(", "CONSTANT_ADDRESS_P", "(", "x", ")", "&&", "!", "avr_address_tiny_absdata_p", "(", "x", ",", "mode", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "oldx", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "oldx", ",", "0", ")", ")", ")", "{", "if", "(", "REG_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ")", "{", "int", "offs", "=", "INTVAL", "(", "XEXP", "(", "oldx", ",", "1", ")", ")", ";", "if", "(", "frame_pointer_rtx", "!=", "XEXP", "(", "oldx", ",", "0", ")", "&&", "offs", ">", "MAX_LD_OFFSET", "(", "mode", ")", ")", "{", "big_offset_p", "=", "true", ";", "x", "=", "force_reg", "(", "GET_MODE", "(", "oldx", ")", ",", "oldx", ")", ";", "}", "}", "}", "if", "(", "avr_log", ".", "legitimize_address", ")", "{", "avr_edump", "(", "\"\\n%?: mode=%m\\n %r\\n\"", ",", "mode", ",", "oldx", ")", ";", "if", "(", "x", "!=", "oldx", ")", "avr_edump", "(", "\" %s --> %r\\n\"", ",", "big_offset_p", "?", "\"(big offset)\"", ":", "\"\"", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>"], "natrual_language": ["Attempts", "to", "replace", "X", "with", "a", "valid", "memory", "address", "for", "an", "operand", "of", "mode", "MODE"], "TS_V_token": ["avr", "0", "1", "1", "1", "0", "\"\\n%?: mode=%m\\n %r\\n\"", "\" %s --> %r\\n\"", "\"(big offset)\"", "\"\""], "File": "avr", "Func": "avr_legitimize_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30568, "Length": 204}
{"ground_truth": ["<s>", "rtx", "avr_legitimize_reload_address", "(", "rtx", "*", "px", ",", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "addr_type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ",", "rtx", "(", "*", "mk_memloc", ")", "(", "rtx", ",", "int", ")", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\"\\n%?:%m %r\\n\"", ",", "mode", ",", "x", ")", ";", "if", "(", "1", "&&", "(", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ",", "0", ",", "0", ",", "opnum", ",", "RELOAD_OTHER", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "reg_equiv_constant", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "==", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "1", ")", "{", "bool", "fit", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "mode", ")", ";", "if", "(", "fit", ")", "{", "if", "(", "reg_equiv_address", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "!=", "0", ")", "{", "int", "regno", "=", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "rtx", "mem", "=", "mk_memloc", "(", "x", ",", "regno", ")", ";", "push_reload", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL", ",", "POINTER_REGS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "1", ",", "(", "enum", "reload_type", ")", "addr_type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "XEXP", "(", "mem", ",", "0", ")", ",", "NULL_RTX", ")", ";", "push_reload", "(", "mem", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "BASE_POINTER_REGS", ",", "mem", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "else", "if", "(", "!", "(", "frame_pointer_needed", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "frame_pointer_rtx", ")", ")", "{", "push_reload", "(", "x", ",", "NULL_RTX", ",", "px", ",", "NULL", ",", "POINTER_REGS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "if", "(", "avr_log", ".", "legitimize_reload_address", ")", "avr_edump", "(", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\"", ",", "POINTER_REGS", ",", "x", ",", "NULL_RTX", ")", ";", "return", "x", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>"], "natrual_language": ["This", "will", "allow", "register", "R26/27", "to", "be", "used", "where", "it", "is", "no", "worse", "than", "normal", "base", "pointers", "R28/29", "or", "R30/31", ".", "For", "example", ",", "if", "base", "offset", "is", "greater", "than", "63", "bytes", "or", "for", "R++", "or", "--", "R", "addressing", "."], "TS_V_token": ["avr", "\"\\n%?:%m %r\\n\"", "1", "0", "0", "0", "0", "0", "0", "\" RCLASS.1 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "0", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "0", "\" RCLASS.2 = %R\\n IN = %r\\n OUT = %r\\n\"", "0", "0", "0", "\" RCLASS.3 = %R\\n IN = %r\\n OUT = %r\\n\""], "File": "avr", "Func": "avr_legitimize_reload_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30569, "Length": 480}
{"ground_truth": ["<s>", "static", "rtx", "avr_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "func", "ATTRIBUTE_UNUSED", ")", "{", "int", "offs", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offs", "<=", "4", ")", "offs", "=", "(", "offs", "+", "1", ")", "&", "~", "1", ";", "return", "gen_rtx_REG", "(", "mode", ",", "avr_ret_register", "(", ")", "+", "2", "-", "offs", ")", ";", "}", "</s>"], "natrual_language": ["Ceate", "an", "RTX", "representing", "the", "place", "where", "a", "library", "function", "returns", "a", "value", "of", "mode", "MODE", "."], "TS_V_token": ["avr", "4", "1", "1", "2"], "File": "avr", "Func": "avr_libcall_value", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30570, "Length": 52}
{"ground_truth": ["<s>", "bool", "avr_load_libgcc_p", "(", "rtx", "op", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "int", "n_bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "n_bytes", ">", "2", "&&", "!", "AVR_HAVE_LPMX", "&&", "avr_mem_flash_p", "(", "op", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "value", "of", "mode", "MODE", "is", "read", "from", "flash", "by", "__load_", "*", "function", "from", "libgcc", "."], "TS_V_token": ["avr", "2"], "File": "avr", "Func": "avr_load_libgcc_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30571, "Length": 39}
{"ground_truth": ["<s>", "static", "inline", "int", "avr_lookup_function_attribute1", "(", "const_tree", "func", ",", "const", "char", "*", "name", ")", "{", "if", "(", "FUNCTION_DECL", "==", "TREE_CODE", "(", "func", ")", ")", "{", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "name", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ")", "{", "return", "true", ";", "}", "func", "=", "TREE_TYPE", "(", "func", ")", ";", "}", "gcc_assert", "(", "TREE_CODE", "(", "func", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "func", ")", "==", "METHOD_TYPE", ")", ";", "return", "NULL_TREE", "!=", "lookup_attribute", "(", "name", ",", "TYPE_ATTRIBUTES", "(", "func", ")", ")", ";", "}", "</s>"], "natrual_language": ["A", "helper", "for", "the", "subsequent", "function", "attribute", "used", "to", "dig", "for", "attribute", "'name", "'", "in", "a", "FUNCTION_DECL", "or", "FUNCTION_TYPE"], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_lookup_function_attribute1", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30572, "Length": 82}
{"ground_truth": ["<s>", "static", "int", "avr_map", "(", "unsigned", "int", "f", ",", "int", "x", ")", "{", "return", "x", "<", "8", "?", "(", "f", ">>", "(", "4", "*", "x", ")", ")", "&", "0xf", ":", "0", ";", "}", "</s>"], "natrual_language": ["Compute", "the", "image", "of", "x", "under", "f", ",", "i.e", ".", "perform", "x", "--", ">", "f", "(", "x", ")"], "TS_V_token": ["avr", "8", "4", "0xf", "0"], "File": "avr", "Func": "avr_map", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30573, "Length": 32}
{"ground_truth": ["<s>", "static", "avr_map_op_t", "avr_map_decompose", "(", "unsigned", "int", "f", ",", "const", "avr_map_op_t", "*", "g", ",", "bool", "val_const_p", ")", "{", "bool", "val_used_p", "=", "avr_map_metric", "(", "f", ",", "MAP_MASK_PREIMAGE_F", ")", "!=", "0", ";", "avr_map_op_t", "f_ginv", "=", "*", "g", ";", "unsigned", "int", "ginv", "=", "g", "->", "ginv", ";", "f_ginv", ".", "cost", "=", "-", "1", ";", "for", "(", "int", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "x", "=", "avr_map", "(", "f", ",", "i", ")", ";", "if", "(", "x", "<=", "7", ")", "{", "x", "=", "avr_map", "(", "ginv", ",", "x", ")", ";", "if", "(", "x", ">", "7", ")", "return", "f_ginv", ";", "}", "f_ginv", ".", "map", "=", "(", "f_ginv", ".", "map", "<<", "4", ")", "+", "x", ";", "}", "if", "(", "avr_map_metric", "(", "f_ginv", ".", "map", ",", "MAP_NONFIXED_0_7", ")", "==", "0", ")", "f_ginv", ".", "cost", "=", "2", "+", "(", "val_used_p", "&&", "!", "val_const_p", ")", ";", "else", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "all_regs_rtx", "[", "24", "]", ";", "xop", "[", "1", "]", "=", "gen_int_mode", "(", "f_ginv", ".", "map", ",", "SImode", ")", ";", "xop", "[", "2", "]", "=", "all_regs_rtx", "[", "25", "]", ";", "xop", "[", "3", "]", "=", "val_used_p", "?", "xop", "[", "0", "]", ":", "const0_rtx", ";", "avr_out_insert_bits", "(", "xop", ",", "&", "f_ginv", ".", "cost", ")", ";", "f_ginv", ".", "cost", "+=", "val_const_p", "&&", "val_used_p", "?", "1", ":", "0", ";", "}", "f_ginv", ".", "cost", "+=", "g", "->", "cost", ";", "if", "(", "avr_log", ".", "builtin", ")", "avr_edump", "(", "\" %s%d=%d\"", ",", "g", "->", "str", ",", "g", "->", "arg", ",", "f_ginv", ".", "cost", ")", ";", "return", "f_ginv", ";", "}", "</s>"], "natrual_language": ["Try", "to", "decompose", "F", "as", "F", "=", "(", "F", "o", "G^-1", ")", "o", "G", "as", "described", "above", ".", "The", "result", "is", "a", "struct", "representing", "F", "o", "G^-1", "and", "G.", "If", "result.cost", "<", "0", "then", "such", "a", "decomposition", "does", "not", "exist", "."], "TS_V_token": ["avr", "0", "1", "7", "0", "7", "7", "4", "0", "2", "4", "0", "24", "1", "2", "25", "3", "0", "1", "0", "\" %s%d=%d\""], "File": "avr", "Func": "avr_map_decompose", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30574, "Length": 256}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "avr_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "cc_reg_rtx", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "REG_CC", ")", ";", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Prepend", "to", "CLOBBERS", "hard", "registers", "that", "are", "automatically", "clobbered", "for", "an", "asm", ".", "We", "do", "this", "for", "CC_REGNUM", "to", "maintain", "source", "compatibility", "with", "the", "original", "cc0-based", "compiler", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_md_asm_adjust", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30575, "Length": 63}
{"ground_truth": ["<s>", "static", "int", "avr_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "mode", "==", "QImode", "?", "2", ":", "mode", "==", "HImode", "?", "4", ":", "mode", "==", "SImode", "?", "8", ":", "mode", "==", "SFmode", "?", "8", ":", "16", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_MEMORY_MOVE_COST", "'"], "TS_V_token": ["avr", "2", "4", "8", "8", "16"], "File": "avr", "Func": "avr_memory_move_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30576, "Length": 46}
{"ground_truth": ["<s>", "static", "rtx", "avr_mem_clobber", "(", "void", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "gen_rtx_SCRATCH", "(", "Pmode", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "return", "mem", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "__builtin_avr_delay_cycles"], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_mem_clobber", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30577, "Length": 31}
{"ground_truth": ["<s>", "bool", "avr_mem_flash_p", "(", "rtx", "x", ")", "{", "return", "(", "MEM_P", "(", "x", ")", "&&", "!", "ADDR_SPACE_GENERIC_P", "(", "MEM_ADDR_SPACE", "(", "x", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "X", "is", "a", "MEM", "rtx", "located", "in", "flash", "and", "FALSE", ",", "otherwise", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_mem_flash_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30578, "Length": 25}
{"ground_truth": ["<s>", "bool", "avr_mem_memx_p", "(", "rtx", "x", ")", "{", "return", "(", "MEM_P", "(", "x", ")", "&&", "ADDR_SPACE_MEMX", "==", "MEM_ADDR_SPACE", "(", "x", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "TRUE", "if", "X", "is", "a", "MEM", "rtx", "located", "in", "the", "24-bit", "flash", "address", "space", "and", "FALSE", ",", "otherwise", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_mem_memx_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30579, "Length": 23}
{"ground_truth": ["<s>", "enum", "reg_class", "avr_mode_code_base_reg_class", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", ",", "RTX_CODE", "outer_code", ",", "RTX_CODE", "index_code", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "return", "POINTER_Z_REGS", ";", "}", "if", "(", "!", "avr_strict_X", ")", "return", "reload_completed", "?", "BASE_POINTER_REGS", ":", "POINTER_REGS", ";", "return", "PLUS", "==", "outer_code", "?", "BASE_POINTER_REGS", ":", "POINTER_REGS", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "MODE_CODE_BASE_REG_CLASS", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_mode_code_base_reg_class", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30580, "Length": 54}
{"ground_truth": ["<s>", "static", "bool", "avr_mode_dependent_address_p", "(", "const_rtx", "addr", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", ")", "{", "return", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_MODE_DEPENDENT_ADDRESS_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_mode_dependent_address_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30581, "Length": 20}
{"ground_truth": ["<s>", "static", "void", "avr_move_bits", "(", "rtx", "*", "xop", ",", "unsigned", "int", "map", ",", "bool", "fixp_p", ",", "int", "*", "plen", ")", "{", "int", "t_bit_src", "=", "-", "1", ";", "for", "(", "int", "b", "=", "0", ";", "b", "<", "8", ";", "b", "++", ")", "for", "(", "int", "bit_dest", "=", "0", ";", "bit_dest", "<", "8", ";", "bit_dest", "++", ")", "{", "int", "bit_src", "=", "avr_map", "(", "map", ",", "bit_dest", ")", ";", "if", "(", "b", "!=", "bit_src", "||", "bit_src", ">=", "8", "||", "(", "bit_dest", "==", "bit_src", "&&", "!", "fixp_p", ")", ")", "continue", ";", "if", "(", "t_bit_src", "!=", "bit_src", ")", "{", "t_bit_src", "=", "bit_src", ";", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_src", ")", ";", "avr_asm_len", "(", "\"bst %T1%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "xop", "[", "3", "]", "=", "GEN_INT", "(", "bit_dest", ")", ";", "avr_asm_len", "(", "\"bld %T0%T3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "}", "</s>"], "natrual_language": ["Insert", "bits", "from", "XOP", "[", "1", "]", "into", "XOP", "[", "0", "]", "according", "to", "MAP", ".", "XOP", "[", "0", "]", "and", "XOP", "[", "1", "]", "do", "n't", "overlap", ".", "If", "FIXP_P", "=", "true", ":", "Move", "all", "bits", "according", "to", "MAP", "using", "BLD/BST", "sequences", ".", "If", "FIXP_P", "=", "false", ":", "Just", "move", "the", "bit", "if", "its", "position", "in", "the", "destination", "is", "different", "to", "its", "source", "position", "."], "TS_V_token": ["avr", "1", "0", "8", "0", "8", "8", "3", "\"bst %T1%T3\"", "1", "3", "\"bld %T0%T3\"", "1"], "File": "avr", "Func": "avr_move_bits", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30582, "Length": 142}
{"ground_truth": ["<s>", "static", "bool", "avr_move_fixed_operands", "(", "rtx", "*", "op", ",", "rtx", "*", "hreg", ",", "unsigned", "mask", ")", "{", "for", "(", ";", "mask", ";", "mask", ">>=", "1", ",", "op", "++", ",", "hreg", "++", ")", "if", "(", "(", "mask", "&", "1", ")", "&&", "*", "hreg", ")", "emit_move_insn", "(", "*", "hreg", ",", "*", "op", ")", ";", "return", "true", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "the", "function", "below", ":", "If", "bit", "n", "of", "MASK", "is", "set", "and", "HREG", "[", "n", "]", "!", "=", "NULL", ",", "then", "emit", "a", "move", "insn", "to", "copy", "OP", "[", "n", "]", "to", "HREG", "[", "n", "]", ".", "Otherwise", "do", "nothing", "for", "that", "n.", "Return", "TRUE", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr", "Func": "avr_move_fixed_operands", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30583, "Length": 55}
{"ground_truth": ["<s>", "static", "int", "avr_mul_highpart_cost", "(", "rtx", "x", ",", "int", ")", "{", "if", "(", "AVR_HAVE_MUL", "&&", "LSHIFTRT", "==", "GET_CODE", "(", "x", ")", "&&", "MULT", "==", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "HImode", "==", "mode", "||", "PSImode", "==", "mode", "||", "SImode", "==", "mode", ")", "{", "return", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "}", "return", "10000", ";", "}", "</s>"], "natrual_language": ["Cost", "for", "mul", "highpart", ".", "X", "is", "a", "LSHIFTRT", ",", "i.e", ".", "the", "outer", "TRUNCATE", "is", "already", "stripped", "off", "."], "TS_V_token": ["avr", "0", "1", "2", "10000"], "File": "avr", "Func": "avr_mul_highpart_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30584, "Length": 79}
{"ground_truth": ["<s>", "static", "int", "avr_naked_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"naked\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "non-zero", "if", "FUNC", "is", "a", "naked", "function", "."], "TS_V_token": ["avr", "\"naked\""], "File": "avr", "Func": "avr_naked_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30585, "Length": 17}
{"ground_truth": ["<s>", "static", "addr_space_t", "avr_nonconst_pointer_addrspace", "(", "tree", "typ", ")", "{", "while", "(", "ARRAY_TYPE", "==", "TREE_CODE", "(", "typ", ")", ")", "typ", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "typ", ")", ")", "{", "addr_space_t", "as", ";", "tree", "target", "=", "TREE_TYPE", "(", "typ", ")", ";", "if", "(", "FUNCTION_TYPE", "==", "TREE_CODE", "(", "target", ")", ")", "return", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "target", ")", ")", ";", "while", "(", "TREE_CODE", "(", "target", ")", "==", "ARRAY_TYPE", ")", "target", "=", "TREE_TYPE", "(", "target", ")", ";", "as", "=", "TYPE_ADDR_SPACE", "(", "target", ")", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", "&&", "!", "TYPE_READONLY", "(", "target", ")", "&&", "avr_addr_space_supported_p", "(", "as", ")", ")", "{", "return", "as", ";", "}", "return", "avr_nonconst_pointer_addrspace", "(", "target", ")", ";", "}", "return", "ADDR_SPACE_GENERIC", ";", "}", "</s>"], "natrual_language": ["Scan", "type", "TYP", "for", "pointer", "references", "to", "address", "space", "ASn", ".", "Return", "ADDR_SPACE_GENERIC", "(", "i.e", ".", "0", ")", "if", "all", "pointers", "targeting", "the", "AS", "are", "also", "declared", "to", "be", "CONST", ".", "Otherwise", ",", "return", "the", "respective", "address", "space", ",", "i.e", ".", "a", "value", "!", "=", "0", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_nonconst_pointer_addrspace", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30586, "Length": 119}
{"ground_truth": ["<s>", "RTX_CODE", "avr_normalize_condition", "(", "RTX_CODE", "condition", ")", "{", "switch", "(", "condition", ")", "{", "case", "GT", ":", "return", "GE", ";", "case", "GTU", ":", "return", "GEU", ";", "case", "LE", ":", "return", "LT", ";", "case", "LEU", ":", "return", "LTU", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>"], "natrual_language": ["Convert", "condition", "code", "CONDITION", "to", "the", "valid", "AVR", "condition", "code"], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_normalize_condition", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30587, "Length": 44}
{"ground_truth": ["<s>", "void", "avr_notice_update_cc", "(", "rtx", "body", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", ";", "enum", "attr_cc", "cc", "=", "get_attr_cc", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "break", ";", "case", "CC_PLUS", ":", "case", "CC_LDI", ":", "{", "rtx", "*", "op", "=", "recog_data", ".", "operand", ";", "int", "len_dummy", ",", "icc", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CC_PLUS", ":", "avr_out_plus", "(", "insn", ",", "op", ",", "&", "len_dummy", ",", "&", "icc", ")", ";", "cc", "=", "(", "enum", "attr_cc", ")", "icc", ";", "break", ";", "case", "CC_LDI", ":", "cc", "=", "(", "op", "[", "1", "]", "==", "CONST0_RTX", "(", "GET_MODE", "(", "op", "[", "0", "]", ")", ")", "&&", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "zero_reg_rtx", ")", ")", "?", "CC_CLOBBER", ":", "CC_NONE", ";", "break", ";", "}", "break", ";", "}", "}", "switch", "(", "cc", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "case", "CC_NONE", ":", "if", "(", "cc_status", ".", "value1", "||", "cc_status", ".", "value2", ")", "{", "HARD_REG_SET", "regs_used", ";", "HARD_REG_SET", "regs_set", ";", "CLEAR_HARD_REG_SET", "(", "regs_used", ")", ";", "if", "(", "cc_status", ".", "value1", "&&", "!", "CONSTANT_P", "(", "cc_status", ".", "value1", ")", ")", "{", "find_all_hard_regs", "(", "cc_status", ".", "value1", ",", "&", "regs_used", ")", ";", "}", "if", "(", "cc_status", ".", "value2", "&&", "!", "CONSTANT_P", "(", "cc_status", ".", "value2", ")", ")", "{", "find_all_hard_regs", "(", "cc_status", ".", "value2", ",", "&", "regs_used", ")", ";", "}", "find_all_hard_reg_sets", "(", "insn", ",", "&", "regs_set", ",", "false", ")", ";", "if", "(", "hard_reg_set_intersect_p", "(", "regs_used", ",", "regs_set", ")", ")", "{", "CC_STATUS_INIT", ";", "}", "}", "break", ";", "case", "CC_SET_N", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_ZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "flags", "|=", "CC_NO_OVERFLOW", ";", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "}", "break", ";", "case", "CC_SET_VZN", ":", "CC_STATUS_INIT", ";", "break", ";", "case", "CC_SET_CZN", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "{", "cc_status", ".", "value1", "=", "SET_DEST", "(", "set", ")", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", ";", "}", "break", ";", "case", "CC_COMPARE", ":", "set", "=", "single_set", "(", "insn", ")", ";", "CC_STATUS_INIT", ";", "if", "(", "set", ")", "cc_status", ".", "value1", "=", "SET_SRC", "(", "set", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "}", "}", "</s>"], "natrual_language": ["Update", "the", "condition", "code", "in", "the", "INSN", "."], "TS_V_token": ["avr", "1", "0", "0"], "File": "avr", "Func": "avr_notice_update_cc", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30588, "Length": 375}
{"ground_truth": ["<s>", "static", "int", "avr_no_gccisr_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"no_gccisr\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "a", "no_gccisr", "function", "as", "specified", "by", "the", "``", "no_gccisr", "''", "attribute", "."], "TS_V_token": ["avr", "\"no_gccisr\""], "File": "avr", "Func": "avr_no_gccisr_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30589, "Length": 17}
{"ground_truth": ["<s>", "static", "int", "avr_num_arg_regs", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "int", "size", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "1", ")", "&", "~", "1", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "number", "of", "registers", "to", "allocate", "for", "a", "function", "argument", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr", "Func": "avr_num_arg_regs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30590, "Length": 46}
{"ground_truth": ["<s>", "static", "int", "avr_operand_rtx_cost", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "enum", "rtx_code", "outer", ",", "int", "opno", ",", "bool", "speed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "int", "total", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "return", "0", ";", "case", "CONST_INT", ":", "case", "CONST_FIXED", ":", "case", "CONST_DOUBLE", ":", "return", "COSTS_N_INSNS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "default", ":", "break", ";", "}", "total", "=", "0", ";", "avr_rtx_costs", "(", "x", ",", "mode", ",", "outer", ",", "opno", ",", "&", "total", ",", "speed", ")", ";", "return", "total", ";", "}", "</s>"], "natrual_language": ["Mutually", "recursive", "subroutine", "of", "avr_rtx_cost", "for", "calculating", "the", "cost", "of", "an", "RTX", "operand", "given", "its", "context", ".", "X", "is", "the", "rtx", "of", "the", "operand", ",", "MODE", "is", "its", "mode", ",", "and", "OUTER", "is", "the", "rtx_code", "of", "this", "operand", "'s", "parent", "operator", "."], "TS_V_token": ["avr", "0", "0"], "File": "avr", "Func": "avr_operand_rtx_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30591, "Length": 94}
{"ground_truth": ["<s>", "static", "void", "avr_option_override", "(", "void", ")", "{", "if", "(", "avr_strict_X", ")", "flag_caller_saves", "=", "0", ";", "if", "(", "(", "flag_unwind_tables", "||", "flag_non_call_exceptions", "||", "flag_asynchronous_unwind_tables", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", "{", "flag_omit_frame_pointer", "=", "0", ";", "}", "if", "(", "flag_pic", "==", "1", ")", "warning", "(", "OPT_fpic", ",", "\"%<-fpic%> is not supported\"", ")", ";", "if", "(", "flag_pic", "==", "2", ")", "warning", "(", "OPT_fPIC", ",", "\"%<-fPIC%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "1", ")", "warning", "(", "OPT_fpie", ",", "\"%<-fpie%> is not supported\"", ")", ";", "if", "(", "flag_pie", "==", "2", ")", "warning", "(", "OPT_fPIE", ",", "\"%<-fPIE%> is not supported\"", ")", ";", "avr_gasisr_prologues", "=", "0", ";", "if", "(", "!", "avr_set_core_architecture", "(", ")", ")", "return", ";", "gcc_assert", "(", "avr_long_double", ">=", "avr_double", "&&", "avr_double", ">=", "32", ")", ";", "avr_addr", ".", "sreg", "=", "0x3F", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampz", "=", "0x3B", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampy", "=", "0x3A", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampx", "=", "0x39", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "rampd", "=", "0x38", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "ccp", "=", "(", "AVR_TINY", "?", "0x3C", ":", "0x34", ")", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_l", "=", "0x3D", "+", "avr_arch", "->", "sfr_offset", ";", "avr_addr", ".", "sp_h", "=", "avr_addr", ".", "sp_l", "+", "1", ";", "init_machine_status", "=", "avr_init_machine_status", ";", "avr_log_set_avr_log", "(", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_OPTION_OVERRIDE", "'", "."], "TS_V_token": ["avr", "0", "0", "1", "\"%<-fpic%> is not supported\"", "2", "\"%<-fPIC%> is not supported\"", "1", "\"%<-fpie%> is not supported\"", "2", "\"%<-fPIE%> is not supported\"", "0", "32", "0x3F", "0x3B", "0x3A", "0x39", "0x38", "0x3C", "0x34", "0x3D", "1"], "File": "avr", "Func": "avr_option_override", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30592, "Length": 205}
{"ground_truth": ["<s>", "static", "int", "avr_OS_main_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"OS_main\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "an", "OS_main", "function", "."], "TS_V_token": ["avr", "\"OS_main\""], "File": "avr", "Func": "avr_OS_main_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30593, "Length": 17}
{"ground_truth": ["<s>", "static", "int", "avr_OS_task_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"OS_task\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "an", "OS_task", "function", "."], "TS_V_token": ["avr", "\"OS_task\""], "File": "avr", "Func": "avr_OS_task_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30594, "Length": 17}
{"ground_truth": ["<s>", "static", "inline", "int", "avr_outgoing_args_size", "(", "void", ")", "{", "return", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "}", "</s>"], "natrual_language": ["Report", "contribution", "of", "accumulated", "outgoing", "arguments", "to", "stack", "size", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "avr_outgoing_args_size", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30595, "Length": 23}
{"ground_truth": ["<s>", "void", "avr_output_addr_vec", "(", "rtx_insn", "*", "labl", ",", "rtx", "table", ")", "{", "FILE", "*", "stream", "=", "asm_out_file", ";", "app_disable", "(", ")", ";", "if", "(", "DECL_SECTION_NAME", "(", "current_function_decl", ")", "&&", "symtab_node", "::", "get", "(", "current_function_decl", ")", "&&", "!", "symtab_node", "::", "get", "(", "current_function_decl", ")", "->", "implicit_section", ")", "{", "switch_to_section", "(", "current_function_section", "(", ")", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.subsection\\t1\\n\"", ")", ";", "}", "else", "{", "const", "char", "*", "sec_name", "=", "\".jumptables.gcc\"", ";", "tree", "asm_name", "=", "DECL_ASSEMBLER_NAME", "(", "current_function_decl", ")", ";", "const", "char", "*", "fname", "=", "IDENTIFIER_POINTER", "(", "asm_name", ")", ";", "fname", "=", "targetm", ".", "strip_name_encoding", "(", "fname", ")", ";", "sec_name", "=", "ACONCAT", "(", "(", "sec_name", ",", "\".\"", ",", "fname", ",", "NULL", ")", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.section\\t%s,\\\"%s\\\",@progbits\\n\"", ",", "sec_name", ",", "AVR_HAVE_JMP_CALL", "?", "\"a\"", ":", "\"ax\"", ")", ";", "}", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "1", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "stream", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "labl", ")", ")", ";", "int", "vlen", "=", "XVECLEN", "(", "table", ",", "0", ")", ";", "for", "(", "int", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "int", "value", "=", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XVECEXP", "(", "table", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ";", "if", "(", "AVR_HAVE_JMP_CALL", ")", "fprintf", "(", "stream", ",", "\"\\t.word gs(.L%d)\\n\"", ",", "value", ")", ";", "else", "fprintf", "(", "stream", ",", "\"\\trjmp .L%d\\n\"", ",", "value", ")", ";", "}", "in_section", "=", "NULL", ";", "switch_to_section", "(", "current_function_section", "(", ")", ")", ";", "}", "</s>"], "natrual_language": ["Emit", "jump", "tables", "out-of-line", "so", "that", "branches", "crossing", "the", "table", "get", "shorter", "offsets", ".", "If", "we", "have", "JUMP", "+", "CALL", ",", "then", "put", "the", "tables", "in", "a", "dedicated", "non-.text", "section", "so", "that", "CALLs", "get", "better", "chance", "to", "be", "relaxed", "to", "RCALLs", ".", "We", "emit", "the", "tables", "by", "hand", "because", "`", "function_rodata_section", "'", "does", "not", "work", "as", "expected", ",", "cf", ".", "PR71151", ",", "and", "we", "do", "*", "NOT", "*", "want", "the", "table", "to", "be", "in", ".rodata", ",", "hence", "setting", "JUMP_TABLES_IN_TEXT_SECTION", "=", "0", "is", "of", "limited", "use", ";", "and", "setting", "it", "to", "1", "attributes", "table", "lengths", "to", "branch", "offsets", "...", "Moreover", ",", "fincal.c", "keeps", "switching", "section", "before", "each", "table", "entry", "which", "we", "find", "too", "fragile", "as", "to", "rely", "on", "section", "caching", "."], "TS_V_token": ["avr", "\"\\t.subsection\\t1\\n\"", "\".jumptables.gcc\"", "\".\"", "\"\\t.section\\t%s,\\\"%s\\\",@progbits\\n\"", "\"a\"", "\"ax\"", "1", "\"L\"", "0", "0", "0", "0", "\"\\t.word gs(.L%d)\\n\"", "\"\\trjmp .L%d\\n\""], "File": "avr", "Func": "avr_output_addr_vec", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30596, "Length": 232}
{"ground_truth": ["<s>", "static", "void", "avr_output_bss_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "avr_need_clear_bss_p", "=", "true", ";", "output_section_asm_op", "(", "data", ")", ";", "}", "</s>"], "natrual_language": ["Unnamed", "section", "callback", "for", "bss_section", "to", "track", "need", "of", "__do_clear_bss", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_output_bss_section_asm_op", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30597, "Length": 20}
{"ground_truth": ["<s>", "static", "void", "avr_output_data_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "avr_need_copy_data_p", "=", "true", ";", "output_section_asm_op", "(", "data", ")", ";", "}", "</s>"], "natrual_language": ["Unnamed", "section", "callback", "for", "data_section", "to", "track", "need", "of", "__do_copy_data", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_output_data_section_asm_op", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30598, "Length": 20}
{"ground_truth": ["<s>", "static", "void", "avr_output_progmem_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"a\\\",@progbits\\n\"", ",", "data", ")", ";", "}", "</s>"], "natrual_language": ["Unnamed", "section", "callback", "for", "progmem", "*", ".data", "sections", "."], "TS_V_token": ["avr", "\"\\t.section\\t%s,\\\"a\\\",@progbits\\n\""], "File": "avr", "Func": "avr_output_progmem_section_asm_op", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30599, "Length": 20}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_addto_sp", "(", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "int", "pc_len", "=", "AVR_2_BYTE_PC", "?", "2", ":", "3", ";", "int", "addend", "=", "INTVAL", "(", "op", "[", "0", "]", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "addend", "<", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP -= %n0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "<=", "-", "pc_len", ")", "{", "addend", "+=", "pc_len", ";", "avr_asm_len", "(", "\"rcall .\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "while", "(", "addend", "++", "<", "0", ")", "avr_asm_len", "(", "\"push __tmp_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "addend", ">", "0", ")", "{", "if", "(", "flag_verbose_asm", "||", "flag_print_asm_name", ")", "avr_asm_len", "(", "ASM_COMMENT_START", "\"SP += %0\"", ",", "op", ",", "plen", ",", "0", ")", ";", "while", "(", "addend", "--", ">", "0", ")", "avr_asm_len", "(", "\"pop __tmp_reg__\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["PLEN", "==", "NULL", ":", "Output", "code", "to", "add", "CONST_INT", "OP", "[", "0", "]", "to", "SP", ".", "PLEN", "!", "=", "NULL", ":", "Set", "*", "PLEN", "to", "the", "length", "of", "that", "sequence", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "2", "3", "0", "0", "0", "\"SP -= %n0\"", "0", "\"rcall .\"", "1", "0", "\"push __tmp_reg__\"", "1", "0", "\"SP += %0\"", "0", "0", "\"pop __tmp_reg__\"", "1", "\"\""], "File": "avr", "Func": "avr_out_addto_sp", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30600, "Length": 160}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_ashlpsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "CONST_INT_P", "(", "op", "[", "2", "]", ")", ")", "{", "switch", "(", "INTVAL", "(", "op", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "op", "[", "2", "]", ")", "<", "24", ")", "break", ";", "return", "avr_asm_len", "(", "\"clr %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", ",", "op", ",", "plen", ",", "3", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "reg1", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "avr_asm_len", "(", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "3", ")", ";", "else", "return", "avr_asm_len", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", ",", "op", ",", "plen", ",", "3", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "reg1", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "!=", "reg1", ")", "avr_asm_len", "(", "\"mov %C0,%A0\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "avr_asm_len", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "case", "23", ":", "return", "avr_asm_len", "(", "\"clr %C0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ",", "op", ",", "plen", ",", "5", ")", ";", "}", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", ",", "insn", ",", "op", ",", "plen", ",", "3", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["24-bit", "shift", "left"], "TS_V_token": ["avr", "0", "2", "2", "2", "24", "\"clr %A0\"", "\"clr %B0\"", "\"clr %C0\"", "3", "8", "0", "1", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "3", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "3", "16", "0", "1", "2", "\"mov %C0,%A0\"", "1", "\"clr %B0\"", "\"clr %A0\"", "2", "23", "\"clr %C0\"", "\"lsr %A0\"", "\"ror %C0\"", "\"clr %B0\"", "\"clr %A0\"", "5", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "3", "\"\""], "File": "avr", "Func": "avr_out_ashlpsi3", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30601, "Length": 253}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_ashrpsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "int", "dest", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "src", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "CONST_INT_P", "(", "op", "[", "2", "]", ")", ")", "{", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "switch", "(", "INTVAL", "(", "op", "[", "2", "]", ")", ")", "{", "case", "8", ":", "if", "(", "dest", "<=", "src", ")", "return", "avr_asm_len", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"sbrc %B0,7\"", "CR_TAB", "\"dec %C0\"", ",", "op", ",", "plen", ",", "5", ")", ";", "else", "return", "avr_asm_len", "(", "\"clr %C0\"", "CR_TAB", "\"sbrc %C1,7\"", "CR_TAB", "\"dec %C0\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ",", "op", ",", "plen", ",", "5", ")", ";", "case", "16", ":", "if", "(", "dest", "!=", "src", "+", "2", ")", "avr_asm_len", "(", "\"mov %A0,%C1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "avr_asm_len", "(", "\"clr %B0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"com %B0\"", "CR_TAB", "\"mov %C0,%B0\"", ",", "op", ",", "plen", ",", "4", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "op", "[", "2", "]", ")", "<", "24", ")", "break", ";", "case", "23", ":", "return", "avr_asm_len", "(", "\"lsl %C0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"mov %C0,%A0\"", ",", "op", ",", "plen", ",", "4", ")", ";", "}", "}", "out_shift_with_cnt", "(", "\"asr %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "op", ",", "plen", ",", "3", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["24-bit", "arithmetic", "shift", "right"], "TS_V_token": ["avr", "0", "1", "2", "0", "2", "8", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"clr %C0\"", "\"sbrc %B0,7\"", "\"dec %C0\"", "5", "\"clr %C0\"", "\"sbrc %C1,7\"", "\"dec %C0\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "5", "16", "2", "\"mov %A0,%C1\"", "1", "\"clr %B0\"", "\"sbrc %A0,7\"", "\"com %B0\"", "\"mov %C0,%B0\"", "4", "2", "24", "23", "\"lsl %C0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"mov %C0,%A0\"", "4", "\"asr %C0\"", "\"ror %B0\"", "\"ror %A0\"", "3", "\"\""], "File": "avr", "Func": "avr_out_ashrpsi3", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30602, "Length": 221}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_compare64", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "xop", "[", "3", "]", ";", "xop", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "18", ")", ";", "xop", "[", "1", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "2", "]", "=", "op", "[", "1", "]", ";", "return", "avr_out_compare", "(", "insn", ",", "xop", ",", "plen", ")", ";", "}", "</s>"], "natrual_language": ["Prepare", "operands", "of", "compare_const_di2", "to", "be", "used", "with", "avr_out_compare", "."], "TS_V_token": ["avr", "3", "0", "18", "1", "0", "2", "1"], "File": "avr", "Func": "avr_out_compare64", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30603, "Length": 67}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_cpymem", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "addr_space_t", "as", "=", "(", "addr_space_t", ")", "INTVAL", "(", "op", "[", "0", "]", ")", ";", "machine_mode", "loop_mode", "=", "GET_MODE", "(", "op", "[", "1", "]", ")", ";", "bool", "sbiw_p", "=", "test_hard_reg_class", "(", "ADDW_REGS", ",", "op", "[", "1", "]", ")", ";", "rtx", "xop", "[", "3", "]", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "xop", "[", "0", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "1", "]", "=", "op", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "tmp_reg_rtx", ";", "avr_asm_len", "(", "\"0:\"", ",", "xop", ",", "plen", ",", "0", ")", ";", "switch", "(", "as", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ADDR_SPACE_GENERIC", ":", "avr_asm_len", "(", "\"ld %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH", ":", "if", "(", "AVR_HAVE_LPMX", ")", "avr_asm_len", "(", "\"lpm %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "else", "avr_asm_len", "(", "\"lpm\"", "CR_TAB", "\"adiw r30,1\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "break", ";", "case", "ADDR_SPACE_FLASH1", ":", "case", "ADDR_SPACE_FLASH2", ":", "case", "ADDR_SPACE_FLASH3", ":", "case", "ADDR_SPACE_FLASH4", ":", "case", "ADDR_SPACE_FLASH5", ":", "if", "(", "AVR_HAVE_ELPMX", ")", "avr_asm_len", "(", "\"elpm %2,Z+\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "else", "avr_asm_len", "(", "\"elpm\"", "CR_TAB", "\"adiw r30,1\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "break", ";", "}", "avr_asm_len", "(", "\"st X+,%2\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "if", "(", "QImode", "==", "loop_mode", ")", "{", "avr_asm_len", "(", "\"dec %1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "sbiw_p", ")", "{", "avr_asm_len", "(", "\"sbiw %1,1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"subi %A1,1\"", "CR_TAB", "\"sbci %B1,0\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "}", "return", "avr_asm_len", "(", "\"brne 0b\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "</s>"], "natrual_language": ["Print", "assembler", "for", "cpymem_qi", ",", "cpymem_hi", "insns", "...", "$", "0", ":", "Address", "Space", "$", "1", ",", "$", "2", ":", "Loop", "register", "Z", ":", "Source", "address", "X", ":", "Destination", "address"], "TS_V_token": ["avr", "0", "1", "1", "3", "0", "0", "0", "1", "1", "2", "\"0:\"", "0", "\"ld %2,Z+\"", "1", "\"lpm %2,Z+\"", "1", "\"lpm\"", "\"adiw r30,1\"", "2", "\"elpm %2,Z+\"", "1", "\"elpm\"", "\"adiw r30,1\"", "2", "\"st X+,%2\"", "1", "\"dec %1\"", "1", "\"sbiw %1,1\"", "1", "\"subi %A1,1\"", "\"sbci %B1,0\"", "2", "\"brne 0b\"", "1"], "File": "avr", "Func": "avr_out_cpymem", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30604, "Length": 295}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_insert_bits", "(", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "op", "[", "1", "]", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "unsigned", "mask_fixed", ";", "bool", "fixp_p", "=", "true", ";", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "1", "]", "=", "op", "[", "2", "]", ";", "xop", "[", "2", "]", "=", "op", "[", "3", "]", ";", "gcc_assert", "(", "REG_P", "(", "xop", "[", "2", "]", ")", "||", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "else", "if", "(", "flag_print_asm_name", ")", "fprintf", "(", "asm_out_file", ",", "ASM_COMMENT_START", "\"map = 0x%08x\\n\"", ",", "map", ")", ";", "mask_fixed", "=", "avr_map_metric", "(", "map", ",", "MAP_MASK_FIXED_0_7", ")", ";", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "==", "REGNO", "(", "xop", "[", "1", "]", ")", ")", "{", "avr_asm_len", "(", "\"mov __tmp_reg__,%1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "xop", "[", "1", "]", "=", "tmp_reg_rtx", ";", "fixp_p", "=", "false", ";", "}", "if", "(", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", ")", "{", "int", "n_fix", "=", "0", ",", "n_nofix", "=", "0", ";", "gcc_assert", "(", "REG_P", "(", "xop", "[", "2", "]", ")", ")", ";", "avr_move_bits", "(", "xop", ",", "map", ",", "true", ",", "&", "n_fix", ")", ";", "avr_move_bits", "(", "xop", ",", "map", ",", "false", ",", "&", "n_nofix", ")", ";", "if", "(", "fixp_p", "&&", "n_fix", "-", "n_nofix", ">", "3", ")", "{", "xop", "[", "3", "]", "=", "gen_int_mode", "(", "~", "mask_fixed", ",", "QImode", ")", ";", "avr_asm_len", "(", "\"eor %0,%1\"", "CR_TAB", "\"andi %0,%3\"", "CR_TAB", "\"eor %0,%1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "fixp_p", "=", "false", ";", "}", "}", "else", "{", "if", "(", "fixp_p", "&&", "mask_fixed", ")", "{", "avr_asm_len", "(", "\"mov %0,%1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "fixp_p", "=", "false", ";", "}", "}", "avr_move_bits", "(", "xop", ",", "map", ",", "fixp_p", ",", "plen", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["PLEN", "==", "0", ":", "Print", "assembler", "code", "for", "`", "insert_bits", "'", ".", "PLEN", "!", "=", "0", ":", "Compute", "code", "length", "in", "bytes", ".", "OP", "[", "0", "]", ":", "Result", "OP", "[", "1", "]", ":", "The", "mapping", "composed", "of", "nibbles", ".", "If", "nibble", "no", ".", "N", "is", "0", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "2", "]", ".0", "...", "...", "7", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "2", "]", ".7", "0xf", ":", "Bit", "N", "of", "result", "is", "copied", "from", "bit", "OP", "[", "3", "]", ".N", "OP", "[", "2", "]", ":", "Bits", "to", "be", "inserted", "OP", "[", "3", "]", ":", "Target", "value"], "TS_V_token": ["avr", "1", "4", "0", "0", "1", "2", "2", "3", "2", "2", "0", "\"map = 0x%08x\\n\"", "0", "1", "\"mov __tmp_reg__,%1\"", "1", "1", "0", "0", "2", "3", "3", "\"eor %0,%1\"", "\"andi %0,%3\"", "\"eor %0,%1\"", "3", "\"mov %0,%1\"", "1", "\"\""], "File": "avr", "Func": "avr_out_insert_bits", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30605, "Length": 309}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_insert_notbit", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "rtx", "xbitno", ",", "int", "*", "plen", ")", "{", "rtx", "op", "[", "4", "]", "=", "{", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "xbitno", "==", "NULL_RTX", "?", "operands", "[", "3", "]", ":", "xbitno", "}", ";", "if", "(", "INTVAL", "(", "op", "[", "1", "]", ")", "==", "7", "&&", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "op", "[", "3", "]", ")", "==", "7", "&&", "REGNO", "(", "op", "[", "0", "]", ")", "==", "REGNO", "(", "op", "[", "2", "]", ")", ")", "{", "avr_asm_len", "(", "\"subi %0,0x80\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"bst %2,%3\"", "CR_TAB", "\"bld %0,%1\"", "CR_TAB", "\"subi %0,0x80\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "}", "else", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", "&&", "(", "INTVAL", "(", "op", "[", "1", "]", ")", "!=", "INTVAL", "(", "op", "[", "3", "]", ")", "||", "!", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "op", "[", "2", "]", ")", ")", ")", "{", "avr_asm_len", "(", "\"andi %0,~(1<<%1)\"", "CR_TAB", "\"sbrs %2,%3\"", "CR_TAB", "\"ori %0,1<<%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"com %2\"", "CR_TAB", "\"bst %2,%3\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "op", "[", "2", "]", ")", "||", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "op", "[", "2", "]", ")", ")", "{", "avr_asm_len", "(", "\"com %2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "avr_asm_len", "(", "\"bld %0,%1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "instructions", "to", "insert", "an", "inverted", "bit", "into", "OPERANDS", "[", "0", "]", ":", "$", "0.", "$", "1", "=", "~", "$", "2.", "$", "3", "if", "XBITNO", "=", "NULL", "$", "0.", "$", "1", "=", "~", "$", "2.XBITNO", "if", "XBITNO", "!", "=", "NULL", ".", "If", "PLEN", "=", "NULL", "then", "output", "the", "respective", "instruction", "sequence", "which", "is", "a", "combination", "of", "BST", "/", "BLD", "and", "some", "instruction", "(", "s", ")", "to", "invert", "the", "bit", ".", "If", "PLEN", "!", "=", "NULL", "then", "store", "the", "length", "of", "the", "sequence", "(", "in", "words", ")", "in", "*", "PLEN", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "4", "0", "1", "2", "3", "1", "7", "0", "3", "7", "0", "2", "\"subi %0,0x80\"", "1", "\"bst %2,%3\"", "\"bld %0,%1\"", "\"subi %0,0x80\"", "3", "0", "1", "3", "0", "2", "\"andi %0,~(1<<%1)\"", "\"sbrs %2,%3\"", "\"ori %0,1<<%1\"", "3", "\"com %2\"", "\"bst %2,%3\"", "2", "2", "0", "2", "\"com %2\"", "1", "\"bld %0,%1\"", "1", "\"\""], "File": "avr", "Func": "avr_out_insert_notbit", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30606, "Length": 275}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_load_psi_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", "CR_TAB", "\"ld %C0,%1\"", "CR_TAB", "\"ld __tmp_reg__,-%1\"", "CR_TAB", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", "CR_TAB", "\"ld %A0,%1\"", "CR_TAB", "\"mov %B0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "8", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1+\"", "CR_TAB", "\"ld %C0,%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "reg_dest", "!=", "reg_base", "-", "2", "&&", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "{", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "2", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "return", "\"\"", ";", "}", "}", "</s>"], "natrual_language": ["Handle", "loads", "of", "24-bit", "types", "from", "memory", "to", "register", "."], "TS_V_token": ["avr", "0", "1", "0", "2", "\"ld %C0,%1\"", "\"ld __tmp_reg__,-%1\"", "1", "\"ld %A0,%1\"", "\"mov %B0,__tmp_reg__\"", "8", "\"ld %A0,%1+\"", "\"ld %B0,%1+\"", "\"ld %C0,%1\"", "3", "2", "2", "2", "\"\""], "File": "avr", "Func": "avr_out_load_psi_reg_no_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30607, "Length": 171}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_lpm_no_lpmx", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "xop", "[", "0", "]", ";", "rtx", "addr", "=", "xop", "[", "1", "]", ";", "int", "n_bytes", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", ";", "int", "regno_dest", ";", "regno_dest", "=", "REGNO", "(", "dest", ")", ";", "xop", "[", "3", "]", "=", "lpm_reg_rtx", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "REG", ":", "gcc_assert", "(", "REG_Z", "==", "REGNO", "(", "addr", ")", ")", ";", "switch", "(", "n_bytes", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "1", ":", "avr_asm_len", "(", "\"%4lpm\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "if", "(", "regno_dest", "!=", "LPM_REGNO", ")", "avr_asm_len", "(", "\"mov %0,%3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "case", "2", ":", "if", "(", "REGNO", "(", "dest", ")", "==", "REG_Z", ")", "return", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"push %3\"", "CR_TAB", "\"adiw %2,1\"", "CR_TAB", "\"%4lpm\"", "CR_TAB", "\"mov %B0,%3\"", "CR_TAB", "\"pop %A0\"", ",", "xop", ",", "plen", ",", "6", ")", ";", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"mov %A0,%3\"", "CR_TAB", "\"adiw %2,1\"", "CR_TAB", "\"%4lpm\"", "CR_TAB", "\"mov %B0,%3\"", ",", "xop", ",", "plen", ",", "5", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "addr", ")", ")", "avr_asm_len", "(", "\"sbiw %2,1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "break", ";", "}", "break", ";", "case", "POST_INC", ":", "gcc_assert", "(", "REG_Z", "==", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "n_bytes", "<=", "4", ")", ";", "if", "(", "regno_dest", "==", "LPM_REGNO", ")", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"adiw %2,1\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "else", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"mov %A0,%3\"", "CR_TAB", "\"adiw %2,1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "if", "(", "n_bytes", ">=", "2", ")", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"mov %B0,%3\"", "CR_TAB", "\"adiw %2,1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "if", "(", "n_bytes", ">=", "3", ")", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"mov %C0,%3\"", "CR_TAB", "\"adiw %2,1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "if", "(", "n_bytes", ">=", "4", ")", "avr_asm_len", "(", "\"%4lpm\"", "CR_TAB", "\"mov %D0,%3\"", "CR_TAB", "\"adiw %2,1\"", ",", "xop", ",", "plen", ",", "3", ")", ";", "break", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "the", "next", "function", "in", "the", "case", "where", "only", "restricted", "version", "of", "LPM", "instruction", "is", "available", "."], "TS_V_token": ["avr", "0", "1", "3", "1", "\"%4lpm\"", "1", "\"mov %0,%3\"", "1", "\"\"", "2", "\"%4lpm\"", "\"push %3\"", "\"adiw %2,1\"", "\"%4lpm\"", "\"mov %B0,%3\"", "\"pop %A0\"", "6", "\"%4lpm\"", "\"mov %A0,%3\"", "\"adiw %2,1\"", "\"%4lpm\"", "\"mov %B0,%3\"", "5", "\"sbiw %2,1\"", "1", "0", "4", "\"%4lpm\"", "\"adiw %2,1\"", "2", "\"%4lpm\"", "\"mov %A0,%3\"", "\"adiw %2,1\"", "3", "2", "\"%4lpm\"", "\"mov %B0,%3\"", "\"adiw %2,1\"", "3", "3", "\"%4lpm\"", "\"mov %C0,%3\"", "\"adiw %2,1\"", "3", "4", "\"%4lpm\"", "\"mov %D0,%3\"", "\"adiw %2,1\"", "3", "\"\""], "File": "avr", "Func": "avr_out_lpm_no_lpmx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30608, "Length": 341}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_lshrpsi3", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "int", "dest", "=", "REGNO", "(", "op", "[", "0", "]", ")", ";", "int", "src", "=", "REGNO", "(", "op", "[", "1", "]", ")", ";", "if", "(", "CONST_INT_P", "(", "op", "[", "2", "]", ")", ")", "{", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "switch", "(", "INTVAL", "(", "op", "[", "2", "]", ")", ")", "{", "case", "8", ":", "if", "(", "dest", "<=", "src", ")", "return", "avr_asm_len", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"clr %C0\"", ",", "op", ",", "plen", ",", "3", ")", ";", "else", "return", "avr_asm_len", "(", "\"clr %C0\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ",", "op", ",", "plen", ",", "3", ")", ";", "case", "16", ":", "if", "(", "dest", "!=", "src", "+", "2", ")", "avr_asm_len", "(", "\"mov %A0,%C1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "avr_asm_len", "(", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", ",", "op", ",", "plen", ",", "2", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "op", "[", "2", "]", ")", "<", "24", ")", "break", ";", "case", "23", ":", "return", "avr_asm_len", "(", "\"clr %A0\"", "CR_TAB", "\"sbrc %C0,7\"", "CR_TAB", "\"inc %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", ",", "op", ",", "plen", ",", "5", ")", ";", "}", "}", "out_shift_with_cnt", "(", "\"lsr %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "op", ",", "plen", ",", "3", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["24-bit", "logic", "shift", "right"], "TS_V_token": ["avr", "0", "1", "2", "0", "2", "8", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"clr %C0\"", "3", "\"clr %C0\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "3", "16", "2", "\"mov %A0,%C1\"", "1", "\"clr %B0\"", "\"clr %C0\"", "2", "2", "24", "23", "\"clr %A0\"", "\"sbrc %C0,7\"", "\"inc %A0\"", "\"clr %B0\"", "\"clr %C0\"", "5", "\"lsr %C0\"", "\"ror %B0\"", "\"ror %A0\"", "3", "\"\""], "File": "avr", "Func": "avr_out_lshrpsi3", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30609, "Length": 211}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_mr_r_xmega", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "int", "reg_src", "=", "true_regnum", "(", "src", ")", ";", "int", "mem_volatile_p", "=", "MEM_VOLATILE_P", "(", "dest", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "return", "io_address_operand", "(", "base", ",", "HImode", ")", "?", "avr_asm_len", "(", "\"out %i0,%A1\"", "CR_TAB", "\"out %i0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ":", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "reg_base", "!=", "REG_X", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "reg_src", "==", "REG_X", ")", "avr_asm_len", "(", "\"mov __tmp_reg__,r27\"", "CR_TAB", "\"st X,r26\"", "CR_TAB", "\"adiw r26,1\"", "CR_TAB", "\"st X,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "else", "avr_asm_len", "(", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "reg_unused_after", "(", "insn", ",", "base", ")", "?", "\"\"", ":", "avr_asm_len", "(", "\"sbiw r26,1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "return", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", "?", "avr_asm_len", "(", "\"adiw r28,%o0-62\"", "CR_TAB", "\"std Y+62,%A1\"", "CR_TAB", "\"std Y+63,%B1\"", "CR_TAB", "\"sbiw r28,%o0-62\"", ",", "op", ",", "plen", ",", "-", "4", ")", ":", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "if", "(", "reg_base", "!=", "REG_X", ")", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "reg_src", "==", "REG_X", "?", "avr_asm_len", "(", "\"mov __tmp_reg__,r26\"", "CR_TAB", "\"mov __zero_reg__,r27\"", "CR_TAB", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,__tmp_reg__\"", "CR_TAB", "\"st X,__zero_reg__\"", "CR_TAB", "\"clr __zero_reg__\"", "CR_TAB", "\"sbiw r26,%o0+1\"", ",", "op", ",", "plen", ",", "-", "7", ")", ":", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", "CR_TAB", "\"sbiw r26,%o0+1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "{", "if", "(", "!", "mem_volatile_p", ")", "return", "avr_asm_len", "(", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", "==", "REG_X", "?", "avr_asm_len", "(", "\"sbiw r26,2\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X,%B1\"", "CR_TAB", "\"sbiw r26,1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ":", "avr_asm_len", "(", "\"sbiw %r0,2\"", "CR_TAB", "\"st %p0,%A1\"", "CR_TAB", "\"std %p0+1,%B1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "{", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "}", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "the", "next", "function", "for", "XMEGA", ".", "It", "does", "the", "same", "but", "with", "low", "byte", "first", "."], "TS_V_token": ["avr", "0", "1", "0", "\"out %i0,%A1\"", "\"out %i0+1,%B1\"", "2", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "4", "0", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "2", "\"mov __tmp_reg__,r27\"", "\"st X,r26\"", "\"adiw r26,1\"", "\"st X,__tmp_reg__\"", "4", "\"st X+,%A1\"", "\"st X,%B1\"", "2", "\"\"", "\"sbiw r26,1\"", "1", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-62\"", "\"std Y+62,%A1\"", "\"std Y+63,%B1\"", "\"sbiw r28,%o0-62\"", "4", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "6", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "2", "\"mov __tmp_reg__,r26\"", "\"mov __zero_reg__,r27\"", "\"adiw r26,%o0\"", "\"st X+,__tmp_reg__\"", "\"st X,__zero_reg__\"", "\"clr __zero_reg__\"", "\"sbiw r26,%o0+1\"", "7", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X,%B1\"", "\"sbiw r26,%o0+1\"", "4", "\"st %0,%B1\"", "\"st %0,%A1\"", "2", "0", "\"sbiw r26,2\"", "\"st X+,%A1\"", "\"st X,%B1\"", "\"sbiw r26,1\"", "4", "\"sbiw %r0,2\"", "\"st %p0,%A1\"", "\"std %p0+1,%B1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "2", "\"unknown move insn:\"", "\"\""], "File": "avr", "Func": "avr_out_movhi_mr_r_xmega", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30610, "Length": 506}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_pre_dec_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "int", "mem_volatile_p", "=", "0", ";", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "mem_volatile_p", "=", "MEM_VOLATILE_P", "(", "src", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "dest", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "if", "(", "!", "mem_volatile_p", ")", "return", "avr_asm_len", "(", "\"ld %B0,%1\"", "CR_TAB", "\"ld %A0,%1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "2", ")", "CR_TAB", "\"ld %A0,%p1+\"", "CR_TAB", "\"ld %B0,%p1\"", "CR_TAB", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "1", ")", ",", "op", ",", "plen", ",", "-", "6", ")", ";", "}", "</s>"], "natrual_language": ["Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD"], "TS_V_token": ["avr", "0", "0", "1", "0", "0", "\"incorrect insn:\"", "\"ld %B0,%1\"", "\"ld %A0,%1\"", "2", "2", "\"ld %A0,%p1+\"", "\"ld %B0,%p1\"", "1", "6"], "File": "avr", "Func": "avr_out_movhi_r_mr_pre_dec_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30611, "Length": 137}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "reg_base", "==", "reg_dest", ")", "{", "return", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld __tmp_reg__,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "}", "else", "{", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %A0,%b1+\"", "CR_TAB", "\"ld %B0,%b1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", "+", "1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "}", "</s>"], "natrual_language": ["Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD"], "TS_V_token": ["avr", "0", "1", "0", "0", "\"ld __tmp_reg__,%b1+\"", "\"ld %B0,%b1\"", "\"mov %A0,__tmp_reg__\"", "5", "\"ld %A0,%b1+\"", "\"ld %B0,%b1\"", "4", "0", "1", "2", "\"\""], "File": "avr", "Func": "avr_out_movhi_r_mr_reg_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30612, "Length": 175}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movhi_r_mr_reg_no_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "reg_dest", "=", "true_regnum", "(", "dest", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "reg_dest", "==", "reg_base", ")", "return", "avr_asm_len", "(", "\"ld __tmp_reg__,%1+\"", "CR_TAB", "\"ld %B0,%1\"", "CR_TAB", "\"mov %A0,__tmp_reg__\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "avr_asm_len", "(", "\"ld %A0,%1+\"", "CR_TAB", "\"ld %B0,%1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "E1", ",", "%", "F1", ",", "1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Same", "as", "movhi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", ",", "SBIW", "and", "LDD"], "TS_V_token": ["avr", "0", "1", "0", "\"ld __tmp_reg__,%1+\"", "\"ld %B0,%1\"", "\"mov %A0,__tmp_reg__\"", "3", "\"ld %A0,%1+\"", "\"ld %B0,%1\"", "2", "1", "2", "\"\""], "File": "avr", "Func": "avr_out_movhi_r_mr_reg_no_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30613, "Length": 133}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_movpsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "if", "(", "avr_mem_flash_p", "(", "src", ")", "||", "avr_mem_flash_p", "(", "dest", ")", ")", "{", "return", "avr_out_lpm", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "if", "(", "register_operand", "(", "dest", ",", "VOIDmode", ")", ")", "{", "if", "(", "register_operand", "(", "src", ",", "VOIDmode", ")", ")", "{", "if", "(", "true_regnum", "(", "dest", ")", ">", "true_regnum", "(", "src", ")", ")", "{", "avr_asm_len", "(", "\"mov %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "avr_asm_len", "(", "\"movw %A0,%A1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "else", "return", "avr_asm_len", "(", "\"mov %B0,%B1\"", "CR_TAB", "\"mov %A0,%A1\"", ",", "op", ",", "plen", ",", "2", ")", ";", "}", "else", "{", "if", "(", "AVR_HAVE_MOVW", ")", "avr_asm_len", "(", "\"movw %A0,%A1\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "else", "avr_asm_len", "(", "\"mov %A0,%A1\"", "CR_TAB", "\"mov %B0,%B1\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "return", "avr_asm_len", "(", "\"mov %C0,%C1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "src", ")", ")", "{", "return", "avr_out_reload_inpsi", "(", "op", ",", "NULL_RTX", ",", "plen", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "src", ")", ")", "return", "avr_out_load_psi", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "dest", ")", ")", "{", "rtx", "xop", "[", "2", "]", ";", "xop", "[", "0", "]", "=", "dest", ";", "xop", "[", "1", "]", "=", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "dest", ")", ")", "?", "zero_reg_rtx", ":", "src", ";", "return", "avr_out_store_psi", "(", "insn", ",", "xop", ",", "plen", ")", ";", "}", "fatal_insn", "(", "\"invalid insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Move", "around", "24-bit", "stuff", "."], "TS_V_token": ["avr", "0", "1", "\"mov %C0,%C1\"", "1", "\"movw %A0,%A1\"", "1", "\"mov %B0,%B1\"", "\"mov %A0,%A1\"", "2", "\"movw %A0,%A1\"", "1", "\"mov %A0,%A1\"", "\"mov %B0,%B1\"", "2", "\"mov %C0,%C1\"", "1", "2", "0", "1", "\"invalid insn:\"", "\"\""], "File": "avr", "Func": "avr_out_movpsi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30614, "Length": 284}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_movqi_r_mr_reg_disp_tiny", "(", "rtx_insn", "*", "insn", ",", "rtx", "op", "[", "]", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "x", "=", "XEXP", "(", "src", ",", "0", ")", ";", "avr_asm_len", "(", "TINY_ADIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", "CR_TAB", "\"ld %0,%b1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "dest", ",", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "avr_asm_len", "(", "TINY_SBIW", "(", "%", "I1", ",", "%", "J1", ",", "%", "o1", ")", ",", "op", ",", "plen", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Same", "as", "out_movqi_r_mr", ",", "but", "TINY", "does", "not", "have", "ADIW", "or", "SBIW"], "TS_V_token": ["avr", "0", "1", "0", "\"ld %0,%b1\"", "3", "0", "0", "2", "\"\""], "File": "avr", "Func": "avr_out_movqi_r_mr_reg_disp_tiny", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30615, "Length": 123}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_plus_symbol", "(", "rtx", "*", "xop", ",", "enum", "rtx_code", "code", ",", "int", "*", "plen", ",", "int", "*", "pcc", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xop", "[", "0", "]", ")", ";", "gcc_assert", "(", "mode", "==", "HImode", "||", "mode", "==", "PSImode", ")", ";", "*", "pcc", "=", "MINUS", "==", "code", "?", "(", "int", ")", "CC_SET_CZN", ":", "(", "int", ")", "CC_SET_N", ";", "avr_asm_len", "(", "PLUS", "==", "code", "?", "\"subi %A0,lo8(-(%2))\"", "CR_TAB", "\"sbci %B0,hi8(-(%2))\"", ":", "\"subi %A0,lo8(%2)\"", "CR_TAB", "\"sbci %B0,hi8(%2)\"", ",", "xop", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "PSImode", "==", "mode", ")", "avr_asm_len", "(", "PLUS", "==", "code", "?", "\"sbci %C0,hlo8(-(%2))\"", ":", "\"sbci %C0,hlo8(%2)\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "addition/subtraction", "of", "register", "XOP", "[", "0", "]", "and", "a", "constant", "XOP", "[", "2", "]", "that", "is", "ont", "a", "compile-time", "constant", ":", "XOP", "[", "0", "]", "=", "XOP", "[", "0", "]", "+/-", "XOP", "[", "2", "]", "This", "is", "a", "helper", "for", "the", "function", "below", ".", "The", "only", "insns", "that", "need", "this", "are", "additions/subtraction", "for", "pointer", "modes", ",", "i.e", ".", "HImode", "and", "PSImode", "."], "TS_V_token": ["avr", "0", "\"subi %A0,lo8(-(%2))\"", "\"sbci %B0,hi8(-(%2))\"", "\"subi %A0,lo8(%2)\"", "\"sbci %B0,hi8(%2)\"", "2", "\"sbci %C0,hlo8(-(%2))\"", "\"sbci %C0,hlo8(%2)\"", "1", "\"\""], "File": "avr", "Func": "avr_out_plus_symbol", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30616, "Length": 111}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_round", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "scalar_mode", "mode", "=", "as_a", "<", "scalar_mode", ">", "(", "GET_MODE", "(", "xop", "[", "0", "]", ")", ")", ";", "scalar_int_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "int", "fbit", "=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ";", "double_int", "i_add", "=", "double_int_zero", ".", "set_bit", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ")", ";", "wide_int", "wi_add", "=", "wi", "::", "set_bit_in_zero", "(", "fbit", "-", "1", "-", "INTVAL", "(", "xop", "[", "2", "]", ")", ",", "GET_MODE_PRECISION", "(", "imode", ")", ")", ";", "int", "len_add", "=", "0", ",", "*", "plen_add", "=", "plen", "?", "&", "len_add", ":", "NULL", ";", "int", "len_and", "=", "0", ",", "*", "plen_and", "=", "plen", "?", "&", "len_and", ":", "NULL", ";", "rtx", "xadd", "=", "const_fixed_from_double_int", "(", "i_add", ",", "mode", ")", ";", "rtx", "xpattern", ",", "xsrc", ",", "op", "[", "4", "]", ";", "xsrc", "=", "SIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", "?", "gen_rtx_SS_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ":", "gen_rtx_US_PLUS", "(", "mode", ",", "xop", "[", "1", "]", ",", "xadd", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xop", "[", "0", "]", ",", "xsrc", ")", ";", "op", "[", "0", "]", "=", "xop", "[", "0", "]", ";", "op", "[", "1", "]", "=", "xop", "[", "1", "]", ";", "op", "[", "2", "]", "=", "xadd", ";", "avr_out_plus", "(", "xpattern", ",", "op", ",", "plen_add", ",", "NULL", ",", "false", ")", ";", "avr_asm_len", "(", "\"rjmp 1f\"", "CR_TAB", "\"0:\"", ",", "NULL", ",", "plen_add", ",", "1", ")", ";", "rtx", "xreg", "=", "simplify_gen_subreg", "(", "imode", ",", "xop", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "rtx", "xmask", "=", "immed_wide_int_const", "(", "-", "wi_add", "-", "wi_add", ",", "imode", ")", ";", "xpattern", "=", "gen_rtx_SET", "(", "xreg", ",", "gen_rtx_AND", "(", "imode", ",", "xreg", ",", "xmask", ")", ")", ";", "op", "[", "0", "]", "=", "xreg", ";", "op", "[", "1", "]", "=", "xreg", ";", "op", "[", "2", "]", "=", "xmask", ";", "op", "[", "3", "]", "=", "gen_rtx_SCRATCH", "(", "QImode", ")", ";", "avr_out_bitop", "(", "xpattern", ",", "op", ",", "plen_and", ")", ";", "avr_asm_len", "(", "\"1:\"", ",", "NULL", ",", "plen", ",", "0", ")", ";", "if", "(", "plen", ")", "*", "plen", "=", "len_add", "+", "len_and", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "fixed-point", "rounding", ".", "XOP", "[", "0", "]", "=", "XOP", "[", "1", "]", "is", "the", "operand", "to", "round", ".", "XOP", "[", "2", "]", "is", "the", "rounding", "point", ",", "a", "CONST_INT", ".", "The", "function", "prints", "the", "instruction", "sequence", "if", "PLEN", "=", "NULL", "and", "computes", "the", "length", "in", "words", "of", "the", "sequence", "if", "PLEN", "!", "=", "NULL", ".", "Most", "of", "this", "function", "deals", "with", "preparing", "operands", "for", "calls", "to", "`", "avr_out_plus", "'", "and", "`", "avr_out_bitop", "'", "."], "TS_V_token": ["avr", "0", "1", "2", "1", "2", "0", "0", "4", "1", "1", "0", "0", "0", "1", "1", "2", "\"rjmp 1f\"", "\"0:\"", "1", "0", "0", "0", "1", "2", "3", "\"1:\"", "0", "\"\""], "File": "avr", "Func": "avr_out_round", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30617, "Length": 362}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_sbxx_branch", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "comp", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "bool", "long_jump", "=", "get_attr_length", "(", "insn", ")", ">=", "4", ";", "bool", "reverse", "=", "long_jump", "||", "jump_over_one_insn_p", "(", "insn", ",", "operands", "[", "3", "]", ")", ";", "if", "(", "comp", "==", "GE", ")", "comp", "=", "EQ", ";", "else", "if", "(", "comp", "==", "LT", ")", "comp", "=", "NE", ";", "if", "(", "reverse", ")", "comp", "=", "reverse_condition", "(", "comp", ")", ";", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CONST_INT", ":", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "if", "(", "low_io_address_operand", "(", "operands", "[", "1", "]", ",", "QImode", ")", ")", "{", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbis %i1,%2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbic %i1,%2\"", ",", "operands", ")", ";", "}", "else", "{", "gcc_assert", "(", "io_address_operand", "(", "operands", "[", "1", "]", ",", "QImode", ")", ")", ";", "output_asm_insn", "(", "\"in __tmp_reg__,%i1\"", ",", "operands", ")", ";", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbrs __tmp_reg__,%2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbrc __tmp_reg__,%2\"", ",", "operands", ")", ";", "}", "break", ";", "case", "REG", ":", "if", "(", "comp", "==", "EQ", ")", "output_asm_insn", "(", "\"sbrs %T1%T2\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"sbrc %T1%T2\"", ",", "operands", ")", ";", "break", ";", "}", "if", "(", "long_jump", ")", "return", "(", "\"rjmp .+4\"", "CR_TAB", "\"jmp %x3\"", ")", ";", "if", "(", "!", "reverse", ")", "return", "\"rjmp %x3\"", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "a", "branch", "that", "tests", "a", "single", "bit", "of", "a", "register", "(", "QI", ",", "HI", "or", "SImode", ")", "or", "memory", "location", "in", "the", "I/O", "space", "(", "QImode", "only", ")", ".", "Operand", "0", ":", "comparison", "operator", "(", "must", "be", "EQ", "or", "NE", ",", "compare", "bit", "to", "zero", ")", ".", "Operand", "1", ":", "register", "operand", "to", "test", ",", "or", "CONST_INT", "memory", "address", ".", "Operand", "2", ":", "bit", "number", "(", "for", "QImode", "operand", ")", "or", "mask", "(", "HImode", ",", "SImode", ")", ".", "Operand", "3", ":", "label", "to", "jump", "to", "if", "the", "test", "is", "true", "."], "TS_V_token": ["avr", "0", "4", "3", "1", "1", "\"sbis %i1,%2\"", "\"sbic %i1,%2\"", "1", "\"in __tmp_reg__,%i1\"", "\"sbrs __tmp_reg__,%2\"", "\"sbrc __tmp_reg__,%2\"", "\"sbrs %T1%T2\"", "\"sbrc %T1%T2\"", "\"rjmp .+4\"", "\"jmp %x3\"", "\"rjmp %x3\"", "\"\""], "File": "avr", "Func": "avr_out_sbxx_branch", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30618, "Length": 241}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_sign_extend", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "xop", ",", "int", "*", "plen", ")", "{", "unsigned", "n_src", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "xop", "[", "1", "]", ")", ")", ";", "unsigned", "n_dest", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "xop", "[", "0", "]", ")", ")", ";", "rtx", "r_msb", "=", "all_regs_rtx", "[", "REGNO", "(", "xop", "[", "1", "]", ")", "+", "n_src", "-", "1", "]", ";", "if", "(", "plen", ")", "*", "plen", "=", "0", ";", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "!=", "REGNO", "(", "xop", "[", "1", "]", ")", ")", "{", "gcc_assert", "(", "n_src", "<=", "2", ")", ";", "if", "(", "n_src", "==", "2", ")", "avr_asm_len", "(", "AVR_HAVE_MOVW", "?", "\"movw %0,%1\"", ":", "\"mov %B0,%B1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "if", "(", "n_src", "==", "1", "||", "!", "AVR_HAVE_MOVW", ")", "avr_asm_len", "(", "\"mov %A0,%A1\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "}", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "==", "REGNO", "(", "xop", "[", "1", "]", ")", "||", "!", "reg_unused_after", "(", "insn", ",", "r_msb", ")", ")", "{", "avr_asm_len", "(", "\"mov __tmp_reg__,%0\"", ",", "&", "r_msb", ",", "plen", ",", "1", ")", ";", "r_msb", "=", "tmp_reg_rtx", ";", "}", "avr_asm_len", "(", "\"lsl %0\"", ",", "&", "r_msb", ",", "plen", ",", "1", ")", ";", "for", "(", "unsigned", "n", "=", "n_src", ";", "n", "<", "n_dest", ";", "n", "++", ")", "avr_asm_len", "(", "\"sbc %0,%0\"", ",", "&", "all_regs_rtx", "[", "REGNO", "(", "xop", "[", "0", "]", ")", "+", "n", "]", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "sign", "extension", "from", "XOP", "[", "1", "]", "to", "XOP", "[", "0", "]", "and", "return", "``", "''", ".", "If", "PLEN", "==", "NULL", ",", "print", "assembler", "instructions", "to", "perform", "the", "operation", ";", "otherwise", ",", "set", "*", "PLEN", "to", "the", "length", "of", "the", "instruction", "sequence", "(", "in", "words", ")", "as", "printed", "with", "PLEN", "==", "NULL", "."], "TS_V_token": ["avr", "1", "0", "1", "1", "0", "0", "1", "2", "2", "\"movw %0,%1\"", "\"mov %B0,%B1\"", "1", "1", "\"mov %A0,%A1\"", "1", "0", "1", "\"mov __tmp_reg__,%0\"", "1", "\"lsl %0\"", "1", "\"sbc %0,%0\"", "0", "1", "\"\""], "File": "avr", "Func": "avr_out_sign_extend", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30619, "Length": 238}
{"ground_truth": ["<s>", "static", "const", "char", "*", "avr_out_store_psi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "int", "n_words", "=", "AVR_TINY", "?", "3", ":", "6", ";", "return", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", "CR_TAB", "\"sts %m0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "n_words", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_no_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "base", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"st %0+,%A1\"", "CR_TAB", "\"st %0+,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "\"sbiw r26,2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "else", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", "CR_TAB", "\"std %0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "if", "(", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "return", "avr_asm_len", "(", "\"adiw r28,%o0-61\"", "CR_TAB", "\"std Y+61,%A1\"", "CR_TAB", "\"std Y+62,%B1\"", "CR_TAB", "\"std Y+63,%C1\"", "CR_TAB", "\"sbiw r28,%o0-61\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "return", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"std Y+2,%C1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "7", ")", ";", "}", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "XEXP", "(", "base", ",", "0", ")", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X+,%B1\"", "CR_TAB", "\"st X,%C1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "\"sbiw r26,%o0+2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", "CR_TAB", "\"std %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "return", "avr_asm_len", "(", "\"st %0,%C1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Handle", "store", "of", "24-bit", "type", "from", "register", "or", "zero", "to", "memory", "."], "TS_V_token": ["avr", "0", "1", "0", "3", "6", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "\"sts %m0+2,%C1\"", "0", "\"st %0+,%A1\"", "\"st %0+,%B1\"", "\"st %0,%C1\"", "3", "\"sbiw r26,2\"", "1", "\"\"", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "\"std %0+2,%C1\"", "3", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-61\"", "\"std Y+61,%A1\"", "\"std Y+62,%B1\"", "\"std Y+63,%C1\"", "\"sbiw r28,%o0-61\"", "5", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"std Y+2,%C1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "7", "0", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X+,%B1\"", "\"st X,%C1\"", "4", "0", "\"sbiw r26,%o0+2\"", "1", "\"\"", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "\"std %C0,%C1\"", "3", "\"st %0,%C1\"", "\"st %0,%B1\"", "\"st %0,%A1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "\"st %0,%C1\"", "3", "\"unknown move insn:\"", "\"\""], "File": "avr", "Func": "avr_out_store_psi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30620, "Length": 478}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_tsthi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %B0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "test", "instruction", "for", "HImode", "."], "TS_V_token": ["avr", "\"tst %B0\"", "1", "0", "\"or %A0,%B0\"", "1", "\"\""], "File": "avr", "Func": "avr_out_tsthi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30621, "Length": 87}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_tstpsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %C0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", "CR_TAB", "\"or %A0,%C0\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "test", "instruction", "for", "PSImode", "."], "TS_V_token": ["avr", "\"tst %C0\"", "1", "0", "\"or %A0,%B0\"", "\"or %A0,%C0\"", "2", "\"\""], "File": "avr", "Func": "avr_out_tstpsi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30622, "Length": 89}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_tstsi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "if", "(", "compare_sign_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"tst %D0\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "if", "(", "reg_unused_after", "(", "insn", ",", "op", "[", "0", "]", ")", "&&", "compare_eq_p", "(", "insn", ")", ")", "{", "avr_asm_len", "(", "\"or %A0,%B0\"", "CR_TAB", "\"or %A0,%C0\"", "CR_TAB", "\"or %A0,%D0\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "{", "avr_out_compare", "(", "insn", ",", "op", ",", "plen", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Output", "test", "instruction", "for", "SImode", "."], "TS_V_token": ["avr", "\"tst %D0\"", "1", "0", "\"or %A0,%B0\"", "\"or %A0,%C0\"", "\"or %A0,%D0\"", "3", "\"\""], "File": "avr", "Func": "avr_out_tstsi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30623, "Length": 91}
{"ground_truth": ["<s>", "const", "char", "*", "avr_out_xload", "(", "rtx_insn", "*", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "1", "]", "=", "op", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "lpm_addr_reg_rtx", ";", "xop", "[", "3", "]", "=", "AVR_HAVE_LPMX", "?", "op", "[", "0", "]", ":", "lpm_reg_rtx", ";", "avr_asm_len", "(", "AVR_HAVE_LPMX", "?", "\"lpm %3,%a2\"", ":", "\"lpm\"", ",", "xop", ",", "plen", ",", "-", "1", ")", ";", "avr_asm_len", "(", "\"sbrc %1,7\"", "CR_TAB", "\"ld %3,%a2\"", ",", "xop", ",", "plen", ",", "2", ")", ";", "if", "(", "REGNO", "(", "xop", "[", "0", "]", ")", "!=", "REGNO", "(", "xop", "[", "3", "]", ")", ")", "avr_asm_len", "(", "\"mov %0,%3\"", ",", "xop", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "xload_8", "insn", "."], "TS_V_token": ["avr", "4", "0", "0", "1", "1", "2", "3", "0", "\"lpm %3,%a2\"", "\"lpm\"", "1", "\"sbrc %1,7\"", "\"ld %3,%a2\"", "2", "0", "3", "\"mov %0,%3\"", "1", "\"\""], "File": "avr", "Func": "avr_out_xload", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30624, "Length": 128}
{"ground_truth": ["<s>", "static", "rtx_insn", "*", "avr_parallel_insn_from_insns", "(", "rtx_insn", "*", "i", "[", "5", "]", ")", "{", "rtvec", "vec", "=", "gen_rtvec", "(", "5", ",", "PATTERN", "(", "i", "[", "0", "]", ")", ",", "PATTERN", "(", "i", "[", "1", "]", ")", ",", "PATTERN", "(", "i", "[", "2", "]", ")", ",", "PATTERN", "(", "i", "[", "3", "]", ")", ",", "PATTERN", "(", "i", "[", "4", "]", ")", ")", ";", "start_sequence", "(", ")", ";", "emit", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ")", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insn", ";", "}", "</s>"], "natrual_language": ["Make", "one", "parallel", "insn", "with", "all", "the", "patterns", "from", "insns", "i", "[", "0", "]", "..", "i", "[", "5", "]", "."], "TS_V_token": ["avr", "5", "5", "0", "1", "2", "3", "4"], "File": "avr", "Func": "avr_parallel_insn_from_insns", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30625, "Length": 91}
{"ground_truth": ["<s>", "static", "bool", "avr_pgm_check_var_decl", "(", "tree", "node", ")", "{", "const", "char", "*", "reason", "=", "NULL", ";", "addr_space_t", "as", "=", "ADDR_SPACE_GENERIC", ";", "gcc_assert", "(", "as", "==", "0", ")", ";", "if", "(", "avr_log", ".", "progmem", ")", "avr_edump", "(", "\"%?: %t\\n\"", ",", "node", ")", ";", "switch", "(", "TREE_CODE", "(", "node", ")", ")", "{", "default", ":", "break", ";", "case", "VAR_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"variable\"", ")", ";", "break", ";", "case", "PARM_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"function parameter\"", ")", ";", "break", ";", "case", "FIELD_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "node", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"structure field\"", ")", ";", "break", ";", "case", "FUNCTION_DECL", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "node", ")", ")", ")", ",", "as", ")", "reason", "=", "_", "(", "\"return type of function\"", ")", ";", "break", ";", "case", "POINTER_TYPE", ":", "if", "(", "as", "=", "avr_nonconst_pointer_addrspace", "(", "node", ")", ",", "as", ")", "reason", "=", "_", "(", "\"pointer\"", ")", ";", "break", ";", "}", "if", "(", "reason", ")", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "\"pointer targeting address space %qs must be const in %qT\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "node", ")", ";", "else", "error", "(", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\"", ",", "avr_addrspace", "[", "as", "]", ".", "name", ",", "reason", ",", "node", ")", ";", "}", "return", "reason", "==", "NULL", ";", "}", "</s>"], "natrual_language": ["Sanity", "check", "NODE", "so", "that", "all", "pointers", "targeting", "non-generic", "address", "spaces", "go", "along", "with", "CONST", "qualifier", ".", "Writing", "to", "these", "address", "spaces", "should", "be", "detected", "and", "complained", "about", "as", "early", "as", "possible", "."], "TS_V_token": ["avr", "0", "\"%?: %t\\n\"", "\"variable\"", "\"function parameter\"", "\"structure field\"", "\"return type of function\"", "\"pointer\"", "\"pointer targeting address space %qs must be const in %qT\"", "\"pointer targeting address space %qs must be const\"", "\" in %s %q+D\""], "File": "avr", "Func": "avr_pgm_check_var_decl", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30626, "Length": 234}
{"ground_truth": ["<s>", "bool", "avr_popcount_each_byte", "(", "rtx", "xval", ",", "int", "n_bytes", ",", "int", "pop_mask", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "xval", ")", ";", "if", "(", "VOIDmode", "==", "mode", ")", "mode", "=", "SImode", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n_bytes", ";", "i", "++", ")", "{", "rtx", "xval8", "=", "simplify_gen_subreg", "(", "QImode", ",", "xval", ",", "mode", ",", "i", ")", ";", "unsigned", "int", "val8", "=", "UINTVAL", "(", "xval8", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "if", "(", "(", "pop_mask", "&", "(", "1", "<<", "popcount_hwi", "(", "val8", ")", ")", ")", "==", "0", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Constraint", "helper", "function", ".", "XVAL", "is", "a", "CONST_INT", "or", "a", "CONST_DOUBLE", ".", "Return", "true", "if", "the", "least", "significant", "N_BYTES", "bytes", "of", "XVAL", "all", "have", "a", "popcount", "in", "POP_MASK", "and", "false", ",", "otherwise", ".", "POP_MASK", "represents", "a", "subset", "of", "integers", "which", "contains", "an", "integer", "N", "iff", "bit", "N", "of", "POP_MASK", "is", "set", "."], "TS_V_token": ["avr", "0", "1", "0"], "File": "avr", "Func": "avr_popcount_each_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30627, "Length": 99}
{"ground_truth": ["<s>", "static", "void", "avr_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "if", "(", "AVR_TINY", "&&", "avr_address_tiny_pm_p", "(", "addr", ")", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "addr", ",", "avr_arch", "->", "flash_pm_offset", ")", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "addr", ")", ")", ")", ";", "break", ";", "case", "PRE_DEC", ":", "fprintf", "(", "file", ",", "\"-%s\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "case", "POST_INC", ":", "fprintf", "(", "file", ",", "\"%s+\"", ",", "ptrreg_to_str", "(", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_ADDRESS_P", "(", "addr", ")", "&&", "text_segment_operand", "(", "addr", ",", "VOIDmode", ")", ")", "{", "rtx", "x", "=", "addr", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", "\")\"", ",", "2", "*", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ";", "if", "(", "AVR_3_BYTE_PC", ")", "if", "(", "warning", "(", "0", ",", "\"pointer offset from symbol maybe incorrect\"", ")", ")", "{", "output_addr_const", "(", "stderr", ",", "addr", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "}", "}", "else", "{", "fprintf", "(", "file", ",", "\"gs(\"", ")", ";", "output_addr_const", "(", "file", ",", "addr", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "}", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "}", "}", "</s>"], "natrual_language": ["Output", "ADDR", "to", "FILE", "as", "address", "."], "TS_V_token": ["avr", "\"%s\"", "\"-%s\"", "0", "\"%s+\"", "0", "0", "1", "\"gs(\"", "0", "\"+\"", "\")\"", "2", "1", "0", "\"pointer offset from symbol maybe incorrect\"", "\"\\n\"", "\"gs(\"", "\")\""], "File": "avr", "Func": "avr_print_operand_address", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30628, "Length": 281}
{"ground_truth": ["<s>", "static", "bool", "avr_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "code", "==", "'~'", "||", "code", "==", "'!'", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_print_operand_punct_valid_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30629, "Length": 19}
{"ground_truth": ["<s>", "int", "avr_progmem_p", "(", "tree", "decl", ",", "tree", "attributes", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "0", ";", "if", "(", "avr_decl_memx_p", "(", "decl", ")", ")", "return", "2", ";", "if", "(", "avr_decl_flash_p", "(", "decl", ")", ")", "return", "1", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "attributes", ")", ")", "return", "-", "1", ";", "a", "=", "decl", ";", "do", "a", "=", "TREE_TYPE", "(", "a", ")", ";", "while", "(", "TREE_CODE", "(", "a", ")", "==", "ARRAY_TYPE", ")", ";", "if", "(", "a", "==", "error_mark_node", ")", "return", "0", ";", "if", "(", "NULL_TREE", "!=", "lookup_attribute", "(", "\"progmem\"", ",", "TYPE_ATTRIBUTES", "(", "a", ")", ")", ")", "return", "-", "1", ";", "return", "0", ";", "}", "</s>"], "natrual_language": ["Look", "for", "attribute", "`", "progmem", "'", "in", "DECL", "if", "found", "return", "1", ",", "otherwise", "0", "."], "TS_V_token": ["avr", "0", "2", "1", "\"progmem\"", "1", "0", "\"progmem\"", "1", "0"], "File": "avr", "Func": "avr_progmem_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30630, "Length": 113}
{"ground_truth": ["<s>", "static", "int", "avr_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "return", "(", "from", "==", "STACK_REG", "?", "6", ":", "to", "==", "STACK_REG", "?", "12", ":", "2", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_REGISTER_MOVE_COST", "'"], "TS_V_token": ["avr", "6", "12", "2"], "File": "avr", "Func": "avr_register_move_cost", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30631, "Length": 33}
{"ground_truth": ["<s>", "bool", "avr_regno_mode_code_ok_for_base_p", "(", "int", "regno", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "RTX_CODE", "outer_code", ",", "RTX_CODE", "index_code", "ATTRIBUTE_UNUSED", ")", "{", "bool", "ok", "=", "false", ";", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "if", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "regno", "==", "REG_Z", ")", "{", "return", "true", ";", "}", "if", "(", "reg_renumber", ")", "{", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "==", "REG_Z", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "if", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "(", "regno", "==", "REG_X", "||", "regno", "==", "REG_Y", "||", "regno", "==", "REG_Z", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", ")", "{", "ok", "=", "true", ";", "}", "else", "if", "(", "reg_renumber", ")", "{", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "==", "REG_X", "||", "regno", "==", "REG_Y", "||", "regno", "==", "REG_Z", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "{", "ok", "=", "true", ";", "}", "}", "if", "(", "avr_strict_X", "&&", "PLUS", "==", "outer_code", "&&", "regno", "==", "REG_X", ")", "{", "ok", "=", "false", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "REGNO_MODE_CODE_OK_FOR_BASE_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_regno_mode_code_ok_for_base_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30632, "Length": 169}
{"ground_truth": ["<s>", "enum", "reg_class", "avr_regno_reg_class", "(", "int", "r", ")", "{", "static", "const", "enum", "reg_class", "reg_class_tab", "[", "]", "=", "{", "R0_REG", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "NO_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "SIMPLE_LD_REGS", ",", "ADDW_REGS", ",", "ADDW_REGS", ",", "POINTER_X_REGS", ",", "POINTER_X_REGS", ",", "POINTER_Y_REGS", ",", "POINTER_Y_REGS", ",", "POINTER_Z_REGS", ",", "POINTER_Z_REGS", ",", "STACK_REG", ",", "STACK_REG", "}", ";", "if", "(", "r", "<=", "33", ")", "return", "reg_class_tab", "[", "r", "]", ";", "if", "(", "r", "==", "REG_CC", ")", "return", "CC_REG", ";", "return", "ALL_REGS", ";", "}", "</s>"], "natrual_language": ["Return", "register", "class", "for", "register", "R"], "TS_V_token": ["avr", "33"], "File": "avr", "Func": "avr_regno_reg_class", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30633, "Length": 111}
{"ground_truth": ["<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "count", ";", "int", "int_or_sig_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", "return", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "||", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "(", "int_or_sig_p", "||", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>"], "natrual_language": ["Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "."], "TS_V_token": ["avr", "0", "0", "0", "32", "1"], "File": "avr", "Func": "avr_regs_to_save", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30634, "Length": 159}
{"ground_truth": ["<s>", "static", "inline", "bool", "avr_reg_ok_for_addr_p", "(", "rtx", "reg", ",", "addr_space_t", "as", ",", "RTX_CODE", "outer_code", ",", "bool", "strict", ")", "{", "return", "(", "REG_P", "(", "reg", ")", "&&", "(", "avr_regno_mode_code_ok_for_base_p", "(", "REGNO", "(", "reg", ")", ",", "QImode", ",", "as", ",", "outer_code", ",", "UNKNOWN", ")", "||", "(", "!", "strict", "&&", "REGNO", "(", "reg", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "function", "for", "`", "avr_legitimate_address_p", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_reg_ok_for_addr_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30635, "Length": 57}
{"ground_truth": ["<s>", "static", "bool", "avr_reg_ok_for_pgm_addr", "(", "rtx", "reg", ",", "bool", "strict", ")", "{", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "if", "(", "strict", ")", "{", "return", "REGNO", "(", "reg", ")", "==", "REG_Z", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "REGNO", "(", "reg", ")", "<", "REG_Z", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "following", "function", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_reg_ok_for_pgm_addr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30636, "Length": 55}
{"ground_truth": ["<s>", "static", "void", "avr_reorg", "(", "void", ")", "{", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "for", "(", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "insn", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "avr_compare_pattern", "(", "insn", ")", ";", "if", "(", "!", "pattern", ")", "continue", ";", "if", "(", "optimize", "&&", "avr_reorg_remove_redundant_compare", "(", "insn", ")", ")", "{", "continue", ";", "}", "if", "(", "compare_diff_p", "(", "insn", ")", ")", "{", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "insn", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "true_regnum", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ">=", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "x", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "XEXP", "(", "pattern", ",", "1", ")", "==", "const0_rtx", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "PUT_CODE", "(", "t", ",", "swap_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "XEXP", "(", "pattern", ",", "1", ")", "=", "XEXP", "(", "pattern", ",", "0", ")", ";", "XEXP", "(", "pattern", ",", "0", ")", "=", "const0_rtx", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "else", "if", "(", "true_regnum", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ">=", "0", "&&", "CONST_INT_P", "(", "XEXP", "(", "pattern", ",", "1", ")", ")", ")", "{", "rtx", "x", "=", "XEXP", "(", "pattern", ",", "1", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "rtx", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", ";", "if", "(", "avr_simplify_comparison_p", "(", "mode", ",", "GET_CODE", "(", "t", ")", ",", "x", ")", ")", "{", "XEXP", "(", "pattern", ",", "1", ")", "=", "gen_int_mode", "(", "INTVAL", "(", "x", ")", "+", "1", ",", "mode", ")", ";", "PUT_CODE", "(", "t", ",", "avr_normalize_condition", "(", "GET_CODE", "(", "t", ")", ")", ")", ";", "INSN_CODE", "(", "next", ")", "=", "-", "1", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "}", "}", "</s>"], "natrual_language": ["This", "function", "optimizes", "conditional", "jumps", "."], "TS_V_token": ["avr", "0", "0", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "1", "0", "0", "1", "1", "1", "1"], "File": "avr", "Func": "avr_reorg", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30637, "Length": 445}
{"ground_truth": ["<s>", "rtx", "avr_return_addr_rtx", "(", "int", "count", ",", "rtx", "tem", ")", "{", "rtx", "r", ";", "if", "(", "count", ")", "return", "NULL", ";", "if", "(", "AVR_3_BYTE_PC", ")", "{", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+2\"", ")", ";", "warning", "(", "0", ",", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", ")", ";", "}", "else", "r", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\".L__stack_usage+1\"", ")", ";", "cfun", "->", "machine", "->", "use_L__stack_usage", "=", "1", ";", "r", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tem", ",", "r", ")", ";", "r", "=", "gen_frame_mem", "(", "Pmode", ",", "memory_address", "(", "Pmode", ",", "r", ")", ")", ";", "r", "=", "gen_rtx_ROTATE", "(", "HImode", ",", "r", ",", "GEN_INT", "(", "8", ")", ")", ";", "return", "r", ";", "}", "</s>"], "natrual_language": ["Return", "contents", "of", "MEM", "at", "frame", "pointer", "+", "stack", "size", "+", "1", "(", "+2", "if", "3-byte", "PC", ")", ".", "This", "is", "return", "address", "of", "function", "."], "TS_V_token": ["avr", "\".L__stack_usage+2\"", "0", "\"%<builtin_return_address%> contains only 2 bytes\"", "\" of address\"", "\".L__stack_usage+1\"", "1", "8"], "File": "avr", "Func": "avr_return_addr_rtx", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30638, "Length": 104}
{"ground_truth": ["<s>", "static", "bool", "avr_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "HOST_WIDE_INT", "ret_size_limit", "=", "AVR_TINY", "?", "4", ":", "8", ";", "if", "(", "size", "==", "-", "1", "||", "size", ">", "ret_size_limit", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "</s>"], "natrual_language": ["Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "."], "TS_V_token": ["avr", "4", "8", "1"], "File": "avr", "Func": "avr_return_in_memory", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30639, "Length": 52}
{"ground_truth": ["<s>", "static", "inline", "unsigned", "int", "avr_ret_register", "(", "void", ")", "{", "return", "24", ";", "}", "</s>"], "natrual_language": ["Returns", "register", "number", "for", "function", "return", "value", "."], "TS_V_token": ["avr", "24"], "File": "avr", "Func": "avr_ret_register", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30640, "Length": 13}
{"ground_truth": ["<s>", "static", "bool", "avr_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "done", "=", "avr_rtx_costs_1", "(", "x", ",", "mode", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "avr_edump", "(", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", ",", "done", ",", "speed", "?", "\"speed\"", ":", "\"size\"", ",", "*", "total", ",", "outer_code", ",", "x", ")", ";", "}", "return", "done", ";", "}", "</s>"], "natrual_language": ["The", "AVR", "backend", "'s", "rtx_cost", "function", ".", "X", "is", "rtx", "expression", "whose", "cost", "is", "to", "be", "calculated", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "."], "TS_V_token": ["avr", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", "\"speed\"", "\"size\""], "File": "avr", "Func": "avr_rtx_costs", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30641, "Length": 74}
{"ground_truth": ["<s>", "static", "bool", "avr_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "PSImode", "==", "mode", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_SCALAR_MODE_SUPPORTED_P", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_scalar_mode_supported_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30642, "Length": 34}
{"ground_truth": ["<s>", "static", "unsigned", "int", "avr_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "startswith", "(", "name", ",", "\".noinit\"", ")", ")", "{", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_INITIAL", "(", "decl", ")", "==", "NULL_TREE", ")", "flags", "|=", "SECTION_BSS", ";", "else", "warning", "(", "0", ",", "\"only uninitialized variables can be placed in the \"", "\"%<.noinit%> section\"", ")", ";", "}", "if", "(", "decl", "&&", "DECL_P", "(", "decl", ")", "&&", "avr_progmem_p", "(", "decl", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "{", "addr_space_t", "as", "=", "TYPE_ADDR_SPACE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "as", "=", "ADDR_SPACE_FLASH", ";", "flags", "|=", "as", "*", "SECTION_MACH_DEP", ";", "flags", "&=", "~", "SECTION_WRITE", ";", "flags", "&=", "~", "SECTION_BSS", ";", "}", "return", "flags", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_SECTION_TYPE_FLAGS", "'", "."], "TS_V_token": ["avr", "\".noinit\"", "0", "\"only uninitialized variables can be placed in the \"", "\"%<.noinit%> section\""], "File": "avr", "Func": "avr_section_type_flags", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30643, "Length": 135}
{"ground_truth": ["<s>", "static", "bool", "avr_set_core_architecture", "(", "void", ")", "{", "if", "(", "!", "avr_mmcu", ")", "avr_mmcu", "=", "AVR_MMCU_DEFAULT", ";", "avr_arch", "=", "&", "avr_arch_types", "[", "0", "]", ";", "for", "(", "const", "avr_mcu_t", "*", "mcu", "=", "avr_mcu_types", ";", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "name", "==", "NULL", ")", "{", "error", "(", "\"unknown core architecture %qs specified with %qs\"", ",", "avr_mmcu", ",", "\"-mmcu=\"", ")", ";", "avr_inform_core_architectures", "(", ")", ";", "break", ";", "}", "else", "if", "(", "strcmp", "(", "mcu", "->", "name", ",", "avr_mmcu", ")", "==", "0", "&&", "mcu", "->", "macro", "==", "NULL", ")", "{", "avr_arch", "=", "&", "avr_arch_types", "[", "mcu", "->", "arch_id", "]", ";", "if", "(", "avr_n_flash", "<", "0", ")", "avr_n_flash", "=", "1", "+", "(", "mcu", "->", "flash_size", "-", "1", ")", "/", "0x10000", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>"], "natrual_language": ["Set", "`", "avr_arch", "'", "as", "specified", "by", "`", "-mmcu=", "'", ".", "Return", "true", "on", "success", "."], "TS_V_token": ["avr", "0", "\"unknown core architecture %qs specified with %qs\"", "\"-mmcu=\"", "0", "0", "1", "1", "0x10000"], "File": "avr", "Func": "avr_set_core_architecture", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30644, "Length": 123}
{"ground_truth": ["<s>", "static", "void", "avr_set_current_function", "(", "tree", "decl", ")", "{", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "location_t", "loc", "=", "DECL_SOURCE_LOCATION", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_naked", "=", "avr_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_signal", "=", "avr_signal_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_interrupt", "=", "avr_interrupt_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_task", "=", "avr_OS_task_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_OS_main", "=", "avr_OS_main_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "is_no_gccisr", "=", "avr_no_gccisr_function_p", "(", "decl", ")", ";", "const", "char", "*", "isr", "=", "cfun", "->", "machine", "->", "is_interrupt", "?", "\"interrupt\"", ":", "\"signal\"", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_task", "&&", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ")", "error_at", "(", "loc", ",", "\"function attributes %qs and %qs are mutually exclusive\"", ",", "\"OS_task\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_OS_main", "&&", "(", "cfun", "->", "machine", "->", "is_signal", "||", "cfun", "->", "machine", "->", "is_interrupt", ")", ")", "error_at", "(", "loc", ",", "\"function attributes %qs and %qs are mutually exclusive\"", ",", "\"OS_main\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ")", "{", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "const", "char", "*", "name", ";", "name", "=", "DECL_ASSEMBLER_NAME_SET_P", "(", "decl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ":", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot have arguments\"", ",", "isr", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error_at", "(", "loc", ",", "\"%qs function cannot return a value\"", ",", "isr", ")", ";", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "cfun", "->", "machine", "->", "is_signal", "=", "0", ";", "if", "(", "!", "startswith", "(", "name", ",", "\"__vector\"", ")", ")", "warning_at", "(", "loc", ",", "OPT_Wmisspelled_isr", ",", "\"%qs appears to be a misspelled \"", "\"%qs handler, missing %<__vector%> prefix\"", ",", "name", ",", "isr", ")", ";", "}", "const", "char", "*", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "strcmp", "(", "\"ISR\"", ",", "name", ")", "==", "0", "||", "strcmp", "(", "\"INTERRUPT\"", ",", "name", ")", "==", "0", "||", "strcmp", "(", "\"SIGNAL\"", ",", "name", ")", "==", "0", ")", "{", "warning_at", "(", "loc", ",", "OPT_Wmisspelled_isr", ",", "\"%qs is a reserved identifier\"", "\" in AVR-LibC.  Consider %<#include <avr/interrupt.h>%>\"", "\" before using the %qs macro\"", ",", "name", ",", "name", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>"], "natrual_language": ["Sanity", "cheching", "for", "above", "function", "attributes", "."], "TS_V_token": ["avr", "\"interrupt\"", "\"signal\"", "\"function attributes %qs and %qs are mutually exclusive\"", "\"OS_task\"", "\"function attributes %qs and %qs are mutually exclusive\"", "\"OS_main\"", "\"%qs function cannot have arguments\"", "\"%qs function cannot return a value\"", "0", "\"__vector\"", "\"%qs appears to be a misspelled \"", "\"%qs handler, missing %<__vector%> prefix\"", "\"ISR\"", "0", "\"INTERRUPT\"", "0", "\"SIGNAL\"", "0", "\"%qs is a reserved identifier\"", "\" in AVR-LibC.  Consider %<#include <avr/interrupt.h>%>\"", "\" before using the %qs macro\"", "1"], "File": "avr", "Func": "avr_set_current_function", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30645, "Length": 419}
{"ground_truth": ["<s>", "static", "int", "avr_signal_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "\"signal\"", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "FUNC", "is", "a", "signal", "function", "as", "specified", "by", "the", "``", "signal", "''", "attribute", "."], "TS_V_token": ["avr", "\"signal\""], "File": "avr", "Func": "avr_signal_function_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30646, "Length": 17}
{"ground_truth": ["<s>", "int", "avr_simple_epilogue", "(", "void", ")", "{", "return", "(", "!", "frame_pointer_needed", "&&", "get_frame_size", "(", ")", "==", "0", "&&", "avr_outgoing_args_size", "(", ")", "==", "0", "&&", "avr_regs_to_save", "(", "NULL", ")", "==", "0", "&&", "!", "cfun", "->", "machine", "->", "is_interrupt", "&&", "!", "cfun", "->", "machine", "->", "is_signal", "&&", "!", "cfun", "->", "machine", "->", "is_naked", "&&", "!", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "1", "if", "the", "function", "epilogue", "is", "just", "a", "single", "``", "ret", "''", "."], "TS_V_token": ["avr", "0", "0", "0"], "File": "avr", "Func": "avr_simple_epilogue", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30647, "Length": 59}
{"ground_truth": ["<s>", "int", "avr_simplify_comparison_p", "(", "machine_mode", "mode", ",", "RTX_CODE", "op", ",", "rtx", "x", ")", "{", "unsigned", "int", "max", "=", "(", "mode", "==", "QImode", "?", "0xff", ":", "mode", "==", "HImode", "?", "0xffff", ":", "mode", "==", "PSImode", "?", "0xffffff", ":", "mode", "==", "SImode", "?", "0xffffffff", ":", "0", ")", ";", "if", "(", "max", "&&", "op", "&&", "CONST_INT_P", "(", "x", ")", ")", "{", "if", "(", "unsigned_condition", "(", "op", ")", "!=", "op", ")", "max", ">>=", "1", ";", "if", "(", "max", "!=", "(", "INTVAL", "(", "x", ")", "&", "max", ")", "&&", "INTVAL", "(", "x", ")", "!=", "0xff", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Return", "0", "if", "undefined", ",", "1", "if", "always", "true", "or", "always", "false", "."], "TS_V_token": ["avr", "0xff", "0xffff", "0xffffff", "0xffffffff", "0", "1", "0xff", "1", "0"], "File": "avr", "Func": "avr_simplify_comparison_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30648, "Length": 98}
{"ground_truth": ["<s>", "static", "HOST_WIDE_INT", "avr_starting_frame_offset", "(", "void", ")", "{", "return", "1", "+", "avr_outgoing_args_size", "(", ")", ";", "}", "</s>"], "natrual_language": ["This", "is", "the", "offset", "from", "the", "frame", "pointer", "register", "to", "the", "first", "stack", "slot", "that", "contains", "a", "variable", "living", "in", "the", "frame", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "avr_starting_frame_offset", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30649, "Length": 15}
{"ground_truth": ["<s>", "static", "char", "*", "avr_tolower", "(", "char", "*", "lo", ",", "const", "char", "*", "up", ")", "{", "char", "*", "lo0", "=", "lo", ";", "for", "(", ";", "*", "up", ";", "up", "++", ",", "lo", "++", ")", "*", "lo", "=", "TOLOWER", "(", "*", "up", ")", ";", "*", "lo", "=", "'\\0'", ";", "return", "lo0", ";", "}", "</s>"], "natrual_language": ["Transform", "UP", "into", "lowercase", "and", "write", "the", "result", "to", "LO", ".", "You", "must", "provide", "enough", "space", "for", "LO", ".", "Return", "LO", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_tolower", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30650, "Length": 51}
{"ground_truth": ["<s>", "rtx", "avr_to_int_mode", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "return", "VOIDmode", "==", "mode", "?", "x", ":", "simplify_gen_subreg", "(", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ",", "x", ",", "mode", ",", "0", ")", ";", "}", "</s>"], "natrual_language": ["Access", "some", "RTX", "as", "INT_MODE", ".", "If", "X", "is", "a", "CONST_FIXED", "we", "can", "get", "the", "bit", "representation", "of", "X", "by", "``", "casting", "''", "it", "to", "CONST_INT", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "avr_to_int_mode", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30651, "Length": 41}
{"ground_truth": ["<s>", "static", "bool", "avr_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", "ATTRIBUTE_UNUSED", ",", "enum", "by_pieces_operation", "op", ",", "bool", "speed_p", ")", "{", "if", "(", "op", "!=", "MOVE_BY_PIECES", "||", "(", "speed_p", "&&", "size", ">", "MOVE_MAX_PIECES", ")", ")", "return", "default_use_by_pieces_infrastructure_p", "(", "size", ",", "align", ",", "op", ",", "speed_p", ")", ";", "return", "size", "<=", "MOVE_MAX_PIECES", ";", "}", "</s>"], "natrual_language": ["Prefer", "sequence", "of", "loads/stores", "for", "moves", "of", "size", "upto", "two", "-", "two", "pairs", "of", "load/store", "instructions", "are", "always", "better", "than", "the", "5", "instruction", "sequence", "for", "a", "loop", "(", "1", "instruction", "for", "loop", "counter", "setup", ",", "and", "4", "for", "the", "body", "of", "the", "loop", ")", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_use_by_pieces_infrastructure_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30652, "Length": 53}
{"ground_truth": ["<s>", "static", "bool", "avr_warn_func_return", "(", "tree", "decl", ")", "{", "return", "!", "avr_naked_function_p", "(", "decl", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "`", "TARGET_WARN_FUNC_RETURN", "'", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "avr_warn_func_return", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30653, "Length": 16}
{"ground_truth": ["<s>", "bool", "avr_xload_libgcc_p", "(", "machine_mode", "mode", ")", "{", "int", "n_bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "n_bytes", ">", "1", "||", "avr_n_flash", ">", "1", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "if", "a", "value", "of", "mode", "MODE", "is", "read", "by", "__xload_", "*", "function", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr", "Func": "avr_xload_libgcc_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30654, "Length": 27}
{"ground_truth": ["<s>", "static", "RTX_CODE", "compare_condition", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "next", "&&", "JUMP_P", "(", "next", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "IF_THEN_ELSE", "==", "GET_CODE", "(", "src", ")", ")", "return", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", ";", "}", "return", "UNKNOWN", ";", "}", "</s>"], "natrual_language": ["Returns", "the", "condition", "of", "compare", "insn", "INSN", ",", "or", "UNKNOWN", "."], "TS_V_token": ["avr", "0", "0", "0"], "File": "avr", "Func": "compare_condition", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30655, "Length": 89}
{"ground_truth": ["<s>", "static", "bool", "compare_diff_p", "(", "rtx_insn", "*", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GT", "||", "cond", "==", "GTU", "||", "cond", "==", "LE", "||", "cond", "==", "LEU", ")", "?", "cond", ":", "0", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "the", "next", "insn", "is", "a", "JUMP_INSN", "with", "a", "condition", "that", "needs", "to", "be", "swapped", "(", "GT", ",", "GTU", ",", "LE", ",", "LEU", ")", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "compare_diff_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30656, "Length": 41}
{"ground_truth": ["<s>", "static", "bool", "compare_eq_p", "(", "rtx_insn", "*", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "EQ", "||", "cond", "==", "NE", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "INSN", "is", "a", "compare", "insn", "with", "the", "EQ", "or", "NE", "condition", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "compare_eq_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30657, "Length": 29}
{"ground_truth": ["<s>", "static", "bool", "compare_sign_p", "(", "rtx_insn", "*", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GE", "||", "cond", "==", "LT", ")", ";", "}", "</s>"], "natrual_language": ["Returns", "nonzero", "if", "INSN", "is", "a", "tst", "insn", "that", "only", "tests", "the", "sign", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "compare_sign_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30658, "Length": 29}
{"ground_truth": ["<s>", "void", "avr_pass_pre_proep", "::", "compute_maybe_gasisr", "(", "function", "*", "fun", ")", "{", "for", "(", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", ";", "if", "(", "AVR_HAVE_JMP_CALL", "&&", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "return", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "find_reg_note", "(", "insn", ",", "REG_NON_LOCAL_GOTO", ",", "NULL_RTX", ")", ")", "return", ";", "}", "fun", "->", "machine", "->", "gasisr", ".", "maybe", "=", "1", ";", "}", "</s>"], "natrual_language": ["Set", "fun-", ">", "machine-", ">", "gasisr.maybe", "provided", "we", "do", "n't", "find", "anything", "that", "prohibits", "GAS", "generating", "parts", "of", "ISR", "prologues", "/", "epilogues", "for", "us", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "compute_maybe_gasisr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30659, "Length": 80}
{"ground_truth": ["<s>", "static", "const", "char", "*", "cond_string", "(", "enum", "rtx_code", "code", ")", "{", "bool", "cc_overflow_unusable", "=", "false", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "\"ne\"", ";", "case", "EQ", ":", "return", "\"eq\"", ";", "case", "GE", ":", "if", "(", "cc_overflow_unusable", ")", "return", "\"pl\"", ";", "else", "return", "\"ge\"", ";", "case", "LT", ":", "if", "(", "cc_overflow_unusable", ")", "return", "\"mi\"", ";", "else", "return", "\"lt\"", ";", "case", "GEU", ":", "return", "\"sh\"", ";", "case", "LTU", ":", "return", "\"lo\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Return", "assembly", "language", "string", "which", "identifies", "a", "comparison", "type", "."], "TS_V_token": ["avr", "\"ne\"", "\"eq\"", "\"pl\"", "\"ge\"", "\"mi\"", "\"lt\"", "\"sh\"", "\"lo\"", "\"\""], "File": "avr", "Func": "cond_string", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30660, "Length": 84}
{"ground_truth": ["<s>", "static", "void", "emit_pop_byte", "(", "unsigned", "regno", ")", "{", "rtx", "mem", ",", "reg", ";", "mem", "=", "gen_rtx_PRE_INC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "avr_expand_epilogue", ".", "Emit", "a", "pop", "of", "a", "byte", "register", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "emit_pop_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30661, "Length": 51}
{"ground_truth": ["<s>", "static", "void", "emit_push_byte", "(", "unsigned", "regno", ",", "bool", "frame_related_p", ")", "{", "rtx", "mem", ",", "reg", ";", "rtx_insn", "*", "insn", ";", "mem", "=", "gen_rtx_POST_DEC", "(", "HImode", ",", "stack_pointer_rtx", ")", ";", "mem", "=", "gen_frame_mem", "(", "QImode", ",", "mem", ")", ";", "reg", "=", "gen_rtx_REG", "(", "QImode", ",", "regno", ")", ";", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfun", "->", "machine", "->", "stack_usage", "++", ";", "}", "</s>"], "natrual_language": ["Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "byte", "register", "."], "TS_V_token": ["avr", "1"], "File": "avr", "Func": "emit_push_byte", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30662, "Length": 78}
{"ground_truth": ["<s>", "static", "void", "emit_push_sfr", "(", "rtx", "sfr", ",", "bool", "frame_related_p", ",", "bool", "clr_p", ",", "int", "treg", ")", "{", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "MEM_P", "(", "sfr", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "all_regs_rtx", "[", "treg", "]", ",", "sfr", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_push_byte", "(", "treg", ",", "frame_related_p", ")", ";", "if", "(", "clr_p", ")", "{", "insn", "=", "emit_move_insn", "(", "sfr", ",", "const0_rtx", ")", ";", "if", "(", "frame_related_p", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>"], "natrual_language": ["Helper", "for", "expand_prologue", ".", "Emit", "a", "push", "of", "a", "SFR", "via", "tmp_reg", ".", "SFR", "is", "a", "MEM", "representing", "the", "memory", "location", "of", "the", "SFR", ".", "If", "CLR_P", "then", "clear", "the", "SFR", "after", "the", "push", "using", "zero_reg", "."], "TS_V_token": ["avr", "1", "1"], "File": "avr", "Func": "emit_push_sfr", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30663, "Length": 86}
{"ground_truth": ["<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", "fun", ")", "{", "if", "(", "avr_gasisr_prologues", "&&", "!", "fun", "->", "machine", "->", "is_no_gccisr", "&&", "(", "fun", "->", "machine", "->", "is_interrupt", "||", "fun", "->", "machine", "->", "is_signal", ")", "&&", "!", "cfun", "->", "machine", "->", "is_naked", "&&", "!", "cfun", "->", "calls_setjmp", "&&", "!", "cfun", "->", "has_nonlocal_label", "&&", "!", "cfun", "->", "has_forced_label_in_static", ")", "{", "compute_maybe_gasisr", "(", "fun", ")", ";", "}", "return", "0", ";", "}", "</s>"], "natrual_language": ["Main", "entry", "point", "for", "this", "pass", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "execute", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30664, "Length": 68}
{"ground_truth": ["<s>", "int", "extra_constraint_Q", "(", "rtx", "x", ")", "{", "int", "ok", "=", "0", ";", "rtx", "plus", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "plus", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "plus", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "plus", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "plus", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "ok", "=", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", "||", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", ";", "if", "(", "avr_log", ".", "constraints", ")", "avr_edump", "(", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"", ",", "ok", ",", "reload_completed", ",", "reload_in_progress", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>"], "natrual_language": ["Test", "for", "extra", "memory", "constraint", "'", "Q", "'", ".", "It", "'s", "a", "memory", "address", "based", "on", "Y", "or", "Z", "pointer", "with", "valid", "displacement", "."], "TS_V_token": ["avr", "0", "0", "0", "1", "1", "0", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\""], "File": "avr", "Func": "extra_constraint_Q", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30665, "Length": 138}
{"ground_truth": ["<s>", "int", "get_sequence_length", "(", "rtx_insn", "*", "insns", ")", "{", "int", "length", "=", "0", ";", "for", "(", "rtx_insn", "*", "insn", "=", "insns", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "length", "+=", "get_attr_length", "(", "insn", ")", ";", "return", "length", ";", "}", "</s>"], "natrual_language": ["Obtain", "the", "length", "sequence", "of", "insns", "."], "TS_V_token": ["avr", "0"], "File": "avr", "Func": "get_sequence_length", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30666, "Length": 41}
{"ground_truth": ["<s>", "const", "char", "*", "lshrqi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "8", ")", "break", ";", "*", "len", "=", "1", ";", "return", "\"clr %0\"", ";", "case", "1", ":", "*", "len", "=", "1", ";", "return", "\"lsr %0\"", ";", "case", "2", ":", "*", "len", "=", "2", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "3", ":", "*", "len", "=", "3", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "4", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "2", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"andi %0,0x0f\"", ")", ";", "}", "*", "len", "=", "4", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "5", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "3", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x7\"", ")", ";", "}", "*", "len", "=", "5", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "6", ":", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ")", "{", "*", "len", "=", "4", ";", "return", "(", "\"swap %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"andi %0,0x3\"", ")", ";", "}", "*", "len", "=", "6", ";", "return", "(", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", "CR_TAB", "\"lsr %0\"", ")", ";", "case", "7", ":", "*", "len", "=", "3", ";", "return", "(", "\"rol %0\"", "CR_TAB", "\"clr %0\"", "CR_TAB", "\"rol %0\"", ")", ";", "}", "}", "else", "if", "(", "CONSTANT_P", "(", "operands", "[", "2", "]", ")", ")", "fatal_insn", "(", "\"internal compiler error.  Incorrect shift:\"", ",", "insn", ")", ";", "out_shift_with_cnt", "(", "\"lsr %0\"", ",", "insn", ",", "operands", ",", "len", ",", "1", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["8bit", "logic", "shift", "right", "(", "(", "unsigned", "char", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "8", "1", "\"clr %0\"", "1", "1", "\"lsr %0\"", "2", "2", "\"lsr %0\"", "\"lsr %0\"", "3", "3", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "4", "0", "2", "\"swap %0\"", "\"andi %0,0x0f\"", "4", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "5", "0", "3", "\"swap %0\"", "\"lsr %0\"", "\"andi %0,0x7\"", "5", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "6", "0", "4", "\"swap %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"andi %0,0x3\"", "6", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "\"lsr %0\"", "7", "3", "\"rol %0\"", "\"clr %0\"", "\"rol %0\"", "2", "\"internal compiler error.  Incorrect shift:\"", "\"lsr %0\"", "1", "\"\""], "File": "avr", "Func": "lshrqi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30667, "Length": 322}
{"ground_truth": ["<s>", "const", "char", "*", "lshrsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", "<=", "reg1", ")", "return", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "(", "\"clr %D0\"", "CR_TAB", "\"mov %C0,%D1\"", "CR_TAB", "\"mov %B0,%C1\"", "CR_TAB", "\"mov %A0,%B1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", "+", "2", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %B0,%D1\"", "CR_TAB", "\"mov %A0,%C1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "case", "24", ":", "return", "*", "len", "=", "4", ",", "(", "\"mov %A0,%D1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %A0\"", "CR_TAB", "\"sbrc %D0,7\"", "CR_TAB", "\"inc %A0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %D0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsr %D0\"", "CR_TAB", "\"ror %C0\"", "CR_TAB", "\"ror %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["32bit", "logic", "shift", "right", "(", "(", "unsigned", "int", ")", "x", ">", ">", "i", ")"], "TS_V_token": ["avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %A0,%B1\"", "\"mov %B0,%C1\"", "\"mov %C0,%D1\"", "\"clr %D0\"", "\"clr %D0\"", "\"mov %C0,%D1\"", "\"mov %B0,%C1\"", "\"mov %A0,%B1\"", "16", "0", "1", "2", "2", "\"clr %C0\"", "\"clr %D0\"", "3", "\"movw %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "4", "\"mov %B0,%D1\"", "\"mov %A0,%C1\"", "\"clr %C0\"", "\"clr %D0\"", "24", "4", "\"mov %A0,%D1\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "31", "6", "\"clr %A0\"", "\"sbrc %D0,7\"", "\"inc %A0\"", "\"clr %B0\"", "\"clr %C0\"", "\"clr %D0\"", "\"lsr %D0\"", "\"ror %C0\"", "\"ror %B0\"", "\"ror %A0\"", "4", "\"\""], "File": "avr", "Func": "lshrsi3_out", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30668, "Length": 324}
{"ground_truth": ["<s>", "const", "char", "*", "output_reload_inhi", "(", "rtx", "*", "op", ",", "rtx", "clobber_reg", ",", "int", "*", "plen", ")", "{", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "plen", ",", "false", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Reload", "the", "constant", "OP", "[", "1", "]", "into", "the", "HI", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "PLEN", "==", "NULL", ":", "Output", "instructions", ".", "PLEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "PLEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "\"\""], "File": "avr", "Func": "output_reload_inhi", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30669, "Length": 32}
{"ground_truth": ["<s>", "const", "char", "*", "output_reload_insisf", "(", "rtx", "*", "op", ",", "rtx", "clobber_reg", ",", "int", "*", "len", ")", "{", "if", "(", "AVR_HAVE_MOVW", "&&", "!", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", "&&", "(", "CONST_INT_P", "(", "op", "[", "1", "]", ")", "||", "CONST_FIXED_P", "(", "op", "[", "1", "]", ")", "||", "CONST_DOUBLE_P", "(", "op", "[", "1", "]", ")", ")", ")", "{", "int", "len_clr", ",", "len_noclr", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "&", "len_clr", ",", "true", ")", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "&", "len_noclr", ",", "false", ")", ";", "if", "(", "len_noclr", "-", "len_clr", "==", "4", ")", "{", "avr_asm_len", "(", "\"mov %A0,__zero_reg__\"", "CR_TAB", "\"mov %B0,__zero_reg__\"", "CR_TAB", "\"movw %C0,%A0\"", ",", "&", "op", "[", "0", "]", ",", "len", ",", "3", ")", ";", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "len", ",", "true", ")", ";", "if", "(", "len", ")", "*", "len", "+=", "3", ";", "return", "\"\"", ";", "}", "}", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "len", ",", "false", ")", ";", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["Reload", "a", "SI", "or", "SF", "compile", "time", "constant", "OP", "[", "1", "]", "into", "the", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "LEN", "==", "NULL", ":", "Output", "instructions", ".", "LEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "LEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "."], "TS_V_token": ["avr", "0", "1", "1", "1", "4", "\"mov %A0,__zero_reg__\"", "\"mov %B0,__zero_reg__\"", "\"movw %C0,%A0\"", "0", "3", "3", "\"\"", "\"\""], "File": "avr", "Func": "output_reload_insisf", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30670, "Length": 156}
{"ground_truth": ["<s>", "static", "const", "char", "*", "ptrreg_to_str", "(", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "REG_X", ":", "return", "\"X\"", ";", "case", "REG_Y", ":", "return", "\"Y\"", ";", "case", "REG_Z", ":", "return", "\"Z\"", ";", "default", ":", "output_operand_lossage", "(", "\"address operand requires constraint for\"", "\" X, Y, or Z register\"", ")", ";", "}", "return", "NULL", ";", "}", "</s>"], "natrual_language": ["Return", "a", "pointer", "register", "name", "as", "a", "string"], "TS_V_token": ["avr", "\"X\"", "\"Y\"", "\"Z\"", "\"address operand requires constraint for\"", "\" X, Y, or Z register\""], "File": "avr", "Func": "ptrreg_to_str", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30671, "Length": 46}
{"ground_truth": ["<s>", "int", "reg_unused_after", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ")", "{", "return", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", "||", "(", "REG_P", "(", "reg", ")", "&&", "_reg_unused_after", "(", "insn", ",", "reg", ")", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "."], "TS_V_token": ["avr"], "File": "avr", "Func": "reg_unused_after", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30672, "Length": 36}
{"ground_truth": ["<s>", "const", "char", "*", "ret_cond_branch", "(", "rtx", "x", ",", "int", "len", ",", "int", "reverse", ")", "{", "RTX_CODE", "cond", "=", "reverse", "?", "reverse_condition", "(", "GET_CODE", "(", "x", ")", ")", ":", "GET_CODE", "(", "x", ")", ";", "bool", "cc_overflow_unusable", "=", "false", ";", "switch", "(", "cond", ")", "{", "case", "GT", ":", "if", "(", "cc_overflow_unusable", ")", "return", "(", "len", "==", "1", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brpl %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+4\"", "CR_TAB", "\"brmi .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+6\"", "CR_TAB", "\"brmi .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "else", "return", "(", "len", "==", "1", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brge %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+4\"", "CR_TAB", "\"brlt .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+6\"", "CR_TAB", "\"brlt .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "case", "GTU", ":", "return", "(", "len", "==", "1", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brsh %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+4\"", "CR_TAB", "\"brlo .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+6\"", "CR_TAB", "\"brlo .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "case", "LE", ":", "if", "(", "cc_overflow_unusable", ")", "return", "(", "len", "==", "1", "?", "(", "\"breq %0\"", "CR_TAB", "\"brmi %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brpl .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+2\"", "CR_TAB", "\"brpl .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "else", "return", "(", "len", "==", "1", "?", "(", "\"breq %0\"", "CR_TAB", "\"brlt %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brge .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+2\"", "CR_TAB", "\"brge .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "case", "LEU", ":", "return", "(", "len", "==", "1", "?", "(", "\"breq %0\"", "CR_TAB", "\"brlo %0\"", ")", ":", "len", "==", "2", "?", "(", "\"breq .+2\"", "CR_TAB", "\"brsh .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ":", "(", "\"breq .+2\"", "CR_TAB", "\"brsh .+4\"", "CR_TAB", "\"jmp %0\"", ")", ")", ";", "default", ":", "if", "(", "reverse", ")", "{", "switch", "(", "len", ")", "{", "case", "1", ":", "return", "\"br%k1 %0\"", ";", "case", "2", ":", "return", "(", "\"br%j1 .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ";", "default", ":", "return", "(", "\"br%j1 .+4\"", "CR_TAB", "\"jmp %0\"", ")", ";", "}", "}", "else", "{", "switch", "(", "len", ")", "{", "case", "1", ":", "return", "\"br%j1 %0\"", ";", "case", "2", ":", "return", "(", "\"br%k1 .+2\"", "CR_TAB", "\"rjmp %0\"", ")", ";", "default", ":", "return", "(", "\"br%k1 .+4\"", "CR_TAB", "\"jmp %0\"", ")", ";", "}", "}", "}", "return", "\"\"", ";", "}", "</s>"], "natrual_language": ["return", "an", "AVR", "condition", "jump", "commands", ".", "X", "is", "a", "comparison", "RTX", ".", "LEN", "is", "a", "number", "returned", "by", "avr_jump_mode", "function", ".", "if", "REVERSE", "nonzero", "then", "condition", "code", "in", "X", "must", "be", "reversed", "."], "TS_V_token": ["avr", "1", "\"breq .+2\"", "\"brpl %0\"", "2", "\"breq .+4\"", "\"brmi .+2\"", "\"rjmp %0\"", "\"breq .+6\"", "\"brmi .+4\"", "\"jmp %0\"", "1", "\"breq .+2\"", "\"brge %0\"", "2", "\"breq .+4\"", "\"brlt .+2\"", "\"rjmp %0\"", "\"breq .+6\"", "\"brlt .+4\"", "\"jmp %0\"", "1", "\"breq .+2\"", "\"brsh %0\"", "2", "\"breq .+4\"", "\"brlo .+2\"", "\"rjmp %0\"", "\"breq .+6\"", "\"brlo .+4\"", "\"jmp %0\"", "1", "\"breq %0\"", "\"brmi %0\"", "2", "\"breq .+2\"", "\"brpl .+2\"", "\"rjmp %0\"", "\"breq .+2\"", "\"brpl .+4\"", "\"jmp %0\"", "1", "\"breq %0\"", "\"brlt %0\"", "2", "\"breq .+2\"", "\"brge .+2\"", "\"rjmp %0\"", "\"breq .+2\"", "\"brge .+4\"", "\"jmp %0\"", "1", "\"breq %0\"", "\"brlo %0\"", "2", "\"breq .+2\"", "\"brsh .+2\"", "\"rjmp %0\"", "\"breq .+2\"", "\"brsh .+4\"", "\"jmp %0\"", "1", "\"br%k1 %0\"", "2", "\"br%j1 .+2\"", "\"rjmp %0\"", "\"br%j1 .+4\"", "\"jmp %0\"", "1", "\"br%j1 %0\"", "2", "\"br%k1 .+2\"", "\"rjmp %0\"", "\"br%k1 .+4\"", "\"jmp %0\"", "\"\""], "File": "avr", "Func": "ret_cond_branch", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30673, "Length": 341}
{"ground_truth": ["<s>", "static", "int", "sequent_regs_live", "(", "void", ")", "{", "int", "live_seq", "=", "0", ";", "int", "cur_seq", "=", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<=", "LAST_CALLEE_SAVED_REG", ";", "++", "reg", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "{", "if", "(", "live_seq", "!=", "0", ")", "return", "0", ";", "else", "continue", ";", "}", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "if", "(", "df_regs_ever_live_p", "(", "REG_Y", "+", "1", ")", ")", "{", "++", "live_seq", ";", "++", "cur_seq", ";", "}", "else", "cur_seq", "=", "0", ";", "}", "else", "{", "cur_seq", "+=", "2", ";", "live_seq", "+=", "2", ";", "}", "return", "(", "cur_seq", "==", "live_seq", ")", "?", "live_seq", ":", "0", ";", "}", "</s>"], "natrual_language": ["This", "function", "checks", "sequence", "of", "live", "registers"], "TS_V_token": ["avr", "0", "0", "0", "0", "0", "0", "0", "1", "0", "2", "2", "0"], "File": "avr", "Func": "sequent_regs_live", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30674, "Length": 156}
{"ground_truth": ["<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "char", "*", "specfile_name", ";", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "0", "==", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "0", "!=", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "specfile_name", "=", "concat", "(", "argv", "[", "0", "]", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "NULL", ")", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"'%s': mmcu='%s'\\n'%s': specfile='%s'\\n\\n\"", ",", "__FUNCTION__", ",", "mmcu", ",", "__FUNCTION__", ",", "specfile_name", ")", ";", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "if", "(", "(", "0", "==", "strncmp", "(", "mmcu", ",", "\"avr\"", ",", "strlen", "(", "\"avr\"", ")", ")", "&&", "specfile_name", "[", "0", "]", "==", "'.'", ")", "||", "(", "IS_ABSOLUTE_PATH", "(", "specfile_name", ")", "&&", "!", "access", "(", "specfile_name", ",", "R_OK", ")", ")", ")", "{", "return", "concat", "(", "\"-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s\"", ",", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "return", "avr_diagnose_devicespecs_error", "(", "mmcu", ",", "specfile_name", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "spec", "function", "`", "device-specs-file\u9e93", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "."], "TS_V_token": ["avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "0", "\"device-specs\"", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "0", "\"specs-\"", "\"'%s': mmcu='%s'\\n'%s': specfile='%s'\\n\\n\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "0", "\"avr\"", "\"avr\"", "0", "\"-specs=device-specs\"", "\"specs-\"", "\"%s\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \""], "File": "driver-avr2", "Func": "avr_devicespecs_file", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30675, "Length": 305}
{"ground_truth": ["<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "0", "==", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "0", "!=", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "return", "concat", "(", "\"-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s\"", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "spec", "function", "`", "device-specs-file\u9e93", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "."], "TS_V_token": ["avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "0", "\"device-specs\"", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "\"-specs=device-specs\"", "\"specs-\"", "\"%s\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \""], "File": "driver-avr4", "Func": "avr_devicespecs_file", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30676, "Length": 213}
{"ground_truth": ["<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", "==", "0", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", "!=", "0", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "return", "concat", "(", "\"-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s\"", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "spec", "function", "`", "device-specs-file\u9e93", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "."], "TS_V_token": ["avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "\"device-specs\"", "0", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "\"-specs=device-specs\"", "\"specs-\"", "\"%s\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \""], "File": "driver-avr5", "Func": "avr_devicespecs_file", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30677, "Length": 213}
{"ground_truth": ["<s>", "const", "char", "*", "avr_devicespecs_file", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "mmcu", "=", "NULL", ";", "if", "(", "verbose_flag", ")", "fnotice", "(", "stderr", ",", "\"Running spec function '%s' with %d args\\n\\n\"", ",", "__FUNCTION__", ",", "argc", ")", ";", "switch", "(", "argc", ")", "{", "case", "0", ":", "fatal_error", "(", "input_location", ",", "\"bad usage of spec function %qs\"", ",", "\"device-specs-file\"", ")", ";", "return", "X_NODEVLIB", ";", "case", "1", ":", "if", "(", "strcmp", "(", "\"device-specs\"", ",", "argv", "[", "0", "]", ")", "==", "0", ")", "{", "return", "X_NODEVLIB", ";", "}", "mmcu", "=", "AVR_MMCU_DEFAULT", ";", "break", ";", "default", ":", "mmcu", "=", "argv", "[", "1", "]", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "mmcu", ",", "argv", "[", "i", "]", ")", "!=", "0", ")", "{", "error", "(", "\"specified option %qs more than once\"", ",", "\"-mmcu\"", ")", ";", "return", "X_NODEVLIB", ";", "}", "break", ";", "}", "for", "(", "const", "char", "*", "s", "=", "mmcu", ";", "*", "s", ";", "s", "++", ")", "if", "(", "!", "ISALNUM", "(", "*", "s", ")", "&&", "'-'", "!=", "*", "s", "&&", "'_'", "!=", "*", "s", ")", "{", "error", "(", "\"strange device name %qs after %qs: bad character %qc\"", ",", "mmcu", ",", "\"-mmcu=\"", ",", "*", "s", ")", ";", "return", "X_NODEVLIB", ";", "}", "return", "concat", "(", "\"%{!nodevicespecs:-specs=device-specs\"", ",", "dir_separator_str", ",", "\"specs-\"", ",", "mmcu", ",", "\"%s} %<nodevicespecs\"", "\" %{mmcu=avr*:\"", "X_NODEVLIB", "\"} %{!mmcu=*:\"", "X_NODEVLIB", "\"}\"", ",", "\" \"", "X_NODEVLIB", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Implement", "spec", "function", "`", "device-specs-file\u9e93", ".", "Compose", "-specs=", "<", "specs-file-name", ">", "%", "s", ".", "If", "everything", "went", "well", "then", "argv", "[", "0", "]", "is", "the", "inflated", "(", "absolute", ")", "specs", "directory", "and", "argv", "[", "1", "]", "is", "a", "device", "or", "core", "name", "as", "supplied", "by", "-mmcu=", "*", ".", "When", "building", "GCC", "the", "path", "might", "be", "relative", "."], "TS_V_token": ["avr", "\"Running spec function '%s' with %d args\\n\\n\"", "0", "\"bad usage of spec function %qs\"", "\"device-specs-file\"", "1", "\"device-specs\"", "0", "0", "1", "2", "0", "\"specified option %qs more than once\"", "\"-mmcu\"", "\"strange device name %qs after %qs: bad character %qc\"", "\"-mmcu=\"", "\"%{!nodevicespecs:-specs=device-specs\"", "\"specs-\"", "\"%s} %<nodevicespecs\"", "\" %{mmcu=avr*:\"", "\"} %{!mmcu=*:\"", "\"}\"", "\" \""], "File": "driver-avr", "Func": "avr_devicespecs_file", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30678, "Length": 213}
{"ground_truth": ["<s>", "const", "char", "*", "avr_double_lib", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "int", "dbl", "=", "64", ";", "int", "dbl", "=", "32", ";", "int", "ldb", "=", "64", ";", "int", "ldb", "=", "32", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "argc", ";", "i", "++", ")", "{", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mdouble=32\"", ")", "==", "0", ")", "{", "dbl", "=", "32", ";", "ldb", "=", "dbl", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mdouble=64\"", ")", "==", "0", ")", "{", "ldb", "=", "dbl", "=", "64", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mlong-double=32\"", ")", "==", "0", ")", "{", "ldb", "=", "dbl", "=", "32", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"mlong-double=64\"", ")", "==", "0", ")", "{", "ldb", "=", "64", ";", "dbl", "=", "ldb", ";", "}", "}", "return", "concat", "(", "\" %<mdouble=* -mdouble=\"", ",", "dbl", "==", "32", "?", "\"32\"", ":", "\"64\"", ",", "\" %<mlong-double=* -mlong-double=\"", ",", "ldb", "==", "32", "?", "\"32\"", ":", "\"64\"", ",", "NULL", ")", ";", "}", "</s>"], "natrual_language": ["Re-build", "the", "-mdouble=", "and", "-mlong-double=", "options", ".", "This", "is", "needed", "because", "these", "options", "are", "not", "independent", "of", "each", "other", "."], "TS_V_token": ["avr", "64", "32", "64", "32", "0", "\"mdouble=32\"", "0", "32", "\"mdouble=64\"", "0", "64", "\"mlong-double=32\"", "0", "32", "\"mlong-double=64\"", "0", "64", "\" %<mdouble=* -mdouble=\"", "32", "\"32\"", "\"64\"", "\" %<mlong-double=* -mlong-double=\"", "32", "\"32\"", "\"64\""], "File": "driver-avr", "Func": "avr_double_lib", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30679, "Length": 173}
{"ground_truth": ["<s>", "static", "bool", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "0", "==", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", ";", "}", "</s>"], "natrual_language": ["Return", "true", "iff", "STR", "starts", "with", "PREFIX", "."], "TS_V_token": ["avr", "0"], "File": "gen-avr-mmcu-specs2", "Func": "str_prefix_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30680, "Length": 31}
{"ground_truth": ["<s>", "static", "bool", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", "==", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "iff", "STR", "starts", "with", "PREFIX", "."], "TS_V_token": ["avr", "0"], "File": "gen-avr-mmcu-specs5", "Func": "str_prefix_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30681, "Length": 31}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "for", "(", "const", "avr_mcu_t", "*", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "print_mcu", "(", "mcu", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr"], "File": "gen-avr-mmcu-specs", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30682, "Length": 31}
{"ground_truth": ["<s>", "static", "int", "c_prefix", "(", "const", "char", "*", "str", ")", "{", "static", "const", "char", "*", "const", "prefixes", "[", "]", "=", "{", "\"attiny\"", ",", "\"atmega\"", ",", "\"atxmega\"", ",", "\"ata\"", ",", "\"at90\"", ",", "\"avr\"", "}", ";", "int", "i", ",", "n", "=", "(", "int", ")", "(", "ARRAY_SIZE", "(", "prefixes", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "str_prefix_p", "(", "str", ",", "prefixes", "[", "i", "]", ")", ")", "return", "i", ";", "return", "n", ";", "}", "</s>"], "natrual_language": ["Used", "by", "string", "comparator", "to", "group", "MCUs", "by", "their", "name", "prefix", "like", "``", "attiny", "''", "or", "``", "atmega", "''", "."], "TS_V_token": ["avr", "\"attiny\"", "\"atmega\"", "\"atxmega\"", "\"ata\"", "\"at90\"", "\"avr\"", "0"], "File": "gen-avr-mmcu-texi1", "Func": "c_prefix", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30683, "Length": 80}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2023 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcus", "[", "n_mcus", "++", "]", "=", "mcu", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2023 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi1", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30684, "Length": 195}
{"ground_truth": ["<s>", "static", "int", "comparator", "(", "const", "void", "*", "va", ",", "const", "void", "*", "vb", ")", "{", "const", "char", "*", "a", "=", "*", "(", "const", "char", "*", "const", "*", ")", "va", ";", "const", "char", "*", "b", "=", "*", "(", "const", "char", "*", "const", "*", ")", "vb", ";", "while", "(", "*", "a", "&&", "*", "b", ")", "{", "if", "(", "letter", "(", "*", "a", ")", "&&", "digit", "(", "*", "b", ")", ")", "return", "-", "1", ";", "if", "(", "digit", "(", "*", "a", ")", "&&", "letter", "(", "*", "b", ")", ")", "return", "1", ";", "if", "(", "*", "a", "!=", "*", "b", ")", "return", "*", "a", "-", "*", "b", ";", "a", "++", ";", "b", "++", ";", "}", "return", "*", "a", "-", "*", "b", ";", "}", "</s>"], "natrual_language": ["Compare", "two", "MCUs", "and", "order", "them", "for", "easy", "lookup", "."], "TS_V_token": ["avr", "1", "1"], "File": "gen-avr-mmcu-texi2", "Func": "comparator", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30685, "Length": 119}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2015 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2015 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c    gcc/config/avr/avr-arch.h\\n\"", "\"@c    gcc/config/avr/avr-devices.c\\n\"", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi2", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30686, "Length": 203}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2016 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2016 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c    gcc/config/avr/avr-arch.h\\n\"", "\"@c    gcc/config/avr/avr-devices.c\\n\"", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi3", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30687, "Length": 203}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2017 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2017 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c    gcc/config/avr/avr-arch.h\\n\"", "\"@c    gcc/config/avr/avr-devices.c\\n\"", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi4", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30688, "Length": 203}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2018 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2018 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c    gcc/config/avr/avr-arch.h\\n\"", "\"@c    gcc/config/avr/avr-devices.c\\n\"", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi5", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30689, "Length": 203}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2019 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2019 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c    gcc/config/avr/avr-arch.h\\n\"", "\"@c    gcc/config/avr/avr-devices.c\\n\"", "\"@c    gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi6", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30690, "Length": 203}
{"ground_truth": ["<s>", "static", "int", "comparator", "(", "const", "void", "*", "va", ",", "const", "void", "*", "vb", ")", "{", "const", "avr_mcu_t", "*", "mcu_a", "=", "*", "(", "const", "avr_mcu_t", "*", "const", "*", ")", "va", ";", "const", "avr_mcu_t", "*", "mcu_b", "=", "*", "(", "const", "avr_mcu_t", "*", "const", "*", ")", "vb", ";", "const", "char", "*", "a", "=", "mcu_a", "->", "name", ";", "const", "char", "*", "b", "=", "mcu_b", "->", "name", ";", "int", "c", "=", "c_prefix", "(", "a", ")", "-", "c_prefix", "(", "b", ")", ";", "if", "(", "c", ")", "return", "c", ";", "c", "=", "(", "int", ")", "mcu_a", "->", "flash_size", "-", "(", "int", ")", "mcu_b", "->", "flash_size", ";", "if", "(", "c", ")", "return", "c", ";", "while", "(", "*", "a", "&&", "*", "b", ")", "{", "c", "=", "c_number", "(", "a", ")", "-", "c_number", "(", "b", ")", ";", "if", "(", "c", ")", "return", "c", ";", "if", "(", "*", "a", "!=", "*", "b", ")", "return", "*", "a", "-", "*", "b", ";", "a", "++", ";", "b", "++", ";", "}", "return", "*", "a", "-", "*", "b", ";", "}", "</s>"], "natrual_language": ["Compare", "two", "MCUs", "and", "order", "them", "for", "easy", "lookup", "."], "TS_V_token": ["avr"], "File": "gen-avr-mmcu-texi", "Func": "comparator", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30691, "Length": 164}
{"ground_truth": ["<s>", "static", "int", "c_number", "(", "const", "char", "*", "a", ")", "{", "int", "val", "=", "0", ";", "if", "(", "digit", "(", "*", "a", ")", "&&", "!", "digit", "(", "*", "(", "a", "-", "1", ")", ")", ")", "{", "while", "(", "digit", "(", "*", "a", ")", ")", "val", "=", "10", "*", "val", "+", "(", "*", "a", "++", ")", "-", "'0'", ";", "}", "return", "val", ";", "}", "</s>"], "natrual_language": ["If", "A", "starts", "a", "group", "of", "digits", ",", "return", "their", "value", "as", "a", "number", "."], "TS_V_token": ["avr", "0", "1", "10"], "File": "gen-avr-mmcu-texi", "Func": "c_number", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30692, "Length": 62}
{"ground_truth": ["<s>", "static", "int", "c_prefix", "(", "const", "char", "*", "str", ")", "{", "static", "const", "char", "*", "const", "prefixes", "[", "]", "=", "{", "\"attiny\"", ",", "\"atmega\"", ",", "\"atxmega\"", ",", "\"ata\"", ",", "\"at90\"", "}", ";", "int", "i", ",", "n", "=", "(", "int", ")", "(", "sizeof", "(", "prefixes", ")", "/", "sizeof", "(", "*", "prefixes", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "str_prefix_p", "(", "str", ",", "prefixes", "[", "i", "]", ")", ")", "return", "i", ";", "return", "n", ";", "}", "</s>"], "natrual_language": ["Used", "by", "string", "comparator", "to", "group", "MCUs", "by", "their", "name", "prefix", "like", "``", "attiny", "''", "or", "``", "atmega", "''", "."], "TS_V_token": ["avr", "\"attiny\"", "\"atmega\"", "\"atxmega\"", "\"ata\"", "\"at90\"", "0"], "File": "gen-avr-mmcu-texi", "Func": "c_prefix", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30693, "Length": 84}
{"ground_truth": ["<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2022 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcus", "[", "n_mcus", "++", "]", "=", "mcu", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>"], "natrual_language": ["Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "."], "TS_V_token": ["avr", "0", "\"@c Copyright (C) 2012-2022 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\""], "File": "gen-avr-mmcu-texi", "Func": "main", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30694, "Length": 201}
{"ground_truth": ["<s>", "static", "int", "str_prefix_p", "(", "const", "char", "*", "str", ",", "const", "char", "*", "prefix", ")", "{", "return", "strncmp", "(", "str", ",", "prefix", ",", "strlen", "(", "prefix", ")", ")", "==", "0", ";", "}", "</s>"], "natrual_language": ["Return", "true", "iff", "STR", "starts", "with", "PREFIX", "."], "TS_V_token": ["avr", "0"], "File": "gen-avr-mmcu-texi", "Func": "str_prefix_p", "Target": "avr", "Target_Clf": "MPU", "Compiler_Type": "GCC", "Idx": 30695, "Length": 31}