Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "msp430_hard_regno_mode_ok", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "return", "regno", "<=", "(", "ARG_POINTER_REGNUM", "-", "msp430_hard_regno_nregs", "(", "regno", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_MODE_OK", "." ]

[ "msp430" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_func_type", "(", "void", ")", "{", "unsigned", "long", "type", "=", "ARM_FT_UNKNOWN", ";", "tree", "a", ";", "tree", "attr", ";", "gcc_assert", "(", "TREE_CODE", "(", "current_function_decl", ")", "==", "FUNCTION_DECL", ")", ";", "if", "(", "optimize", ">", "0", "&&", "(", "TREE_NOTHROW", "(", "current_function_decl", ")", "||", "!", "(", "flag_unwind_tables", "||", "(", "flag_exceptions", "&&", "arm_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_SJLJ", ")", ")", ")", "&&", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", ")", "type", "|=", "ARM_FT_VOLATILE", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "type", "|=", "ARM_FT_NESTED", ";", "attr", "=", "DECL_ATTRIBUTES", "(", "current_function_decl", ")", ";", "a", "=", "lookup_attribute", "(", "\"naked\"", ",", "attr", ")", ";", "if", "(", "a", "!=", "NULL_TREE", ")", "type", "|=", "ARM_FT_NAKED", ";", "a", "=", "lookup_attribute", "(", "\"isr\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "a", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "attr", ")", ";", "if", "(", "a", "==", "NULL_TREE", ")", "type", "|=", "TARGET_INTERWORK", "?", "ARM_FT_INTERWORKED", ":", "ARM_FT_NORMAL", ";", "else", "type", "|=", "arm_isr_value", "(", "TREE_VALUE", "(", "a", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"cmse_nonsecure_entry\"", ",", "attr", ")", ")", "type", "|=", "ARM_FT_CMSE_ENTRY", ";", "return", "type", ";", "}", "</s>" ]

[ "Computes", "the", "type", "of", "the", "current", "function", "." ]

[ "arm", "0", "\"naked\"", "\"isr\"", "\"interrupt\"", "\"cmse_nonsecure_entry\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "visium_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "rtx", ">", "&", ",", "vec", "<", "machine_mode", ">", "&", ",", "vec", "<", "const", "char", "*", ">", "&", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "FLAGS_REGNUM", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Prepend", "to", "CLOBBERS", "hard", "registers", "that", "are", "automatically", "clobbered", "for", "an", "asm", "We", "do", "this", "for", "the", "FLAGS", "to", "maintain", "source", "compatibility", "with", "the", "original", "cc0-based", "compiler", "." ]

[ "visium" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "setPic", "(", "OutContext", ".", "getObjectFileInfo", "(", ")", "->", "isPositionIndependent", "(", ")", ")", ";", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "MIPS_MC", "::", "selectMipsCPU", "(", "TT", ",", "TM", ".", "getTargetCPU", "(", ")", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "MipsTargetMachine", "&", "MTM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "MipsSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "MTM", ".", "isLittleEndian", "(", ")", ",", "MTM", ",", "None", ")", ";", "bool", "IsABICalls", "=", "STI", ".", "isABICalls", "(", ")", ";", "const", "MipsABIInfo", "&", "ABI", "=", "MTM", ".", "getABI", "(", ")", ";", "if", "(", "IsABICalls", ")", "{", "TS", ".", "emitDirectiveAbiCalls", "(", ")", ";", "if", "(", "!", "isPositionIndependent", "(", ")", "&&", "STI", ".", "hasSym32", "(", ")", ")", "TS", ".", "emitDirectiveOptionPic0", "(", ")", ";", "}", "std", "::", "string", "SectionName", "=", "std", "::", "string", "(", "\".mdebug.\"", ")", "+", "getCurrentABIString", "(", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "OutContext", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ")", ";", "STI", ".", "isNaN2008", "(", ")", "?", "TS", ".", "emitDirectiveNaN2008", "(", ")", ":", "TS", ".", "emitDirectiveNaNLegacy", "(", ")", ";", "TS", ".", "updateABIInfo", "(", "STI", ")", ";", "if", "(", "(", "ABI", ".", "IsO32", "(", ")", "&&", "(", "STI", ".", "isABI_FPXX", "(", ")", "||", "STI", ".", "isFP64bit", "(", ")", ")", ")", "||", "STI", ".", "useSoftFloat", "(", ")", ")", "TS", ".", "emitDirectiveModuleFP", "(", ")", ";", "if", "(", "ABI", ".", "IsO32", "(", ")", "&&", "(", "!", "STI", ".", "useOddSPReg", "(", ")", "||", "STI", ".", "isABI_FPXX", "(", ")", ")", ")", "TS", ".", "emitDirectiveModuleOddSPReg", "(", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "Mips", "Mips", "Mips", "MIPS_MC::selectMipsCPU", "Mips", "Mips", "Mips", "Mips", "\".mdebug.\"", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "usePreRAHazardRecognizer", "(", ")", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "static_cast", "<", "const", "ARMSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ",", "\"pre-RA-sched\"", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "ARM", "ARM", "ARM", "\"pre-RA-sched\"" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", "==", "\".even\"", ")", "return", "parseDirectiveEven", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_proc\"", ")", "return", "parseDirectiveFPOProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_setframe\"", ")", "return", "parseDirectiveFPOSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_pushreg\"", ")", "return", "parseDirectiveFPOPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_stackalloc\"", ")", "return", "parseDirectiveFPOStackAlloc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_stackalign\"", ")", "return", "parseDirectiveFPOStackAlign", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endprologue\"", ")", "return", "parseDirectiveFPOEndPrologue", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".cv_fpo_endproc\"", ")", "return", "parseDirectiveFPOEndProc", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_pushreg\"", ")", "return", "parseDirectiveSEHPushReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_setframe\"", ")", "return", "parseDirectiveSEHSetFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_savereg\"", ")", "return", "parseDirectiveSEHSaveReg", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_savexmm\"", ")", "return", "parseDirectiveSEHSaveXMM", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".seh_pushframe\"", ")", "return", "parseDirectiveSEHPushFrame", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "X86", "X86", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".even\"", "\".cv_fpo_proc\"", "\".cv_fpo_setframe\"", "\".cv_fpo_pushreg\"", "\".cv_fpo_stackalloc\"", "\".cv_fpo_stackalign\"", "\".cv_fpo_endprologue\"", "\".cv_fpo_endproc\"", "\".seh_pushreg\"", "\".seh_setframe\"", "\".seh_savereg\"", "\".seh_savexmm\"", "\".seh_pushframe\"" ]

[]

[ "<s>", "static", "bool", "rs6000_optab_supported_p", "(", "int", "op", ",", "machine_mode", "mode1", ",", "machine_mode", ",", "optimization_type", "opt_type", ")", "{", "switch", "(", "op", ")", "{", "case", "rsqrt_optab", ":", "return", "(", "opt_type", "==", "OPTIMIZE_FOR_SPEED", "&&", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "mode1", ")", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_OPTAB_SUPPORTED_P", "hook", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "char", "*", "msp430_mcu_name", "(", "void", ")", "{", "if", "(", "target_mcu", ")", "{", "msp430_extract_mcu_data", "(", "target_mcu", ")", ";", "unsigned", "int", "i", ";", "unsigned", "int", "start_upper", ";", "unsigned", "int", "end_upper", ";", "static", "char", "mcu_name", "[", "64", "]", ";", "if", "(", "startswith", "(", "target_mcu", ",", "\"msp430i\"", ")", ")", "{", "snprintf", "(", "mcu_name", ",", "sizeof", "(", "mcu_name", ")", "-", "1", ",", "\"__MSP430i%s__\"", ",", "target_mcu", "+", "7", ")", ";", "start_upper", "=", "9", ";", "}", "else", "{", "snprintf", "(", "mcu_name", ",", "sizeof", "(", "mcu_name", ")", "-", "1", ",", "\"__%s__\"", ",", "target_mcu", ")", ";", "start_upper", "=", "2", ";", "}", "end_upper", "=", "strlen", "(", "mcu_name", ")", "-", "2", ";", "for", "(", "i", "=", "start_upper", ";", "i", "<", "end_upper", ";", "i", "++", ")", "mcu_name", "[", "i", "]", "=", "TOUPPER", "(", "mcu_name", "[", "i", "]", ")", ";", "return", "mcu_name", ";", "}", "return", "msp430x", "?", "\"__MSP430XGENERIC__\"", ":", "\"__MSP430GENERIC__\"", ";", "}", "</s>" ]

[ "Generate", "a", "C", "preprocessor", "symbol", "based", "upon", "the", "MCU", "selected", "by", "the", "user", ".", "If", "a", "specific", "MCU", "has", "not", "been", "selected", "then", "return", "a", "generic", "symbol", "instead", "." ]

[ "msp430", "64", "\"msp430i\"", "1", "\"__MSP430i%s__\"", "7", "9", "1", "\"__%s__\"", "2", "2", "\"__MSP430XGENERIC__\"", "\"__MSP430GENERIC__\"" ]

[]

[ "<s>", "static", "tree", "arc_handle_interrupt_attribute", "(", "tree", "*", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "args", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "arc", "\"argument of %qE attribute is not a string constant\"", "\"ilink1\"", "\"ilink2\"", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"" ]

[]

[ "<s>", "static", "const", "struct", "tilepro_multiply_insn_seq", "*", "tilepro_find_multiply_insn_seq_for_constant", "(", "int", "multiplier", ")", "{", "return", "(", "(", "const", "struct", "tilepro_multiply_insn_seq", "*", ")", "bsearch", "(", "&", "multiplier", ",", "tilepro_multiply_insn_seq_table", ",", "tilepro_multiply_insn_seq_table_size", ",", "sizeof", "tilepro_multiply_insn_seq_table", "[", "0", "]", ",", "tilepro_compare_multipliers", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "tilepro_multiply_insn_seq", "for", "multiplier", ",", "or", "NULL", "if", "none", "exists", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "StackOffset", "CSKYFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "int", "MinCSFI", "=", "0", ";", "int", "MaxCSFI", "=", "-", "1", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "MinCSFI", "=", "CSI", "[", "0", "]", ".", "getFrameIdx", "(", ")", ";", "MaxCSFI", "=", "CSI", "[", "CSI", ".", "size", "(", ")", "-", "1", "]", ".", "getFrameIdx", "(", ")", ";", "}", "if", "(", "FI", ">=", "MinCSFI", "&&", "FI", "<=", "MaxCSFI", ")", "{", "FrameReg", "=", "CSKY", "::", "R14", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "if", "(", "RI", "->", "hasStackRealignment", "(", "MF", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", ")", ";", "if", "(", "!", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ")", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "CSKY", "::", "R14", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "}", "else", "{", "if", "(", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", "&&", "hasFP", "(", "MF", ")", ")", "{", "FrameReg", "=", "getFPReg", "(", "STI", ")", ";", "Offset", "+=", "CFI", "->", "getVarArgsSaveSize", "(", ")", "+", "CFI", "->", "getCalleeSaveAreaSize", "(", ")", ";", "}", "else", "{", "FrameReg", "=", "hasBP", "(", "MF", ")", "?", "getBPReg", "(", "STI", ")", ":", "CSKY", "::", "R14", ";", "Offset", "+=", "MFI", ".", "getStackSize", "(", ")", ";", "}", "}", "return", "StackOffset", "::", "getFixed", "(", "Offset", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY", "0", "1", "0", "1", "CSKY::R14", "CSKY::R14", "CSKY::R14" ]

[]

[ "<s>", "static", "void", "sparc32_initialize_trampoline", "(", "rtx", "m_tramp", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ")", "{", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "0", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "fnaddr", ",", "10", ",", "0", ",", "1", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x03000000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "cxt", ",", "10", ",", "0", ",", "1", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x05000000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "8", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_and", "(", "SImode", ",", "fnaddr", ",", "GEN_INT", "(", "0x3ff", ")", ",", "NULL_RTX", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x81c06000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "12", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_and", "(", "SImode", ",", "cxt", ",", "GEN_INT", "(", "0x3ff", ")", ",", "NULL_RTX", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x8410a000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_insn", "(", "gen_flush", "(", "SImode", ",", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "0", ")", ")", ")", ")", ";", "if", "(", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC", "&&", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA2", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA3", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA4", "&&", "sparc_cpu", "!=", "PROCESSOR_NIAGARA7", "&&", "sparc_cpu", "!=", "PROCESSOR_M8", ")", "emit_insn", "(", "gen_flush", "(", "SImode", ",", "validize_mem", "(", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "8", ")", ")", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "This", "takes", "16", "insns", ":", "2", "shifts", "&", "2", "ands", "(", "to", "split", "up", "addresses", ")", ",", "4", "sethi", "(", "to", "load", "in", "opcodes", ")", ",", "4", "iors", "(", "to", "merge", "address", "and", "opcodes", ")", ",", "and", "4", "writes", "(", "to", "store", "insns", ")", ".", "This", "is", "a", "bit", "excessive", ".", "Perhaps", "a", "different", "mechanism", "would", "be", "better", "here", ".", "Emit", "enough", "FLUSH", "insns", "to", "synchronize", "the", "data", "and", "instruction", "caches", "." ]

[ "sparc", "0", "10", "0", "1", "0x03000000", "1", "4", "10", "0", "1", "0x05000000", "1", "8", "0x3ff", "0x81c06000", "1", "12", "0x3ff", "0x8410a000", "1", "0", "8", "\"__enable_execute_stack\"", "0" ]

[]

[ "<s>", "void", "MSP430FrameInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SPW", "MSP430::FPW", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "MCRegisterInfo", "&", "MRI", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "switch", "(", "TheTriple", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "new", "MBlazeMCAsmInfo", "(", ")", ";", "}", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "void", "nios2_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "int", "pret_size", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "*", "cum", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "nios2_function_arg_advance", "(", "local_cum_v", ",", "arg", ")", ";", "regs_to_push", "=", "NUM_ARG_REGS", "-", "local_cum", ".", "regs_used", ";", "if", "(", "!", "TARGET_HAS_CDX", "&&", "!", "second_time", "&&", "regs_to_push", ">", "0", ")", "{", "rtx", "ptr", "=", "virtual_incoming_args_rtx", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "regs_used", "+", "FIRST_ARG_REGNO", ",", "mem", ",", "regs_to_push", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "pret_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";", "if", "(", "pret_size", ")", "*", "pretend_size", "=", "pret_size", ";", "}", "</s>" ]

[ "TODO", ":", "It", "may", "be", "possible", "to", "eliminate", "the", "copyback", "and", "implement", "own", "va_arg", "type", "." ]

[ "nios2", "1", "0" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createPPCLowerMASSVEntriesPass", "(", ")", ")", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0" ]

[]

[ "<s>", "static", "void", "m32r_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", ")", "{", "enum", "m32r_function_type", "fn_type", "=", "m32r_compute_function_type", "(", "current_function_decl", ")", ";", "if", "(", "M32R_INTERRUPT_P", "(", "fn_type", ")", ")", "fprintf", "(", "file", ",", "\"\\t%s interrupt handler\\n\"", ",", "ASM_COMMENT_START", ")", ";", "if", "(", "!", "current_frame_info", ".", "initialized", ")", "m32r_compute_frame_size", "(", "size", ")", ";", "fprintf", "(", "file", ",", "\"\\t%s PROLOGUE, vars= %d, regs= %d, args= %d, extra= %d\\n\"", ",", "ASM_COMMENT_START", ",", "current_frame_info", ".", "var_size", ",", "current_frame_info", ".", "reg_size", "/", "4", ",", "current_frame_info", ".", "args_size", ",", "current_frame_info", ".", "extra_size", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "pointer", "(", "if", "desired", ")", "for", "the", "function", ".", "Note", ",", "if", "this", "is", "changed", ",", "you", "need", "to", "mirror", "the", "changes", "in", "m32r_compute_frame_size", "which", "calculates", "the", "prolog", "size", "." ]

[ "m32r", "\"\\t%s interrupt handler\\n\"", "\"\\t%s PROLOGUE, vars= %d, regs= %d, args= %d, extra= %d\\n\"", "4" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "X86", "X86", "ISD::OutputArg", "16", "X86" ]

[]

[ "<s>", "int", "s390_single_part", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "machine_mode", "part_mode", ",", "int", "def", ")", "{", "unsigned", "HOST_WIDE_INT", "value", "=", "0", ";", "int", "n_parts", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "GET_MODE_SIZE", "(", "part_mode", ")", ";", "unsigned", "HOST_WIDE_INT", "part_mask", "=", "(", "HOST_WIDE_INT_1U", "<<", "GET_MODE_BITSIZE", "(", "part_mode", ")", ")", "-", "1", ";", "int", "i", ",", "part", "=", "-", "1", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", ")", "return", "-", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_parts", ";", "i", "++", ")", "{", "if", "(", "i", "==", "0", ")", "value", "=", "UINTVAL", "(", "op", ")", ";", "else", "value", ">>=", "GET_MODE_BITSIZE", "(", "part_mode", ")", ";", "if", "(", "(", "value", "&", "part_mask", ")", "!=", "(", "def", "&", "part_mask", ")", ")", "{", "if", "(", "part", "!=", "-", "1", ")", "return", "-", "1", ";", "else", "part", "=", "i", ";", "}", "}", "return", "part", "==", "-", "1", "?", "-", "1", ":", "n_parts", "-", "1", "-", "part", ";", "}", "</s>" ]

[ "If", "OP", "is", "an", "integer", "constant", "of", "mode", "MODE", "with", "exactly", "one", "part", "of", "mode", "PART_MODE", "unequal", "to", "DEF", ",", "return", "the", "number", "of", "that", "part", ".", "Otherwise", ",", "return", "-1", "." ]

[ "s390", "0", "1", "1", "1", "0", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "pa_singlemove_string", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "intval", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "return", "\"stw %r1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", ")", "return", "\"ldw %1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_DOUBLE", ")", "{", "long", "i", ";", "REAL_VALUE_TYPE", "d", ";", "gcc_assert", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", "==", "SFmode", ")", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "d", ",", "operands", "[", "1", "]", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "d", ",", "i", ")", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "CONST_INT", ")", "{", "intval", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "VAL_14_BITS_P", "(", "intval", ")", ")", "return", "\"ldi %1,%0\"", ";", "else", "if", "(", "(", "intval", "&", "0x7ff", ")", "==", "0", ")", "return", "\"ldil L'%1,%0\"", ";", "else", "if", "(", "pa_zdepi_cint_p", "(", "intval", ")", ")", "return", "\"{zdepi %Z1,%0|depwi,z %Z1,%0}\"", ";", "else", "return", "\"ldil L'%1,%0\\n\\tldo R'%1(%0),%0\"", ";", "}", "return", "\"copy %1,%0\"", ";", "}", "</s>" ]

[ "Return", "the", "best", "assembler", "insn", "template", "for", "moving", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "as", "a", "fullword", "." ]

[ "pa", "0", "\"stw %r1,%0\"", "1", "\"ldw %1,%0\"", "1", "1", "1", "1", "1", "1", "\"ldi %1,%0\"", "0x7ff", "0", "\"ldil L'%1,%0\"", "\"{zdepi %Z1,%0|depwi,z %Z1,%0}\"", "\"ldil L'%1,%0\\n\\tldo R'%1(%0),%0\"", "\"copy %1,%0\"" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowTruncateForTailCall", "(", "Type", "*", "Ty1", ",", "Type", "*", "Ty2", ")", "const", "{", "if", "(", "!", "Ty1", "->", "isIntegerTy", "(", ")", "||", "!", "Ty2", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "return", "Ty1", "->", "getPrimitiveSizeInBits", "(", ")", "<=", "32", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "truncation", "from", "FromTy", "to", "ToTy", "is", "permitted", "when", "deciding", "whether", "a", "call", "is", "in", "tail", "position", "." ]

[ "Hexagon", "Hexagon", "32" ]

[]

[ "<s>", "const", "ArrayRef", "<", "MCPhysReg", ">", "Cpu0ABIInfo", "::", "GetVarArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsS32", "(", ")", ")", "return", "makeArrayRef", "(", "S32IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "the", "variable", "argument", "list", "." ]

[ "Cpu0", "Cpu0", "\"Unhandled ABI\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "STI", ".", "isTargetDarwin", "(", ")", ")", "return", "true", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "(", "DisableFramePointerElim", "(", "MF", ")", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "||", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Unsupported Node Replacement\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "TPC", "\"Unsupported Node Replacement\"" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "FRE", ":", "return", "\"PPCISD::FRE\"", ";", "case", "PPCISD", "::", "FRSQRTE", ":", "return", "\"PPCISD::FRSQRTE\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "CALL", ":", "return", "\"PPCISD::CALL\"", ";", "case", "PPCISD", "::", "CALL_NOP", ":", "return", "\"PPCISD::CALL_NOP\"", ";", "case", "PPCISD", "::", "CALL_TLS", ":", "return", "\"PPCISD::CALL_TLS\"", ";", "case", "PPCISD", "::", "CALL_NOP_TLS", ":", "return", "\"PPCISD::CALL_NOP_TLS\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL", ":", "return", "\"PPCISD::BCTRL\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"PPCISD::EH_SJLJ_SETJMP\"", ";", "case", "PPCISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"PPCISD::EH_SJLJ_LONGJMP\"", ";", "case", "PPCISD", "::", "MFOCRF", ":", "return", "\"PPCISD::MFOCRF\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "BDNZ", ":", "return", "\"PPCISD::BDNZ\"", ";", "case", "PPCISD", "::", "BDZ", ":", "return", "\"PPCISD::BDZ\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "PPC32_GOT", ":", "return", "\"PPCISD::PPC32_GOT\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "case", "PPCISD", "::", "SC", ":", "return", "\"PPCISD::SC\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "PowerPC", "PPC", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::FRE", "\"PPCISD::FRE\"", "PPCISD::FRSQRTE", "\"PPCISD::FRSQRTE\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::CALL", "\"PPCISD::CALL\"", "PPCISD::CALL_NOP", "\"PPCISD::CALL_NOP\"", "PPCISD::CALL_TLS", "\"PPCISD::CALL_TLS\"", "PPCISD::CALL_NOP_TLS", "\"PPCISD::CALL_NOP_TLS\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL", "\"PPCISD::BCTRL\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::EH_SJLJ_SETJMP", "\"PPCISD::EH_SJLJ_SETJMP\"", "PPCISD::EH_SJLJ_LONGJMP", "\"PPCISD::EH_SJLJ_LONGJMP\"", "PPCISD::MFOCRF", "\"PPCISD::MFOCRF\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::BDNZ", "\"PPCISD::BDNZ\"", "PPCISD::BDZ", "\"PPCISD::BDZ\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::PPC32_GOT", "\"PPCISD::PPC32_GOT\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"", "PPCISD::SC", "\"PPCISD::SC\"" ]

[]

[ "<s>", "HOST_WIDE_INT", "csky_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "offset", ";", "csky_layout_stack_frame", "(", ")", ";", "switch", "(", "from", ")", "{", "case", "FRAME_POINTER_REGNUM", ":", "case", "HARD_FRAME_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "reg_offset", ";", "break", ";", "case", "ARG_POINTER_REGNUM", ":", "offset", "=", "cfun", "->", "machine", "->", "arg_offset", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "to", "==", "FRAME_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "-=", "cfun", "->", "machine", "->", "reg_offset", ";", "return", "offset", ";", "}", "</s>" ]

[ "Worker", "function", "for", "INITIAL_ELIMINATION_OFFSET", "macro", ".", "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "csky" ]

[]

[ "<s>", "static", "void", "sparc_emit_set_const32", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op0", ")", ";", "rtx", "temp", "=", "op0", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "temp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", ")", "{", "gcc_assert", "(", "!", "small_int_operand", "(", "op1", ",", "mode", ")", "&&", "!", "const_high_operand", "(", "op1", ",", "mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "GEN_INT", "(", "INTVAL", "(", "op1", ")", "&", "~", "(", "HOST_WIDE_INT", ")", "0x3ff", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_IOR", "(", "mode", ",", "temp", ",", "GEN_INT", "(", "INTVAL", "(", "op1", ")", "&", "0x3ff", ")", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "gen_rtx_HIGH", "(", "mode", ",", "op1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_rtx_LO_SUM", "(", "mode", ",", "temp", ",", "op1", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "We", "know", "it", "ca", "n't", "be", "done", "in", "one", "insn", "when", "we", "get", "here", ",", "the", "movsi", "expander", "guarentees", "this", "." ]

[ "sparc", "0x3ff", "0x3ff" ]

[]

[ "<s>", "static", "bool", "rs6000_function_parms_need_stack", "(", "tree", "fun", ",", "bool", "incoming", ")", "{", "tree", "fntype", ",", "result", ";", "CUMULATIVE_ARGS", "args_so_far_v", ";", "cumulative_args_t", "args_so_far", ";", "if", "(", "!", "fun", ")", "return", "false", ";", "fntype", "=", "fun", ";", "if", "(", "!", "TYPE_P", "(", "fun", ")", ")", "fntype", "=", "TREE_TYPE", "(", "fun", ")", ";", "if", "(", "(", "!", "incoming", "&&", "!", "prototype_p", "(", "fntype", ")", ")", "||", "stdarg_p", "(", "fntype", ")", ")", "return", "true", ";", "INIT_CUMULATIVE_INCOMING_ARGS", "(", "args_so_far_v", ",", "fntype", ",", "NULL_RTX", ")", ";", "args_so_far", "=", "pack_cumulative_args", "(", "&", "args_so_far_v", ")", ";", "if", "(", "incoming", ")", "{", "gcc_assert", "(", "DECL_P", "(", "fun", ")", ")", ";", "result", "=", "DECL_RESULT", "(", "fun", ")", ";", "}", "else", "result", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "result", "&&", "aggregate_value_p", "(", "result", ",", "fntype", ")", ")", "{", "if", "(", "!", "TYPE_P", "(", "result", ")", ")", "result", "=", "TREE_TYPE", "(", "result", ")", ";", "result", "=", "build_pointer_type", "(", "result", ")", ";", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "result", ")", ";", "}", "if", "(", "incoming", ")", "{", "tree", "parm", ";", "for", "(", "parm", "=", "DECL_ARGUMENTS", "(", "fun", ")", ";", "parm", "&&", "parm", "!=", "void_list_node", ";", "parm", "=", "TREE_CHAIN", "(", "parm", ")", ")", "if", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "parm", ")", ")", ")", "return", "true", ";", "}", "else", "{", "function_args_iterator", "args_iter", ";", "tree", "arg_type", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "arg_type", ",", "args_iter", ")", "if", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "arg_type", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUN", "has", "no", "prototype", ",", "has", "a", "variable", "argument", "list", ",", "or", "passes", "any", "parameter", "in", "memory", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "char", "*", "NVPTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "NVPTXISD", "::", "CALL", ":", "return", "\"NVPTXISD::CALL\"", ";", "case", "NVPTXISD", "::", "RET_FLAG", ":", "return", "\"NVPTXISD::RET_FLAG\"", ";", "case", "NVPTXISD", "::", "Wrapper", ":", "return", "\"NVPTXISD::Wrapper\"", ";", "case", "NVPTXISD", "::", "NVBuiltin", ":", "return", "\"NVPTXISD::NVBuiltin\"", ";", "case", "NVPTXISD", "::", "DeclareParam", ":", "return", "\"NVPTXISD::DeclareParam\"", ";", "case", "NVPTXISD", "::", "DeclareScalarParam", ":", "return", "\"NVPTXISD::DeclareScalarParam\"", ";", "case", "NVPTXISD", "::", "DeclareRet", ":", "return", "\"NVPTXISD::DeclareRet\"", ";", "case", "NVPTXISD", "::", "DeclareRetParam", ":", "return", "\"NVPTXISD::DeclareRetParam\"", ";", "case", "NVPTXISD", "::", "PrintCall", ":", "return", "\"NVPTXISD::PrintCall\"", ";", "case", "NVPTXISD", "::", "LoadParam", ":", "return", "\"NVPTXISD::LoadParam\"", ";", "case", "NVPTXISD", "::", "StoreParam", ":", "return", "\"NVPTXISD::StoreParam\"", ";", "case", "NVPTXISD", "::", "StoreParamS32", ":", "return", "\"NVPTXISD::StoreParamS32\"", ";", "case", "NVPTXISD", "::", "StoreParamU32", ":", "return", "\"NVPTXISD::StoreParamU32\"", ";", "case", "NVPTXISD", "::", "MoveToParam", ":", "return", "\"NVPTXISD::MoveToParam\"", ";", "case", "NVPTXISD", "::", "CallArgBegin", ":", "return", "\"NVPTXISD::CallArgBegin\"", ";", "case", "NVPTXISD", "::", "CallArg", ":", "return", "\"NVPTXISD::CallArg\"", ";", "case", "NVPTXISD", "::", "LastCallArg", ":", "return", "\"NVPTXISD::LastCallArg\"", ";", "case", "NVPTXISD", "::", "CallArgEnd", ":", "return", "\"NVPTXISD::CallArgEnd\"", ";", "case", "NVPTXISD", "::", "CallVoid", ":", "return", "\"NVPTXISD::CallVoid\"", ";", "case", "NVPTXISD", "::", "CallVal", ":", "return", "\"NVPTXISD::CallVal\"", ";", "case", "NVPTXISD", "::", "CallSymbol", ":", "return", "\"NVPTXISD::CallSymbol\"", ";", "case", "NVPTXISD", "::", "Prototype", ":", "return", "\"NVPTXISD::Prototype\"", ";", "case", "NVPTXISD", "::", "MoveParam", ":", "return", "\"NVPTXISD::MoveParam\"", ";", "case", "NVPTXISD", "::", "MoveRetval", ":", "return", "\"NVPTXISD::MoveRetval\"", ";", "case", "NVPTXISD", "::", "MoveToRetval", ":", "return", "\"NVPTXISD::MoveToRetval\"", ";", "case", "NVPTXISD", "::", "StoreRetval", ":", "return", "\"NVPTXISD::StoreRetval\"", ";", "case", "NVPTXISD", "::", "PseudoUseParam", ":", "return", "\"NVPTXISD::PseudoUseParam\"", ";", "case", "NVPTXISD", "::", "RETURN", ":", "return", "\"NVPTXISD::RETURN\"", ";", "case", "NVPTXISD", "::", "CallSeqBegin", ":", "return", "\"NVPTXISD::CallSeqBegin\"", ";", "case", "NVPTXISD", "::", "CallSeqEnd", ":", "return", "\"NVPTXISD::CallSeqEnd\"", ";", "case", "NVPTXISD", "::", "LoadV2", ":", "return", "\"NVPTXISD::LoadV2\"", ";", "case", "NVPTXISD", "::", "LoadV4", ":", "return", "\"NVPTXISD::LoadV4\"", ";", "case", "NVPTXISD", "::", "LDGV2", ":", "return", "\"NVPTXISD::LDGV2\"", ";", "case", "NVPTXISD", "::", "LDGV4", ":", "return", "\"NVPTXISD::LDGV4\"", ";", "case", "NVPTXISD", "::", "LDUV2", ":", "return", "\"NVPTXISD::LDUV2\"", ";", "case", "NVPTXISD", "::", "LDUV4", ":", "return", "\"NVPTXISD::LDUV4\"", ";", "case", "NVPTXISD", "::", "StoreV2", ":", "return", "\"NVPTXISD::StoreV2\"", ";", "case", "NVPTXISD", "::", "StoreV4", ":", "return", "\"NVPTXISD::StoreV4\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "NVPTX", "NVPTX", "0", "NVPTXISD::CALL", "\"NVPTXISD::CALL\"", "NVPTXISD::RET_FLAG", "\"NVPTXISD::RET_FLAG\"", "NVPTXISD::Wrapper", "\"NVPTXISD::Wrapper\"", "NVPTXISD::NVBuiltin", "\"NVPTXISD::NVBuiltin\"", "NVPTXISD::DeclareParam", "\"NVPTXISD::DeclareParam\"", "NVPTXISD::DeclareScalarParam", "\"NVPTXISD::DeclareScalarParam\"", "NVPTXISD::DeclareRet", "\"NVPTXISD::DeclareRet\"", "NVPTXISD::DeclareRetParam", "\"NVPTXISD::DeclareRetParam\"", "NVPTXISD::PrintCall", "\"NVPTXISD::PrintCall\"", "NVPTXISD::LoadParam", "\"NVPTXISD::LoadParam\"", "NVPTXISD::StoreParam", "\"NVPTXISD::StoreParam\"", "NVPTXISD::StoreParamS32", "\"NVPTXISD::StoreParamS32\"", "NVPTXISD::StoreParamU32", "\"NVPTXISD::StoreParamU32\"", "NVPTXISD::MoveToParam", "\"NVPTXISD::MoveToParam\"", "NVPTXISD::CallArgBegin", "\"NVPTXISD::CallArgBegin\"", "NVPTXISD::CallArg", "\"NVPTXISD::CallArg\"", "NVPTXISD::LastCallArg", "\"NVPTXISD::LastCallArg\"", "NVPTXISD::CallArgEnd", "\"NVPTXISD::CallArgEnd\"", "NVPTXISD::CallVoid", "\"NVPTXISD::CallVoid\"", "NVPTXISD::CallVal", "\"NVPTXISD::CallVal\"", "NVPTXISD::CallSymbol", "\"NVPTXISD::CallSymbol\"", "NVPTXISD::Prototype", "\"NVPTXISD::Prototype\"", "NVPTXISD::MoveParam", "\"NVPTXISD::MoveParam\"", "NVPTXISD::MoveRetval", "\"NVPTXISD::MoveRetval\"", "NVPTXISD::MoveToRetval", "\"NVPTXISD::MoveToRetval\"", "NVPTXISD::StoreRetval", "\"NVPTXISD::StoreRetval\"", "NVPTXISD::PseudoUseParam", "\"NVPTXISD::PseudoUseParam\"", "NVPTXISD::RETURN", "\"NVPTXISD::RETURN\"", "NVPTXISD::CallSeqBegin", "\"NVPTXISD::CallSeqBegin\"", "NVPTXISD::CallSeqEnd", "\"NVPTXISD::CallSeqEnd\"", "NVPTXISD::LoadV2", "\"NVPTXISD::LoadV2\"", "NVPTXISD::LoadV4", "\"NVPTXISD::LoadV4\"", "NVPTXISD::LDGV2", "\"NVPTXISD::LDGV2\"", "NVPTXISD::LDGV4", "\"NVPTXISD::LDGV4\"", "NVPTXISD::LDUV2", "\"NVPTXISD::LDUV2\"", "NVPTXISD::LDUV4", "\"NVPTXISD::LDUV4\"", "NVPTXISD::StoreV2", "\"NVPTXISD::StoreV2\"", "NVPTXISD::StoreV4", "\"NVPTXISD::StoreV4\"" ]

[]

[ "<s>", "const", "MCRegisterInfo", "*", "getRegInfo", "(", ")", "const", "{", "return", "RegInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "getRegInfo", "-", "Return", "information", "about", "the", "registers", "currently", "in", "use", "." ]

[ "Sparc" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZERO_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSIGN_EXTEND_INREG", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "BR_CCMASK", ":", "return", "combineBR_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "combineSELECT_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "GET_CCMASK", ":", "return", "combineGET_CCMASK", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "SystemZ", "SystemZ", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_INREG", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::FP_ROUND", "ISD::BSWAP", "SystemZISD::BR_CCMASK", "SystemZISD::SELECT_CCMASK", "SystemZISD::GET_CCMASK" ]

[]

[ "<s>", "void", "HexagonAsmInstPrinter", "::", "printInst", "(", "MCInst", "const", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "{", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "*", "MI", ")", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "*", "MI", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "std", "::", "string", "Buffer", ";", "{", "raw_string_ostream", "TempStream", "(", "Buffer", ")", ";", "RawPrinter", "->", "printInst", "(", "MI", ",", "TempStream", ",", "\"\"", ",", "STI", ")", ";", "}", "StringRef", "Contents", "(", "Buffer", ")", ";", "auto", "PacketBundle", "=", "Contents", ".", "rsplit", "(", "'\\n'", ")", ";", "auto", "HeadTail", "=", "PacketBundle", ".", "first", ".", "split", "(", "'\\n'", ")", ";", "auto", "Preamble", "=", "\"\\t{\\n\\t\\t\"", ";", "auto", "Separator", "=", "\"\"", ";", "while", "(", "!", "HeadTail", ".", "first", ".", "empty", "(", ")", ")", "{", "O", "<<", "Separator", ";", "StringRef", "Inst", ";", "auto", "Duplex", "=", "HeadTail", ".", "first", ".", "split", "(", "'\\v'", ")", ";", "if", "(", "!", "Duplex", ".", "second", ".", "empty", "(", ")", ")", "{", "O", "<<", "Duplex", ".", "first", "<<", "\"\\n\"", ";", "Inst", "=", "Duplex", ".", "second", ";", "}", "else", "Inst", "=", "Duplex", ".", "first", ";", "O", "<<", "Preamble", ";", "O", "<<", "Inst", ";", "HeadTail", "=", "HeadTail", ".", "second", ".", "split", "(", "'\\n'", ")", ";", "Preamble", "=", "\"\"", ";", "Separator", "=", "\"\\n\\t\\t\"", ";", "}", "O", "<<", "\"\\n\\t}\"", "<<", "PacketBundle", ".", "second", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"\"", "\"\\t{\\n\\t\\t\"", "\"\"", "\"\\n\"", "\"\"", "\"\\n\\t\\t\"", "\"\\n\\t}\"" ]

[]

[ "<s>", "const", "TGSISubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "TGSI", "TGSI" ]

[]

[ "<s>", "unsigned", "SystemZRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unxpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "hasFP", "(", "MF", ")", "?", "SystemZ", "::", "R11D", ":", "SystemZ", "::", "R15D", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "Offset", "=", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "getMemoryInstr", "(", "MI", ".", "getOpcode", "(", ")", ",", "Offset", ")", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "SystemZ", "SystemZ", "0", "\"Unxpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "SystemZ::R11D", "SystemZ::R15D", "1", "1", "0" ]

[]

[ "<s>", "unsigned", "getLinkageSize", "(", ")", "const", "{", "return", "LinkageSize", ";", "}", "</s>" ]

[ "getLinkageSize", "-", "Return", "the", "size", "of", "the", "PowerPC", "ABI", "linkage", "area", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "void", "aarch64_option_save", "(", "struct", "cl_target_option", "*", "ptr", ",", "struct", "gcc_options", "*", "opts", ")", "{", "ptr", "->", "x_aarch64_override_tune_string", "=", "opts", "->", "x_aarch64_override_tune_string", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_SAVE", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "alpha_align_insns_1", "(", "unsigned", "int", "max_align", ",", "rtx_insn", "*", "(", "*", "next_group", ")", "(", "rtx_insn", "*", ",", "int", "*", ",", "int", "*", ")", ",", "rtx", "(", "*", "next_nop", ")", "(", "int", "*", ")", ")", "{", "unsigned", "int", "align", ";", "int", "ofs", ";", "int", "prev_in_use", ",", "in_use", ",", "len", ",", "ldgp", ";", "rtx_insn", "*", "i", ",", "*", "next", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "if", "(", "align_functions", "<", "4", ")", "align", "=", "4", ";", "else", "if", "(", "(", "unsigned", "int", ")", "align_functions", "<", "max_align", ")", "align", "=", "align_functions", ";", "else", "align", "=", "max_align", ";", "ofs", "=", "prev_in_use", "=", "0", ";", "i", "=", "get_insns", "(", ")", ";", "if", "(", "NOTE_P", "(", "i", ")", ")", "i", "=", "next_nonnote_insn", "(", "i", ")", ";", "ldgp", "=", "alpha_function_needs_gp", "?", "8", ":", "0", ";", "while", "(", "i", ")", "{", "next", "=", "(", "*", "next_group", ")", "(", "i", ",", "&", "in_use", ",", "&", "len", ")", ";", "if", "(", "LABEL_P", "(", "i", ")", ")", "{", "unsigned", "int", "new_align", "=", "1", "<<", "label_to_alignment", "(", "i", ")", ";", "if", "(", "new_align", ">=", "align", ")", "{", "align", "=", "new_align", "<", "max_align", "?", "new_align", ":", "max_align", ";", "ofs", "=", "0", ";", "}", "else", "if", "(", "ofs", "&", "(", "new_align", "-", "1", ")", ")", "ofs", "=", "(", "ofs", "|", "(", "new_align", "-", "1", ")", ")", "+", "1", ";", "gcc_assert", "(", "!", "len", ")", ";", "}", "else", "if", "(", "in_use", "==", "0", ")", "{", "if", "(", "len", "<", "0", ")", "{", "ofs", "=", "0", ";", "align", "=", "4", ";", "len", "=", "0", ";", "}", "}", "else", "if", "(", "(", "int", ")", "align", "<", "len", ")", "{", "unsigned", "int", "new_log_align", "=", "len", ">", "8", "?", "4", ":", "3", ";", "rtx_insn", "*", "prev", ",", "*", "where", ";", "where", "=", "prev", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "!", "where", "||", "!", "LABEL_P", "(", "where", ")", ")", "where", "=", "i", ";", "if", "(", "!", "(", "TARGET_EXPLICIT_RELOCS", "&&", "prev", "&&", "CALL_P", "(", "prev", ")", ")", ")", "{", "emit_insn_before", "(", "gen_realign", "(", "GEN_INT", "(", "new_log_align", ")", ")", ",", "where", ")", ";", "align", "=", "1", "<<", "new_log_align", ";", "ofs", "=", "0", ";", "}", "}", "else", "if", "(", "ldgp", ">", "0", ")", "ldgp", "-=", "len", ";", "else", "if", "(", "ofs", "+", "len", ">", "(", "int", ")", "align", ")", "{", "int", "nop_count", "=", "(", "align", "-", "ofs", ")", "/", "4", ";", "rtx_insn", "*", "where", ";", "where", "=", "prev_nonnote_insn", "(", "i", ")", ";", "if", "(", "where", ")", "{", "if", "(", "LABEL_P", "(", "where", ")", ")", "{", "rtx_insn", "*", "where2", "=", "prev_nonnote_insn", "(", "where", ")", ";", "if", "(", "where2", "&&", "JUMP_P", "(", "where2", ")", ")", "where", "=", "where2", ";", "}", "else", "if", "(", "NONJUMP_INSN_P", "(", "where", ")", ")", "where", "=", "i", ";", "}", "else", "where", "=", "i", ";", "do", "emit_insn_before", "(", "(", "*", "next_nop", ")", "(", "&", "prev_in_use", ")", ",", "where", ")", ";", "while", "(", "--", "nop_count", ")", ";", "ofs", "=", "0", ";", "}", "ofs", "=", "(", "ofs", "+", "len", ")", "&", "(", "align", "-", "1", ")", ";", "prev_in_use", "=", "in_use", ";", "i", "=", "next", ";", "}", "}", "</s>" ]

[ "The", "instruction", "group", "alignment", "main", "loop", "." ]

[ "alpha", "4", "4", "0", "8", "0", "1", "0", "1", "1", "1", "0", "0", "0", "4", "0", "8", "4", "3", "1", "0", "0", "4", "0", "1" ]

[]

[ "<s>", "static", "ARMCC", "::", "CondCodes", "getPredicate", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCInstrInfo", "&", "Info", ",", "unsigned", "&", "PredReg", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "Info", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "int", "PIdx", "=", "Desc", ".", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "==", "-", "1", ")", "{", "PredReg", "=", "0", ";", "return", "ARMCC", "::", "AL", ";", "}", "PredReg", "=", "Inst", ".", "getOperand", "(", "PIdx", "+", "1", ")", ".", "getReg", "(", ")", ";", "return", "static_cast", "<", "ARMCC", "::", "CondCodes", ">", "(", "Inst", ".", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "comparison", "predicate", "underlying", "the", "intrinsic", "." ]

[ "ARM", "ARMCC::CondCodes", "1", "0", "ARMCC::AL", "1", "ARMCC::CondCodes" ]

[]

[ "<s>", "bool", "LinuxAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "SwitchToTextSection", "(", "\"\\t.text\"", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "assert", "(", "DW", "&&", "\"Dwarf Writer is not available\"", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "MMI", ",", "O", ",", "this", ",", "TAI", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "CellSPU", "\"\\t.text\"", "\"Dwarf Writer is not available\"" ]

[]

[ "<s>", "static", "bool", "aarch64_array_mode_supported_p", "(", "machine_mode", "mode", ",", "unsigned", "HOST_WIDE_INT", "nelems", ")", "{", "if", "(", "TARGET_SIMD", "&&", "(", "AARCH64_VALID_SIMD_QREG_MODE", "(", "mode", ")", "||", "AARCH64_VALID_SIMD_DREG_MODE", "(", "mode", ")", ")", "&&", "(", "nelems", ">=", "2", "&&", "nelems", "<=", "4", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "target", "hook", "TARGET_ARRAY_MODE_SUPPORTED_P", "." ]

[ "aarch64", "2", "4" ]

[]

[ "<s>", "static", "void", "or1k_save_reg", "(", "int", "regno", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "rtx", "insn", "=", "emit_move_insn", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "rtl", "to", "save", "register", "REGNO", "contents", "to", "stack", "memory", "at", "the", "given", "OFFSET", "from", "the", "current", "stack", "pointer", "." ]

[ "or1k", "1" ]

[]

[ "<s>", "static", "int", "ix86_vec_cost", "(", "machine_mode", "mode", ",", "int", "cost", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "cost", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "128", "&&", "TARGET_SSE_SPLIT_REGS", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "64", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "128", "&&", "TARGET_AVX256_SPLIT_REGS", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "128", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "256", "&&", "TARGET_AVX512_SPLIT_REGS", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "256", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "vector", "operation", "in", "MODE", "given", "that", "scalar", "version", "has", "COST", ".", "If", "PARALLEL", "is", "true", "assume", "that", "CPU", "has", "more", "than", "one", "unit", "performing", "the", "operation", "." ]

[ "i386", "128", "64", "128", "128", "256", "256" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "decomposeMulByConstant", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "APInt", "MulC", ";", "if", "(", "!", "ISD", "::", "isConstantSplatVector", "(", "C", ".", "getNode", "(", ")", ",", "MulC", ")", ")", "return", "false", ";", "while", "(", "getTypeAction", "(", "Context", ",", "VT", ")", "!=", "TypeLegal", ")", "VT", "=", "getTypeToTransformTo", "(", "Context", ",", "VT", ")", ";", "unsigned", "EltSizeInBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "if", "(", "isOperationLegal", "(", "ISD", "::", "MUL", ",", "VT", ")", "&&", "EltSizeInBits", "<=", "32", "&&", "(", "EltSizeInBits", "!=", "32", "||", "!", "Subtarget", ".", "isPMULLDSlow", "(", ")", ")", ")", "return", "false", ";", "return", "(", "MulC", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "MulC", "-", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "1", "-", "MulC", ")", ".", "isPowerOf2", "(", ")", "||", "(", "-", "(", "MulC", "+", "1", ")", ")", ".", "isPowerOf2", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "X86", "X86", "ISD::isConstantSplatVector", "ISD::MUL", "32", "32", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "M68kMachineFunctionInfo", "*", "M68kFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "M68kFI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "Register", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "M68k", "M68k", "M68k", "M68k", "M68k", "M68k", "0" ]

[]

[ "<s>", "SDValue", "TriCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "Type", "*", "t", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_TriCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "t", "->", "isPointerTy", "(", ")", ")", "VA", ".", "convertToReg", "(", "TriCore", "::", "A2", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "TriCoreISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "TriCore", "TriCore", "ISD::OutputArg", "\"VarArg not supported\"", "16", "TriCore", "4", "1", "0", "TriCore::A2", "\"Can only return in registers!\"", "1", "0", "TriCoreISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "s390_valid_shift_count", "(", "rtx", "op", ",", "HOST_WIDE_INT", "implicit_mask", ")", "{", "while", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "subreg_lowpart_p", "(", "op", ")", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "AND", ")", "{", "rtx", "op1", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "imm", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "SUBREG", "&&", "subreg_lowpart_p", "(", "op1", ")", ")", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "!", "(", "register_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", "||", "GET_CODE", "(", "op1", ")", "==", "PLUS", ")", ")", "return", "false", ";", "if", "(", "!", "immediate_operand", "(", "imm", ",", "GET_MODE", "(", "imm", ")", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "imm", ")", ";", "if", "(", "implicit_mask", ">", "0", "&&", "(", "val", "&", "implicit_mask", ")", "!=", "implicit_mask", ")", "return", "false", ";", "op", "=", "op1", ";", "}", "return", "s390_decompose_addrstyle_without_index", "(", "op", ",", "NULL", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Check", "that", "OP", "is", "a", "valid", "shift", "count", "operand", ".", "It", "should", "be", "of", "the", "following", "structure", ":", "(", "subreg", "(", "and", "(", "plus", "(", "reg", "imm_op", ")", ")", "2^k-1", ")", "7", ")", "where", "subreg", ",", "and", "and", "plus", "are", "optional", ".", "If", "IMPLICIT_MASK", "is", ">", "0", "and", "OP", "contains", "and", "(", "AND", "...", "immediate", ")", "it", "is", "checked", "whether", "IMPLICIT_MASK", "and", "the", "immediate", "match", ".", "Otherwise", ",", "no", "checking", "is", "performed", "." ]

[ "s390", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "bfin_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "force", "certain", "constants", "to", "memory", ".", "If", "we", "decide", "we", "ca", "n't", ",", "the", "caller", "should", "be", "able", "to", "cope", "with", "it", "in", "another", "way", "." ]

[ "bfin" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "void", "unicosmk_output_ssib", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ")", "{", "int", "len", ";", "int", "i", ";", "rtx", "x", ";", "rtx", "ciw", ";", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "ssib_section", "(", ")", ";", "fprintf", "(", "file", ",", "\"\\t.endp\\n\\n\\t.psect\\t%s%s,data\\n\"", ",", "user_label_prefix", ",", "unicosmk_ssib_name", "(", ")", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t^X20008%2.2X28\\n\"", ",", "len", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "fprintf", "(", "file", ",", "\"\\t.byte\\t%d\\n\"", ",", "(", "int", ")", "(", "fnname", "[", "i", "]", ")", ")", ";", "if", "(", "(", "len", "%", "8", ")", "==", "0", ")", "fputs", "(", "\"\\t.quad\\t0\\n\"", ",", "file", ")", ";", "else", "fprintf", "(", "file", ",", "\"\\t.bits\\t%d : 0\\n\"", ",", "(", "8", "-", "(", "len", "%", "8", ")", ")", "*", "8", ")", ";", "for", "(", "x", "=", "machine", "->", "first_ciw", ";", "x", ";", "x", "=", "XEXP", "(", "x", ",", "1", ")", ")", "{", "ciw", "=", "XEXP", "(", "x", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t\"", "HOST_WIDE_INT_PRINT_DOUBLE_HEX", "\"\\n\"", ",", "CONST_DOUBLE_HIGH", "(", "ciw", ")", ",", "CONST_DOUBLE_LOW", "(", "ciw", ")", ")", ";", "fprintf", "(", "file", ",", "\"\\t.quad\\t\"", "HOST_WIDE_INT_PRINT_HEX", "\"\\n\"", ",", "INTVAL", "(", "ciw", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "static", "subroutine", "information", "block", "for", "the", "current", "function", "." ]

[ "alpha", "\"\\t.endp\\n\\n\\t.psect\\t%s%s,data\\n\"", "\"\\t.quad\\t^X20008%2.2X28\\n\"", "\"\\t.quad\\t0\\n\"", "\"\\t.quad\\t\"", "\"\\t.quad\\t0\\n\"", "\"\\t.quad\\t0\\n\"", "0", "\"\\t.byte\\t%d\\n\"", "8", "0", "\"\\t.quad\\t0\\n\"", "\"\\t.bits\\t%d : 0\\n\"", "8", "8", "8", "1", "0", "\"\\t.quad\\t\"", "\"\\n\"", "\"\\t.quad\\t\"", "\"\\n\"" ]

[]

[ "<s>", "Value", "*", "HexagonTargetLowering", "::", "emitStoreConditional", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "BasicBlock", "*", "BB", "=", "Builder", ".", "GetInsertBlock", "(", ")", ";", "Module", "*", "M", "=", "BB", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "Ty", "=", "Val", "->", "getType", "(", ")", ";", "unsigned", "SZ", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "Type", "*", "CastTy", "=", "Builder", ".", "getIntNTy", "(", "SZ", ")", ";", "assert", "(", "(", "SZ", "==", "32", "||", "SZ", "==", "64", ")", "&&", "\"Only 32/64-bit atomic stores supported\"", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "(", "SZ", "==", "32", ")", "?", "Intrinsic", "::", "hexagon_S2_storew_locked", ":", "Intrinsic", "::", "hexagon_S4_stored_locked", ";", "Value", "*", "Fn", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "IntID", ")", ";", "unsigned", "AS", "=", "Addr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "CastTy", "->", "getPointerTo", "(", "AS", ")", ")", ";", "Val", "=", "Builder", ".", "CreateBitCast", "(", "Val", ",", "CastTy", ")", ";", "Value", "*", "Call", "=", "Builder", ".", "CreateCall", "(", "Fn", ",", "{", "Addr", ",", "Val", "}", ",", "\"stcx\"", ")", ";", "Value", "*", "Cmp", "=", "Builder", ".", "CreateICmpEQ", "(", "Call", ",", "Builder", ".", "getInt32", "(", "0", ")", ",", "\"\"", ")", ";", "Value", "*", "Ext", "=", "Builder", ".", "CreateZExt", "(", "Cmp", ",", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Ext", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "Hexagon", "Hexagon", "32", "64", "\"Only 32/64-bit atomic stores supported\"", "Intrinsic::ID", "32", "Intrinsic::hexagon_S2_storew_locked", "Intrinsic::hexagon_S4_stored_locked", "Intrinsic::getDeclaration", "\"stcx\"", "0", "\"\"" ]

[]

[ "<s>", "FastISel", "*", "PPC", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "FuncInfo", ",", "const", "TargetLibraryInfo", "*", "LibInfo", ")", "{", "const", "TargetMachine", "&", "TM", "=", "FuncInfo", ".", "MF", "->", "getTarget", "(", ")", ";", "const", "PPCSubtarget", "*", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "isPPC64", "(", ")", "&&", "Subtarget", "->", "isSVR4ABI", "(", ")", ")", "return", "new", "PPCFastISel", "(", "FuncInfo", ",", "LibInfo", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "PowerPC", "PPC::createFastISel", "PPC", "PPC", "PPC", "PPC", "0" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "ARMTargetLowering", "::", "findRepresentativeClass", "(", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "0", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v1i64", ":", "case", "MVT", "::", "v2f32", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "if", "(", "Subtarget", "->", "useNEONForSinglePrecisionFP", "(", ")", ")", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v4i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "4", ";", "break", ";", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "8", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "ARM", "ARM", "0", "1", "MVT::f32", "MVT::f64", "MVT::v8i8", "MVT::v4i16", "MVT::v2i32", "MVT::v1i64", "MVT::v2f32", "ARM::DPRRegClass", "2", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "ARM::DPRRegClass", "2", "MVT::v4i64", "ARM::DPRRegClass", "4", "MVT::v8i64", "ARM::DPRRegClass", "8" ]

[]

[ "<s>", "int", "arc_double_limm_p", "(", "rtx", "value", ")", "{", "HOST_WIDE_INT", "low", ",", "high", ";", "gcc_assert", "(", "GET_CODE", "(", "value", ")", "==", "CONST_DOUBLE", ")", ";", "low", "=", "CONST_DOUBLE_LOW", "(", "value", ")", ";", "high", "=", "CONST_DOUBLE_HIGH", "(", "value", ")", ";", "if", "(", "low", "&", "0x80000000", ")", "{", "return", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0xffffffff", "&&", "high", "==", "0", ")", "||", "(", "(", "(", "low", "&", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "==", "-", "(", "unsigned", "HOST_WIDE_INT", ")", "0x80000000", ")", "&&", "high", "==", "-", "1", ")", ")", ";", "}", "else", "{", "return", "(", "unsigned", "HOST_WIDE_INT", ")", "low", "<=", "0x7fffffff", "&&", "high", "==", "0", ";", "}", "}", "</s>" ]

[ "Return", "1", "if", "VALUE", ",", "a", "const_double", ",", "will", "fit", "in", "a", "limm", "(", "4", "byte", "number", ")", ".", "We", "assume", "the", "value", "can", "be", "either", "signed", "or", "unsigned", "." ]

[ "arc", "0x80000000", "0xffffffff", "0", "0x80000000", "0x80000000", "1", "0x7fffffff", "0" ]

[]

[ "<s>", "bool", "X86ATTAsmParser", "::", "ParseInstruction", "(", "const", "StringRef", "&", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "StringRef", "PatchedName", "=", "StringSwitch", "<", "StringRef", ">", "(", "Name", ")", ".", "Case", "(", "\"sal\"", ",", "\"shl\"", ")", ".", "Case", "(", "\"salb\"", ",", "\"shlb\"", ")", ".", "Case", "(", "\"sall\"", ",", "\"shll\"", ")", ".", "Case", "(", "\"salq\"", ",", "\"shlq\"", ")", ".", "Case", "(", "\"salw\"", ",", "\"shlw\"", ")", ".", "Case", "(", "\"repe\"", ",", "\"rep\"", ")", ".", "Case", "(", "\"repz\"", ",", "\"rep\"", ")", ".", "Case", "(", "\"repnz\"", ",", "\"repne\"", ")", ".", "Default", "(", "Name", ")", ";", "Operands", ".", "push_back", "(", "X86Operand", "::", "CreateToken", "(", "PatchedName", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Star", ")", ")", "{", "SMLoc", "Loc", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "X86Operand", "::", "CreateToken", "(", "\"*\"", ",", "Loc", ")", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "}", "if", "(", "X86Operand", "*", "Op", "=", "ParseOperand", "(", ")", ")", "Operands", ".", "push_back", "(", "Op", ")", ";", "else", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "X86Operand", "*", "Op", "=", "ParseOperand", "(", ")", ")", "Operands", ".", "push_back", "(", "Op", ")", ";", "else", "return", "true", ";", "}", "}", "if", "(", "(", "Name", ".", "startswith", "(", "\"shr\"", ")", "||", "Name", ".", "startswith", "(", "\"sar\"", ")", "||", "Name", ".", "startswith", "(", "\"shl\"", ")", ")", "&&", "Operands", ".", "size", "(", ")", "==", "3", "&&", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "isImm", "(", ")", "&&", "isa", "<", "MCConstantExpr", ">", "(", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "getImm", "(", ")", ")", "&&", "cast", "<", "MCConstantExpr", ">", "(", "static_cast", "<", "X86Operand", "*", ">", "(", "Operands", "[", "1", "]", ")", "->", "getImm", "(", ")", ")", "->", "getValue", "(", ")", "==", "1", ")", "{", "delete", "Operands", "[", "1", "]", ";", "Operands", ".", "erase", "(", "Operands", ".", "begin", "(", ")", "+", "1", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "X86", "X86", "\"sal\"", "\"shl\"", "\"salb\"", "\"shlb\"", "\"sall\"", "\"shll\"", "\"salq\"", "\"shlq\"", "\"salw\"", "\"shlw\"", "\"repe\"", "\"rep\"", "\"repz\"", "\"rep\"", "\"repnz\"", "\"repne\"", "X86Operand::CreateToken", "X86Operand::CreateToken", "\"*\"", "X86", "X86", "\"shr\"", "\"sar\"", "\"shl\"", "3", "X86", "1", "X86", "1", "X86", "1", "1", "1", "1" ]

[]

[ "<s>", "int", "arc_label_align", "(", "rtx_insn", "*", "label", ")", "{", "if", "(", "align_labels", ".", "levels", "[", "0", "]", ".", "log", "<", "1", ")", "{", "rtx_insn", "*", "next", "=", "next_nonnote_nondebug_insn", "(", "label", ")", ";", "if", "(", "INSN_P", "(", "next", ")", "&&", "recog_memoized", "(", "next", ")", ">=", "0", ")", "return", "1", ";", "}", "return", "align_labels", ".", "levels", "[", "0", "]", ".", "log", ";", "}", "</s>" ]

[ "Oddly", "enough", ",", "sometimes", "we", "get", "a", "zero", "overhead", "loop", "that", "branch", "shortening", "does", "n't", "think", "is", "a", "loop", "-", "observed", "with", "compile/pr24883.c", "-O3", "-fomit-frame-pointer", "-funroll-loops", ".", "Make", "sure", "to", "include", "the", "alignment", "visible", "for", "branch", "shortening", "(", "we", "actually", "align", "the", "loop", "insn", "before", "it", ",", "but", "that", "is", "equivalent", "since", "the", "loop", "insn", "is", "4", "byte", "long", ".", ")" ]

[ "arc", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "MSP430AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MSP430MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "int", "tilegx_pic_address_needs_scratch", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "(", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "requires", "a", "scratch", "register", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "X", "satisfies", "CONSTANT_P", "." ]

[ "tilegx", "0", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "SDValue", "F2003fTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "F2003f", "F2003f", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "tree", "rs6000_handle_struct_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "*", "type", "=", "NULL", ";", "if", "(", "DECL_P", "(", "*", "node", ")", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "==", "TYPE_DECL", ")", "type", "=", "&", "TREE_TYPE", "(", "*", "node", ")", ";", "}", "else", "type", "=", "node", ";", "if", "(", "!", "(", "type", "&&", "(", "TREE_CODE", "(", "*", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "*", "type", ")", "==", "UNION_TYPE", ")", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "(", "is_attribute_p", "(", "\"ms_struct\"", ",", "name", ")", "&&", "lookup_attribute", "(", "\"gcc_struct\"", ",", "TYPE_ATTRIBUTES", "(", "*", "type", ")", ")", ")", "||", "(", "(", "is_attribute_p", "(", "\"gcc_struct\"", ",", "name", ")", "&&", "lookup_attribute", "(", "\"ms_struct\"", ",", "TYPE_ATTRIBUTES", "(", "*", "type", ")", ")", ")", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE incompatible attribute ignored\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "ms_struct", "''", "or", "``", "gcc_struct", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "rs6000", "\"%qE attribute ignored\"", "\"ms_struct\"", "\"gcc_struct\"", "\"gcc_struct\"", "\"ms_struct\"", "\"%qE incompatible attribute ignored\"" ]

[]

[ "<s>", "bool", "CAHPAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "CAHP", "CAHP" ]

[]

[ "<s>", "static", "void", "mips16_copy_fpr_return_value", "(", "void", ")", "{", "rtx", "fn", ",", "insn", ",", "retval", ";", "tree", "return_type", ";", "machine_mode", "return_mode", ";", "const", "char", "*", "name", ";", "return_type", "=", "DECL_RESULT", "(", "current_function_decl", ")", ";", "return_mode", "=", "DECL_MODE", "(", "return_type", ")", ";", "name", "=", "ACONCAT", "(", "(", "\"__mips16_ret_\"", ",", "mips16_call_stub_mode_suffix", "(", "return_mode", ")", ",", "NULL", ")", ")", ";", "fn", "=", "mips16_stub_function", "(", "name", ")", ";", "SYMBOL_REF_FLAGS", "(", "fn", ")", "|=", "SYMBOL_FLAG_BIND_NOW", ";", "retval", "=", "gen_rtx_REG", "(", "return_mode", ",", "GP_RETURN", ")", ";", "insn", "=", "mips_expand_call", "(", "MIPS_CALL_EPILOGUE", ",", "retval", ",", "fn", ",", "const0_rtx", ",", "NULL_RTX", ",", "false", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "retval", ")", ";", "}", "</s>" ]

[ "The", "current", "function", "is", "a", "MIPS16", "function", "that", "returns", "a", "value", "in", "an", "FPR", ".", "Copy", "the", "return", "value", "from", "its", "soft-float", "to", "its", "hard-float", "location", ".", "libgcc2", "has", "special", "non-MIPS16", "helper", "functions", "for", "each", "case", "." ]

[ "mips", "\"__mips16_ret_\"" ]

[]

[ "<s>", "bool", "aarch64_pad_reg_upward", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "first", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", "&&", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "(", "type", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "size", "<", "2", "*", "UNITS_PER_WORD", ")", "return", "true", ";", "}", "return", "!", "BYTES_BIG_ENDIAN", ";", "}", "</s>" ]

[ "Similarly", ",", "for", "use", "by", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "FIRST", ")", ".", "It", "specifies", "padding", "for", "the", "last", "(", "may", "also", "be", "the", "only", ")", "element", "of", "a", "block", "move", "between", "registers", "and", "memory", ".", "If", "assuming", "the", "block", "is", "in", "the", "memory", ",", "padding", "upward", "means", "that", "the", "last", "element", "is", "padded", "after", "its", "highest", "significant", "byte", ",", "while", "in", "downward", "padding", ",", "the", "last", "element", "is", "padded", "at", "the", "its", "least", "significant", "byte", "side", ".", "Small", "aggregates", "and", "small", "complex", "types", "are", "always", "padded", "upwards", ".", "We", "do", "n't", "need", "to", "worry", "about", "homogeneous", "floating-point", "or", "short-vector", "aggregates", ";", "their", "move", "is", "not", "affected", "by", "the", "padding", "direction", "determined", "here", ".", "Regardless", "of", "endianness", ",", "each", "element", "of", "such", "an", "aggregate", "is", "put", "in", "the", "least", "significant", "bits", "of", "a", "fp/simd", "register", ".", "Return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ",", "and", "return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "isFuncletReturnInstr", "(", "*", "MI", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "{", "if", "(", "STI", ".", "is32Bit", "(", ")", ")", "return", "true", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CATCHRET", ")", "{", "const", "Function", "&", "F", "=", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", ";", "bool", "IsSEH", "=", "isAsynchronousEHPersonality", "(", "classifyEHPersonality", "(", "F", ".", "getPersonalityFn", "(", ")", ")", ")", ";", "if", "(", "IsSEH", ")", "return", "true", ";", "}", "}", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "X86", "X86", "X86::CATCHRET", "0", "X86::GR64RegClass", "X86::GR32RegClass", "X86::POP64r", "X86::POP32r", "0", "X86::GR64RegClass", "X86::GR32RegClass" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "return", "TII", "->", "isInlineConstant", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "AMDGPU", "SI", "SI" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ",", "bool", "is64Bit", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "X86SSELevel", "(", "NoMMXSSE", ")", ",", "X863DNowLevel", "(", "NoThreeDNow", ")", ",", "HasCMov", "(", "false", ")", ",", "HasX86_64", "(", "false", ")", ",", "HasPOPCNT", "(", "false", ")", ",", "HasSSE4A", "(", "false", ")", ",", "HasAES", "(", "false", ")", ",", "HasPCLMUL", "(", "false", ")", ",", "HasFMA", "(", "false", ")", ",", "HasFMA4", "(", "false", ")", ",", "HasXOP", "(", "false", ")", ",", "HasMOVBE", "(", "false", ")", ",", "HasRDRAND", "(", "false", ")", ",", "HasF16C", "(", "false", ")", ",", "HasFSGSBase", "(", "false", ")", ",", "HasLZCNT", "(", "false", ")", ",", "HasBMI", "(", "false", ")", ",", "HasBMI2", "(", "false", ")", ",", "IsBTMemSlow", "(", "false", ")", ",", "IsUAMemFast", "(", "false", ")", ",", "HasVectorUAMem", "(", "false", ")", ",", "HasCmpxchg16b", "(", "false", ")", ",", "UseLeaForSP", "(", "false", ")", ",", "HasSlowDivide", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "MaxInlineSizeThreshold", "(", "128", ")", ",", "TargetTriple", "(", "TT", ")", ",", "In64BitMode", "(", "is64Bit", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", "||", "!", "CPU", ".", "empty", "(", ")", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "||", "defined", "(", "__x86_64__", ")", "||", "defined", "(", "_M_AMD64", ")", "||", "defined", "(", "_M_X64", ")", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "std", "::", "string", "FullFS", "=", "FS", ";", "if", "(", "In64BitMode", ")", "{", "if", "(", "!", "FullFS", ".", "empty", "(", ")", ")", "FullFS", "=", "\"+64bit,+sse2,\"", "+", "FullFS", ";", "else", "FullFS", "=", "\"+64bit,+sse2\"", ";", "}", "ParseSubtargetFeatures", "(", "CPUName", ",", "FullFS", ")", ";", "}", "else", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "{", "CPUName", "=", "sys", "::", "getHostCPUName", "(", ")", ";", "CPUName", "=", "\"generic\"", ";", "}", "AutoDetectSubtargetFeatures", "(", ")", ";", "if", "(", "In64BitMode", ")", "{", "HasX86_64", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "Feature64Bit", ")", ";", "HasCMov", "=", "true", ";", "ToggleFeature", "(", "X86", "::", "FeatureCMOV", ")", ";", "if", "(", "X86SSELevel", "<", "SSE2", ")", "{", "X86SSELevel", "=", "SSE2", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE1", ")", ";", "ToggleFeature", "(", "X86", "::", "FeatureSSE2", ")", ";", "}", "}", "}", "InitMCProcessorInfo", "(", "CPUName", ",", "FS", ")", ";", "if", "(", "X86ProcFamily", "==", "IntelAtom", ")", "PostRAScheduler", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "In64BitMode", ")", "ToggleFeature", "(", "X86", "::", "Mode64Bit", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Subtarget features: SSELevel \"", "<<", "X86SSELevel", "<<", "\", 3DNowLevel \"", "<<", "X863DNowLevel", "<<", "\", 64bit \"", "<<", "HasX86_64", "<<", "\"\\n\"", ")", ";", "assert", "(", "(", "!", "In64BitMode", "||", "HasX86_64", ")", "&&", "\"64-bit code requested on a subtarget that doesn't support it!\"", ")", ";", "if", "(", "StackAlignOverride", ")", "stackAlignment", "=", "StackAlignOverride", ";", "else", "if", "(", "isTargetDarwin", "(", ")", "||", "isTargetFreeBSD", "(", ")", "||", "isTargetLinux", "(", ")", "||", "isTargetSolaris", "(", ")", "||", "In64BitMode", ")", "stackAlignment", "=", "16", ";", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "4", "128", "\"generic\"", "\"+64bit,+sse2,\"", "\"+64bit,+sse2\"", "\"generic\"", "X86", "X86::Feature64Bit", "X86::FeatureCMOV", "X86", "X86", "X86::FeatureSSE1", "X86::FeatureSSE2", "X86", "X86::Mode64Bit", "\"Subtarget features: SSELevel \"", "X86", "\", 3DNowLevel \"", "X86", "\", 64bit \"", "X86", "\"\\n\"", "X86", "\"64-bit code requested on a subtarget that doesn't support it!\"", "16" ]

[]

[ "<s>", "static", "bool", "ix86_use_mask_cmp_p", "(", "machine_mode", "mode", ",", "machine_mode", "cmp_mode", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "return", "true", ";", "gcc_assert", "(", "!", "op_true", "==", "!", "op_false", ")", ";", "if", "(", "!", "op_true", "||", "!", "ix86_valid_mask_cmp_mode", "(", "cmp_mode", ")", ")", "return", "false", ";", "if", "(", "op_false", "==", "CONST0_RTX", "(", "mode", ")", "||", "op_true", "==", "CONST0_RTX", "(", "mode", ")", "||", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "(", "op_true", "==", "CONSTM1_RTX", "(", "mode", ")", "||", "op_false", "==", "CONSTM1_RTX", "(", "mode", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "mask", "comparison", "should", "be", "used", "." ]

[ "i386", "64" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "STI", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isCmseNSEntryFunction", "(", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "shouldSignReturnAddress", "(", "false", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "PPCSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "initialize", "(", "MF", ")", ";", "if", "(", "gatherVectorInstructions", "(", ")", ")", "{", "formWebs", "(", ")", ";", "recordUnoptimizableWebs", "(", ")", ";", "markSwapsForRemoval", "(", ")", ";", "Changed", "=", "removeSwaps", "(", ")", ";", "}", "delete", "EC", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "eco32_option_override", "(", "void", ")", "{", "init_machine_status", "=", "eco32_init_machine_status", ";", "}", "</s>" ]

[ "The", "TARGET_OPTION_OVERRIDE", "worker", ".", "All", "this", "curently", "does", "is", "set", "init_machine_status", "." ]

[ "eco32" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "if", "(", "Vector", "&&", "!", "ST", "->", "hasAltivec", "(", ")", "&&", "!", "ST", "->", "hasQPX", "(", ")", ")", "return", "0", ";", "return", "ST", "->", "hasVSX", "(", ")", "?", "64", ":", "32", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "PowerPC", "PPC", "0", "64", "32" ]

[]

[ "<s>", "static", "bool", "darwin_local_data_pic", "(", "rtx", "disp", ")", "{", "if", "(", "GET_CODE", "(", "disp", ")", "==", "MINUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "disp", ",", "0", ")", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "XEXP", "(", "disp", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "if", "(", "GET_CODE", "(", "XEXP", "(", "disp", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "{", "const", "char", "*", "sym_name", "=", "XSTR", "(", "XEXP", "(", "disp", ",", "1", ")", ",", "0", ")", ";", "if", "(", "!", "strcmp", "(", "sym_name", ",", "\"<pic base>\"", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Allow", "{", "LABEL", "|", "SYMBOL", "}", "_REF", "-", "SYMBOL_REF-FOR-PICBASE", "for", "Mach-O", "as", "this", "is", "used", "for", "to", "form", "addresses", "to", "local", "data", "when", "-fPIC", "is", "in", "use", "." ]

[ "i386", "0", "0", "1", "1", "0", "\"<pic base>\"" ]

[]

[ "<s>", "enum", "machine_mode", "ix86_fp_compare_mode", "(", "enum", "rtx_code", "code", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_IEEE_FP", "?", "CCFPUmode", ":", "CCFPmode", ";", "}", "</s>" ]

[ "Figure", "out", "whether", "to", "use", "ordered", "or", "unordered", "fp", "comparisons", ".", "Return", "the", "appropriate", "mode", "to", "use", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "TeakRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "dbgs", "(", ")", "<<", "\"shouldCoalesce\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"SrcRC: \"", "<<", "SrcRC", "->", "getID", "(", ")", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\"SubReg: \"", "<<", "SubReg", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\"DstRC: \"", "<<", "DstRC", "->", "getID", "(", ")", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\"DstSubReg: \"", "<<", "DstSubReg", "<<", "\"\\n\"", ";", "dbgs", "(", ")", "<<", "\"NewRC: \"", "<<", "NewRC", "->", "getID", "(", ")", "<<", "\"\\n\"", ";", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "Teak", "Teak", "\"shouldCoalesce\\n\"", "\"SrcRC: \"", "\"\\n\"", "\"SubReg: \"", "\"\\n\"", "\"DstRC: \"", "\"\\n\"", "\"DstSubReg: \"", "\"\\n\"", "\"NewRC: \"", "\"\\n\"" ]

[]

[ "<s>", "const", "ARMRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", "->", "hasAVX512", "(", ")", "?", "MVT", "::", "i1", ":", "MVT", "::", "i8", ";", "const", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "const", "EVT", "EltVT", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VT", ".", "is512BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "}", "if", "(", "Subtarget", "->", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "case", "64", ":", "return", "MVT", "::", "v64i1", ";", "}", "}", "if", "(", "VT", ".", "is256BitVector", "(", ")", "||", "VT", ".", "is128BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "hasVLX", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "2", ":", "return", "MVT", "::", "v2i1", ";", "case", "4", ":", "return", "MVT", "::", "v4i1", ";", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "}", "if", "(", "Subtarget", "->", "hasBWI", "(", ")", "&&", "Subtarget", "->", "hasVLX", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "8", ":", "return", "MVT", "::", "v8i1", ";", "case", "16", ":", "return", "MVT", "::", "v16i1", ";", "case", "32", ":", "return", "MVT", "::", "v32i1", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "X86", "X86", "MVT::i1", "MVT::i8", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "8", "MVT::v8i1", "16", "MVT::v16i1", "MVT::i8", "MVT::i16", "32", "MVT::v32i1", "64", "MVT::v64i1", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64", "2", "MVT::v2i1", "4", "MVT::v4i1", "8", "MVT::v8i1", "MVT::i8", "MVT::i16", "8", "MVT::v8i1", "16", "MVT::v16i1", "32", "MVT::v32i1" ]

[]

[ "<s>", "bool", "shouldTrackPressure", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "PostRA", "scheduling", "does", "not", "track", "pressure", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "construct_plt_address", "(", "rtx", "symbol", ")", "{", "rtx", "tmp", ",", "unspec", ";", "gcc_assert", "(", "GET_CODE", "(", "symbol", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "ix86_cmodel", "==", "CM_LARGE_PIC", "&&", "!", "TARGET_PECOFF", ")", ";", "gcc_assert", "(", "Pmode", "==", "DImode", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "symbol", ")", ",", "UNSPEC_PLTOFF", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_CONST", "(", "Pmode", ",", "unspec", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "tmp", ",", "pic_offset_table_rtx", ")", ")", ";", "return", "tmp", ";", "}", "</s>" ]

[ "For", "given", "symbol", "(", "function", ")", "construct", "code", "to", "compute", "address", "of", "it", "'s", "PLT", "entry", "in", "large", "x86-64", "PIC", "model", "." ]

[ "i386", "1" ]

[]

[ "<s>", "static", "void", "mn10300_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "nbytes", "+=", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", "+", "3", ")", "&", "~", "3", ";", "}", "</s>" ]

[ "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", ".", ")" ]

[ "mn10300", "3", "3" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "isLabel", "(", "AsmToken", "&", "Token", ")", "{", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "AsmToken", "const", "&", "Second", "=", "Lexer", ".", "getTok", "(", ")", ";", "AsmToken", "Third", "=", "Lexer", ".", "peekTok", "(", ")", ";", "StringRef", "String", "=", "Token", ".", "getString", "(", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "LCurly", ")", "||", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "RCurly", ")", ")", "return", "false", ";", "if", "(", "String", ".", "lower", "(", ")", "==", "\"vwhist256\"", "&&", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", "&&", "Third", ".", "getString", "(", ")", ".", "lower", "(", ")", "==", "\"sat\"", ")", "return", "false", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "Identifier", ")", ")", "return", "true", ";", "if", "(", "!", "matchRegister", "(", "String", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "assert", "(", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", ")", ";", "StringRef", "Raw", "(", "String", ".", "data", "(", ")", ",", "Third", ".", "getString", "(", ")", ".", "data", "(", ")", "-", "String", ".", "data", "(", ")", "+", "Third", ".", "getString", "(", ")", ".", "size", "(", ")", ")", ";", "std", "::", "string", "Collapsed", "=", "std", "::", "string", "(", "Raw", ")", ";", "Collapsed", ".", "erase", "(", "llvm", "::", "remove_if", "(", "Collapsed", ",", "isspace", ")", ",", "Collapsed", ".", "end", "(", ")", ")", ";", "StringRef", "Whole", "=", "Collapsed", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "DotSplit", "=", "Whole", ".", "split", "(", "'.'", ")", ";", "if", "(", "!", "matchRegister", "(", "DotSplit", ".", "first", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "Hexagon", "Hexagon", "\"vwhist256\"", "\"sat\"" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_move", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "!", "BYTES_BIG_ENDIAN", "&&", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "TARGET_P9_VECTOR", "&&", "!", "gpr_or_gpr_p", "(", "dest", ",", "source", ")", "&&", "(", "MEM_P", "(", "source", ")", "^", "MEM_P", "(", "dest", ")", ")", ")", ";", "if", "(", "MEM_P", "(", "source", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "dest", ")", "||", "SUBREG_P", "(", "dest", ")", ")", ";", "rs6000_emit_le_vsx_load", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "else", "{", "if", "(", "!", "REG_P", "(", "source", ")", ")", "source", "=", "force_reg", "(", "mode", ",", "source", ")", ";", "rs6000_emit_le_vsx_store", "(", "dest", ",", "source", ",", "mode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "sequence", "representing", "a", "little-endian", "VSX", "load", "or", "store", ",", "moving", "data", "from", "SOURCE", "to", "DEST", "in", "mode", "MODE", ".", "This", "is", "done", "separately", "from", "rs6000_emit_move", "to", "ensure", "it", "is", "called", "only", "during", "expand", ".", "LE", "VSX", "loads", "and", "stores", "introduced", "later", "are", "handled", "with", "a", "split", ".", "The", "expand-time", "RTL", "generation", "allows", "us", "to", "optimize", "away", "redundant", "pairs", "of", "register-permutes", "." ]

[ "rs6000" ]

[]

[ "<s>", "char", "c6x_get_unit_specifier", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_units", "units", ";", "if", "(", "insn_info", ".", "exists", "(", ")", ")", "{", "int", "unit", "=", "INSN_INFO_ENTRY", "(", "INSN_UID", "(", "insn", ")", ")", ".", "reservation", ";", "return", "c6x_unit_names", "[", "unit", "]", "[", "0", "]", ";", "}", "units", "=", "get_attr_units", "(", "insn", ")", ";", "switch", "(", "units", ")", "{", "case", "UNITS_D", ":", "case", "UNITS_DL", ":", "case", "UNITS_DS", ":", "case", "UNITS_DLS", ":", "case", "UNITS_D_ADDR", ":", "return", "'d'", ";", "break", ";", "case", "UNITS_L", ":", "case", "UNITS_LS", ":", "return", "'l'", ";", "break", ";", "case", "UNITS_S", ":", "return", "'s'", ";", "break", ";", "case", "UNITS_M", ":", "return", "'m'", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "single", "character", ",", "which", "is", "either", "'", "l", "'", ",", "'s", "'", ",", "'d", "'", "or", "'m", "'", ",", "which", "specifies", "the", "functional", "unit", "used", "by", "INSN", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_mode_valid_for_sched_fusion_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", "||", "(", "aarch64_vector_mode_supported_p", "(", "mode", ")", "&&", "known_eq", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "8", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "one", "of", "the", "modes", "for", "which", "we", "support", "LDP/STP", "operations", "." ]

[ "aarch64", "8" ]

[]

[ "<s>", "static", "bool", "contains_string_p", "(", "const", "char", "*", "*", "arr", ",", "const", "char", "*", "str", ")", "{", "bool", "res", "=", "false", ";", "if", "(", "arr", "[", "0", "]", "!=", "NULL", ")", "{", "res", "=", "strstr", "(", "arr", "[", "0", "]", ",", "str", ")", "!=", "NULL", ";", "if", "(", "res", ")", "return", "res", ";", "if", "(", "arr", "[", "1", "]", "!=", "NULL", ")", "return", "strstr", "(", "arr", "[", "1", "]", ",", "str", ")", "!=", "NULL", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "ARR", "contains", "STR", "in", "one", "of", "its", "two", "elements", "." ]

[ "aarch64", "0", "0", "1", "1" ]

[]

[ "<s>", "static", "int", "calc_live_regs", "(", "int", "*", "count", ")", "{", "int", "reg", ";", "int", "live_regs_mask", "=", "0", ";", "*", "count", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "FIRST_PSEUDO_REGISTER", ";", "reg", "++", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "reg", ")", ")", "{", "(", "*", "count", ")", "++", ";", "live_regs_mask", "|=", "(", "1", "<<", "reg", ")", ";", "}", "}", "return", "live_regs_mask", ";", "}", "</s>" ]

[ "Work", "out", "the", "registers", "which", "need", "to", "be", "saved", ",", "both", "as", "a", "mask", "and", "a", "count" ]

[ "mcore", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "LanaiRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "unsigned", "AVRAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "ExpectedKind", ")", "{", "AVROperand", "&", "Op", "=", "static_cast", "<", "AVROperand", "&", ">", "(", "AsmOp", ")", ";", "MatchClassKind", "Expected", "=", "static_cast", "<", "MatchClassKind", ">", "(", "ExpectedKind", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "MCConstantExpr", "const", "*", "Const", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "{", "int64_t", "RegNum", "=", "Const", "->", "getValue", "(", ")", ";", "std", "::", "ostringstream", "RegName", ";", "RegName", "<<", "\"r\"", "<<", "RegNum", ";", "RegNum", "=", "MatchRegisterName", "(", "RegName", ".", "str", "(", ")", ".", "c_str", "(", ")", ")", ";", "if", "(", "RegNum", "!=", "AVR", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "RegNum", ")", ";", "if", "(", "validateOperandClass", "(", "Op", ",", "Expected", ")", "==", "Match_Success", ")", "{", "return", "Match_Success", ";", "}", "}", "}", "}", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "isSubclass", "(", "Expected", ",", "MCK_DREGS", ")", ")", "{", "unsigned", "correspondingDREG", "=", "toDREG", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "correspondingDREG", "!=", "AVR", "::", "NoRegister", ")", "{", "Op", ".", "makeReg", "(", "correspondingDREG", ")", ";", "return", "validateOperandClass", "(", "Op", ",", "Expected", ")", ";", "}", "}", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "AVR", "AVR", "AVR", "AVR", "\"r\"", "AVR::NoRegister", "AVR::NoRegister" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "tGPRRegisterClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "SPRRegisterClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "DPRRegisterClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegisterClass", "0U", "ARM::GPRRegisterClass", "0U", "ARM::GPRRegisterClass", "MVT::f32", "0U", "ARM::SPRRegisterClass", "MVT::f64", "0U", "ARM::DPRRegisterClass" ]

[]

[ "<s>", "static", "void", "print_shift_count_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "HOST_WIDE_INT", "offset", ";", "rtx", "base", ";", "if", "(", "!", "s390_decompose_shift_count", "(", "op", ",", "&", "base", ",", "&", "offset", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "base", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "base", ")", "==", "REG", ")", ";", "gcc_assert", "(", "REGNO", "(", "base", ")", "<", "FIRST_PSEUDO_REGISTER", ")", ";", "gcc_assert", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "base", ")", ")", "==", "ADDR_REGS", ")", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", "&", "(", "(", "1", "<<", "12", ")", "-", "1", ")", ")", ";", "if", "(", "base", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "base", ")", "]", ")", ";", "}", "</s>" ]

[ "Output", "operand", "OP", "to", "stdio", "stream", "FILE", ".", "OP", "is", "an", "address", "(", "register", "+", "offset", ")", "which", "is", "not", "used", "to", "address", "data", ";", "instead", "the", "rightmost", "bits", "are", "interpreted", "as", "the", "value", "." ]

[ "s390", "1", "12", "1", "\"(%s)\"" ]

[]

[ "<s>", "static", "int", "num_insns_constant_gpr", "(", "HOST_WIDE_INT", "value", ")", "{", "if", "(", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "value", "+", "0x8000", ")", "<", "0x10000", ")", "return", "1", ";", "else", "if", "(", "(", "value", "&", "0xffff", ")", "==", "0", "&&", "(", "value", ">>", "31", "==", "-", "1", "||", "value", ">>", "31", "==", "0", ")", ")", "return", "1", ";", "else", "if", "(", "TARGET_POWERPC64", ")", "{", "HOST_WIDE_INT", "low", "=", "(", "(", "value", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "HOST_WIDE_INT", "high", "=", "value", ">>", "31", ";", "if", "(", "high", "==", "0", "||", "high", "==", "-", "1", ")", "return", "2", ";", "high", ">>=", "1", ";", "if", "(", "low", "==", "0", ")", "return", "num_insns_constant_gpr", "(", "high", ")", "+", "1", ";", "else", "if", "(", "high", "==", "0", ")", "return", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ";", "else", "return", "(", "num_insns_constant_gpr", "(", "high", ")", "+", "num_insns_constant_gpr", "(", "low", ")", "+", "1", ")", ";", "}", "else", "return", "2", ";", "}", "</s>" ]

[ "Helper", "for", "num_insns_constant", ".", "Calculate", "number", "of", "instructions", "to", "load", "VALUE", "to", "a", "single", "gpr", "using", "combinations", "of", "addi", ",", "addis", ",", "ori", ",", "oris", ",", "sldi", "and", "rldimi", "instructions", "." ]

[ "rs6000", "0x8000", "0x10000", "1", "0xffff", "0", "31", "1", "31", "0", "1", "0xffffffff", "0x80000000", "0x80000000", "31", "0", "1", "2", "1", "0", "1", "0", "1", "1", "2" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "ARG_UNUSED", "(", "subtarget", ")", ",", "machine_mode", "mode", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "switch", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "NVPTX_BUILTIN_SHUFFLE", ":", "case", "NVPTX_BUILTIN_SHUFFLELL", ":", "return", "nvptx_expand_shuffle", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ")", ";", "case", "NVPTX_BUILTIN_WORKER_ADDR", ":", "return", "nvptx_expand_shared_addr", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ",", "false", ")", ";", "case", "NVPTX_BUILTIN_VECTOR_ADDR", ":", "return", "nvptx_expand_shared_addr", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ",", "true", ")", ";", "case", "NVPTX_BUILTIN_CMP_SWAP", ":", "case", "NVPTX_BUILTIN_CMP_SWAPLL", ":", "return", "nvptx_expand_cmp_swap", "(", "exp", ",", "target", ",", "mode", ",", "ignore", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "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", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "static", "void", "mips_save_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "if", "(", "GET_MODE", "(", "reg", ")", "==", "DFmode", "&&", "(", "!", "TARGET_FLOAT64", "||", "mips_abi", "==", "ABI_32", ")", ")", "{", "rtx", "x1", ",", "x2", ";", "mips_emit_move_or_split", "(", "mem", ",", "reg", ",", "SPLIT_IF_NECESSARY", ")", ";", "x1", "=", "mips_frame_set", "(", "mips_subword", "(", "mem", ",", "false", ")", ",", "mips_subword", "(", "reg", ",", "false", ")", ")", ";", "x2", "=", "mips_frame_set", "(", "mips_subword", "(", "mem", ",", "true", ")", ",", "mips_subword", "(", "reg", ",", "true", ")", ")", ";", "mips_set_frame_expr", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "x1", ",", "x2", ")", ")", ")", ";", "}", "else", "mips_emit_save_slot_move", "(", "mem", ",", "reg", ",", "MIPS_PROLOGUE_TEMP", "(", "GET_MODE", "(", "reg", ")", ")", ")", ";", "}", "</s>" ]

[ "Save", "register", "REG", "to", "MEM", ".", "Make", "the", "instruction", "frame-related", "." ]

[ "mips", "2" ]

[]

[ "<s>", "void", "OR1KAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "(", "unsigned", ")", "Kind", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "OR1K", "OR1K", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_teardown", "(", "gcall", "*", "call", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_WORKER", ")", "{", "tree", "offset", "=", "gimple_call_arg", "(", "call", ",", "5", ")", ";", "tree", "call", "=", "nvptx_get_worker_red_addr", "(", "TREE_TYPE", "(", "var", ")", ",", "offset", ")", ";", "tree", "ptr", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "call", ")", ")", ";", "gimplify_assign", "(", "ptr", ",", "call", ",", "&", "seq", ")", ";", "var", "=", "build_simple_mem_ref", "(", "ptr", ")", ";", "TREE_THIS_VOLATILE", "(", "var", ")", "=", "1", ";", "}", "if", "(", "level", "!=", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "!", "integer_zerop", "(", "ref_to_res", ")", ")", "gimplify_assign", "(", "build_simple_mem_ref", "(", "ref_to_res", ")", ",", "var", ",", "&", "seq", ")", ";", "}", "if", "(", "lhs", ")", "gimplify_assign", "(", "lhs", ",", "var", ",", "&", "seq", ")", ";", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_TEARDOWN", "." ]

[ "nvptx", "2", "3", "5", "1", "1" ]

[]

[ "<s>", "void", "LEGDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "SelectMoveImmediate", "(", "N", ")", ";", "return", ";", "case", "ISD", "::", "BR_CC", ":", "SelectConditionalBranch", "(", "N", ")", ";", "return", ";", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "LEG", "LEG", "ISD::Constant", "ISD::BR_CC" ]

[]

[ "<s>", "const", "char", "*", "arc_short_long", "(", "rtx_insn", "*", "insn", ",", "const", "char", "*", "s_tmpl", ",", "const", "char", "*", "l_tmpl", ")", "{", "int", "is_short", "=", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "-", "1", ")", ";", "extract_constrain_insn_cached", "(", "insn", ")", ";", "return", "is_short", "?", "s_tmpl", ":", "l_tmpl", ";", "}", "</s>" ]

[ "Select", "between", "the", "instruction", "output", "templates", "s_tmpl", "(", "for", "short", "INSNs", ")", "and", "l_tmpl", "(", "for", "long", "INSNs", ")", "." ]

[ "arc", "1" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "LDDRdPtrQ", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "LDDWRdYQ", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot load this register from a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "AVR", "AVR", "0", "MVT::i8", "AVR::LDDRdPtrQ", "MVT::i16", "AVR::LDDWRdYQ", "\"Cannot load this register from a stack slot!\"", "0" ]

[]

[ "<s>", "void", "loongarch_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT_ABI", ")", "return", ";", "tree", "exceptions_var", "=", "create_tmp_var_raw", "(", "LARCH_ATYPE_USI", ")", ";", "tree", "fcsr_orig_var", "=", "create_tmp_var_raw", "(", "LARCH_ATYPE_USI", ")", ";", "tree", "fcsr_mod_var", "=", "create_tmp_var_raw", "(", "LARCH_ATYPE_USI", ")", ";", "tree", "const0", "=", "build_int_cst", "(", "LARCH_ATYPE_UQI", ",", "0", ")", ";", "tree", "get_fcsr", "=", "loongarch_builtin_decls", "[", "LARCH_MOVFCSR2GR", "]", ";", "tree", "set_fcsr", "=", "loongarch_builtin_decls", "[", "LARCH_MOVGR2FCSR", "]", ";", "tree", "get_fcsr_hold_call", "=", "build_call_expr", "(", "get_fcsr", ",", "1", ",", "const0", ")", ";", "tree", "hold_assign_orig", "=", "build4", "(", "TARGET_EXPR", ",", "LARCH_ATYPE_USI", ",", "fcsr_orig_var", ",", "get_fcsr_hold_call", ",", "NULL", ",", "NULL", ")", ";", "tree", "hold_mod_val", "=", "build2", "(", "BIT_AND_EXPR", ",", "LARCH_ATYPE_USI", ",", "fcsr_orig_var", ",", "build_int_cst", "(", "LARCH_ATYPE_USI", ",", "0xffe0ffe0", ")", ")", ";", "tree", "hold_assign_mod", "=", "build4", "(", "TARGET_EXPR", ",", "LARCH_ATYPE_USI", ",", "fcsr_mod_var", ",", "hold_mod_val", ",", "NULL", ",", "NULL", ")", ";", "tree", "set_fcsr_hold_call", "=", "build_call_expr", "(", "set_fcsr", ",", "2", ",", "const0", ",", "fcsr_mod_var", ")", ";", "tree", "hold_all", "=", "build2", "(", "COMPOUND_EXPR", ",", "LARCH_ATYPE_USI", ",", "hold_assign_orig", ",", "hold_assign_mod", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "hold_all", ",", "set_fcsr_hold_call", ")", ";", "*", "clear", "=", "build_call_expr", "(", "set_fcsr", ",", "2", ",", "const0", ",", "fcsr_mod_var", ")", ";", "tree", "get_fcsr_update_call", "=", "build_call_expr", "(", "get_fcsr", ",", "1", ",", "const0", ")", ";", "*", "update", "=", "build4", "(", "TARGET_EXPR", ",", "LARCH_ATYPE_USI", ",", "exceptions_var", ",", "get_fcsr_update_call", ",", "NULL", ",", "NULL", ")", ";", "tree", "set_fcsr_update_call", "=", "build_call_expr", "(", "set_fcsr", ",", "2", ",", "const0", ",", "fcsr_orig_var", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "update", ",", "set_fcsr_update_call", ")", ";", "tree", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "tree", "int_exceptions_var", "=", "fold_convert", "(", "integer_type_node", ",", "exceptions_var", ")", ";", "tree", "atomic_feraiseexcept_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "int_exceptions_var", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "*", "update", ",", "atomic_feraiseexcept_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "." ]

[ "loongarch", "0", "1", "0xffe0ffe0", "2", "2", "1", "2", "1" ]

[]

[ "<s>", "static", "bool", "isShift", "(", "MachineInstr", "*", "MI", ",", "int", "Opcode", ",", "int64_t", "Imm", ")", "{", "return", "(", "MI", "->", "getOpcode", "(", ")", "==", "Opcode", "&&", "!", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "Imm", ")", ";", "}", "</s>" ]

[ "Determine", "if", "the", "Opcode", "is", "one", "of", "the", "shift", "instructions", "." ]

[ "SystemZ", "2", "3" ]

[]