Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "hash_set", "<", "basic_block", ">", "get_all_predecessors", "(", "basic_block", "cfg_bb", ")", "{", "hash_set", "<", "basic_block", ">", "blocks", ";", "auto_vec", "<", "basic_block", ">", "work_list", ";", "hash_set", "<", "basic_block", ">", "visited_list", ";", "work_list", ".", "safe_push", "(", "cfg_bb", ")", ";", "while", "(", "!", "work_list", ".", "is_empty", "(", ")", ")", "{", "basic_block", "new_cfg_bb", "=", "work_list", ".", "pop", "(", ")", ";", "visited_list", ".", "add", "(", "new_cfg_bb", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "new_cfg_bb", "->", "preds", ")", "{", "if", "(", "!", "visited_list", ".", "contains", "(", "e", "->", "src", ")", ")", "work_list", ".", "safe_push", "(", "e", "->", "src", ")", ";", "blocks", ".", "add", "(", "e", "->", "src", ")", ";", "}", "}", "return", "blocks", ";", "}", "</s>" ]

[ "Recursively", "find", "all", "predecessor", "blocks", "for", "cfg_bb", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "arc_register_move_cost", "(", "machine_mode", ",", "enum", "reg_class", "from_class", ",", "enum", "reg_class", "to_class", ")", "{", "if", "(", "TARGET_ARC600", ")", "{", "if", "(", "to_class", "==", "MPY_WRITABLE_CORE_REGS", ")", "return", "3", ";", "else", "if", "(", "to_class", "==", "LPCOUNT_REG", ")", "return", "6", ";", "else", "if", "(", "to_class", "==", "WRITABLE_CORE_REGS", ")", "return", "6", ";", "}", "if", "(", "TARGET_ARC700", "&&", "(", "from_class", "==", "LPCOUNT_REG", "||", "from_class", "==", "ALL_CORE_REGS", "||", "from_class", "==", "WRITABLE_CORE_REGS", ")", ")", "return", "8", ";", "if", "(", "TARGET_ARC700", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>" ]

[ "Implement", "TARGET_REGISTER_MOVE_COST", "." ]

[ "arc", "3", "6", "6", "8", "100", "2" ]

[]

[ "<s>", "static", "unsigned", "parse_field", "(", "const", "char", "*", "field", ")", "{", "const", "char", "*", "rest", "=", "strchr", "(", "field", ",", "':'", ")", ";", "char", "*", "after", ";", "unsigned", "fint", "=", "strtol", "(", "rest", "+", "1", ",", "&", "after", ",", "16", ")", ";", "if", "(", "after", "==", "rest", "+", "1", ")", "return", "-", "1", ";", "return", "fint", ";", "}", "</s>" ]

[ "Returns", "the", "hex", "integer", "that", "is", "after", "'", ":", "'", "for", "the", "FIELD", ".", "Returns", "-1", "is", "returned", "if", "there", "was", "problem", "parsing", "the", "integer", "." ]

[ "aarch64", "1", "16", "1", "1" ]

[]

[ "<s>", "int", "aarch64_vec_fpconst_pow_of_2", "(", "rtx", "x", ")", "{", "int", "nelts", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_VECTOR", "||", "!", "CONST_VECTOR_NUNITS", "(", "x", ")", ".", "is_constant", "(", "&", "nelts", ")", ")", "return", "-", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "!=", "MODE_VECTOR_FLOAT", ")", "return", "-", "1", ";", "int", "firstval", "=", "aarch64_fpconst_pow_of_2", "(", "CONST_VECTOR_ELT", "(", "x", ",", "0", ")", ")", ";", "if", "(", "firstval", "<=", "0", ")", "return", "-", "1", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "nelts", ";", "i", "++", ")", "if", "(", "aarch64_fpconst_pow_of_2", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", "!=", "firstval", ")", "return", "-", "1", ";", "return", "firstval", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "vector", "of", "equal", "CONST_DOUBLE", "values", "and", "that", "value", "is", "Y", ",", "return", "the", "aarch64_fpconst_pow_of_2", "of", "Y", ".", "Otherwise", "return", "-1", "." ]

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

[]

[ "<s>", "OperandMatchResultTy", "X86AsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "bool", "Result", "=", "ParseRegister", "(", "RegNo", ",", "StartLoc", ",", "EndLoc", ",", "true", ")", ";", "bool", "PendingErrors", "=", "getParser", "(", ")", ".", "hasPendingError", "(", ")", ";", "getParser", "(", ")", ".", "clearPendingErrors", "(", ")", ";", "if", "(", "PendingErrors", ")", "return", "MatchOperand_ParseFail", ";", "if", "(", "Result", ")", "return", "MatchOperand_NoMatch", ";", "return", "MatchOperand_Success", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "MINA32MCExpr", "*", "MINA32MCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "MINA32MCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "MINA32", "MINA32", "MINA32", "MINA32" ]

[]

[ "<s>", "static", "bool", "iq2000_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "size", ";", "if", "(", "cum", "&&", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "{", "CUMULATIVE_ARGS", "temp", ";", "temp", "=", "*", "cum", ";", "if", "(", "iq2000_function_arg", "(", "pack_cumulative_args", "(", "&", "temp", ")", ",", "arg", ")", "!=", "0", ")", "return", "1", ";", "}", "if", "(", "arg", ".", "type", "==", "NULL_TREE", "||", "arg", ".", "mode", "==", "DImode", "||", "arg", ".", "mode", "==", "DFmode", ")", "return", "0", ";", "size", "=", "int_size_in_bytes", "(", "arg", ".", "type", ")", ";", "return", "size", "==", "-", "1", "||", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Return", "true", "when", "an", "argument", "must", "be", "passed", "by", "reference", "." ]

[ "iq2000", "0", "1", "0", "1" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Nand", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "return", "(", "Subtarget", "->", "hasLSE", "(", ")", "&&", "Size", "<", "128", ")", "?", "AtomicExpansionKind", "::", "None", ":", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "AArch64", "AArch64", "128", "128" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasCMov", "(", ")", ")", "return", "false", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ">", "X86", "::", "COND_S", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "X86", "X86", "1", "X86::CondCode", "0", "X86::COND_S", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "2", "2", "2" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "STI", ".", "hasV8_1MMainlineOps", "(", ")", "&&", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isCmseNSEntryFunction", "(", ")", ")", "{", "CSI", ".", "emplace_back", "(", "ARM", "::", "FPCXTNS", ")", ";", "CSI", ".", "back", "(", ")", ".", "setRestored", "(", "false", ")", ";", "}", "const", "auto", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", ".", "shouldSignReturnAddress", "(", ")", ")", "{", "CSI", ".", "insert", "(", "find_if", "(", "CSI", ",", "[", "=", "]", "(", "const", "auto", "&", "CS", ")", "{", "unsigned", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "return", "Reg", "==", "ARM", "::", "R10", "||", "Reg", "==", "ARM", "::", "R11", "||", "Reg", "==", "ARM", "::", "R8", "||", "Reg", "==", "ARM", "::", "R9", "||", "ARM", "::", "DPRRegClass", ".", "contains", "(", "Reg", ")", ";", "}", ")", ",", "CalleeSavedInfo", "(", "ARM", "::", "R12", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM::FPCXTNS", "ARM", "ARM::R10", "ARM::R11", "ARM::R8", "ARM::R9", "ARM::DPRRegClass", "ARM::R12" ]

[]

[ "<s>", "static", "int", "ia64_first_cycle_multipass_dfa_lookahead", "(", "void", ")", "{", "return", "(", "reload_completed", "?", "6", ":", "4", ")", ";", "}", "</s>" ]

[ "If", "the", "following", "function", "returns", "TRUE", ",", "we", "will", "use", "the", "DFA", "insn", "scheduler", "." ]

[ "ia64", "6", "4" ]

[]

[ "<s>", "static", "rtx", "arm_expand_acle_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", "==", "ARM_BUILTIN_SAT_IMM_CHECK", ")", "{", "rtx", "min_sat", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "rtx", "max_sat", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "min_sat", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "max_sat", ")", ")", ";", "rtx", "sat_imm", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "sat_imm", ")", ")", "{", "if", "(", "!", "IN_RANGE", "(", "sat_imm", ",", "min_sat", ",", "max_sat", ")", ")", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"saturation bit range must be in the range [%wd, %wd]\"", ",", "UINTVAL", "(", "min_sat", ")", ",", "UINTVAL", "(", "max_sat", ")", ")", ";", "}", "else", "error_at", "(", "EXPR_LOCATION", "(", "exp", ")", ",", "\"saturation bit range must be a constant immediate\"", ")", ";", "return", "const0_rtx", ";", "}", "gcc_assert", "(", "fcode", "!=", "ARM_BUILTIN_CDE_BASE", ")", ";", "arm_builtin_datum", "*", "d", "=", "(", "fcode", "<", "ARM_BUILTIN_CDE_BASE", ")", "?", "&", "acle_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_ACLE_PATTERN_START", "]", ":", "&", "cde_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_CDE_PATTERN_START", "]", ".", "base", ";", "return", "arm_expand_builtin_1", "(", "fcode", ",", "exp", ",", "target", ",", "d", ")", ";", "}", "</s>" ]

[ "Expand", "an", "ACLE", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "their", "respective", "target", "constraints", "are", "met", ".", "This", "check", "happens", "within", "arm_expand_builtin_args", "." ]

[ "arm", "1", "2", "0", "\"saturation bit range must be in the range [%wd, %wd]\"", "\"saturation bit range must be a constant immediate\"" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "TPC" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "getSubtarget", "(", ")", "const", "{", "return", "Subtarget", ";", "}", "</s>" ]

[ "getSubtarget", "-", "Return", "the", "subtarget", "for", "which", "this", "machine", "code", "is", "being", "compiled", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasV4TOps", "(", "false", ")", ",", "HasV5TOps", "(", "false", ")", ",", "HasV5TEOps", "(", "false", ")", ",", "HasV6Ops", "(", "false", ")", ",", "HasV6T2Ops", "(", "false", ")", ",", "HasV7Ops", "(", "false", ")", ",", "HasVFPv2", "(", "false", ")", ",", "HasVFPv3", "(", "false", ")", ",", "HasVFPv4", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasNEON2", "(", "false", ")", ",", "UseNEONForSinglePrecisionFP", "(", "false", ")", ",", "SlowFPVMLx", "(", "false", ")", ",", "HasVMLxForwarding", "(", "false", ")", ",", "SlowFPBrcc", "(", "false", ")", ",", "InThumbMode", "(", "false", ")", ",", "HasThumb2", "(", "false", ")", ",", "IsMClass", "(", "false", ")", ",", "NoARM", "(", "false", ")", ",", "PostRAScheduler", "(", "false", ")", ",", "IsR9Reserved", "(", "ReserveR9", ")", ",", "UseMovt", "(", "false", ")", ",", "SupportsTailCall", "(", "false", ")", ",", "HasFP16", "(", "false", ")", ",", "HasD16", "(", "false", ")", ",", "HasHardwareDivide", "(", "false", ")", ",", "HasT2ExtractPack", "(", "false", ")", ",", "HasDataBarrier", "(", "false", ")", ",", "Pref32BitThumb", "(", "false", ")", ",", "AvoidCPSRPartialUpdate", "(", "false", ")", ",", "HasMPExtension", "(", "false", ")", ",", "FPOnlySP", "(", "false", ")", ",", "AllowsUnalignedMem", "(", "false", ")", ",", "Thumb2DSP", "(", "false", ")", ",", "stackAlignment", "(", "4", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TargetABI", "(", "ARM_ABI_APCS", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "std", "::", "string", "ArchFS", "=", "ARM_MC", "::", "ParseARMTriple", "(", "TT", ")", ";", "if", "(", "!", "FS", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "ArchFS", ".", "empty", "(", ")", ")", "ArchFS", "=", "ArchFS", "+", "\",\"", "+", "FS", ";", "else", "ArchFS", "=", "FS", ";", "}", "ParseSubtargetFeatures", "(", "CPUString", ",", "ArchFS", ")", ";", "if", "(", "!", "HasV6T2Ops", "&&", "hasThumb2", "(", ")", ")", "HasV4TOps", "=", "HasV5TOps", "=", "HasV5TEOps", "=", "HasV6Ops", "=", "HasV6T2Ops", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUString", ")", ";", "computeIssueWidth", "(", ")", ";", "if", "(", "TT", ".", "find", "(", "\"eabi\"", ")", "!=", "std", "::", "string", "::", "npos", ")", "TargetABI", "=", "ARM_ABI_AAPCS", ";", "if", "(", "isAAPCS_ABI", "(", ")", ")", "stackAlignment", "=", "8", ";", "if", "(", "!", "isTargetIOS", "(", ")", ")", "UseMovt", "=", "hasV6T2Ops", "(", ")", ";", "else", "{", "IsR9Reserved", "=", "ReserveR9", "|", "!", "HasV6Ops", ";", "UseMovt", "=", "DarwinUseMOVT", "&&", "hasV6T2Ops", "(", ")", ";", "SupportsTailCall", "=", "!", "getTargetTriple", "(", ")", ".", "isOSVersionLT", "(", "5", ",", "0", ")", ";", "}", "if", "(", "!", "isThumb", "(", ")", "||", "hasThumb2", "(", ")", ")", "PostRAScheduler", "=", "true", ";", "if", "(", "!", "StrictAlign", "&&", "hasV6Ops", "(", ")", "&&", "isTargetDarwin", "(", ")", ")", "AllowsUnalignedMem", "=", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "4", "ARM", "\"generic\"", "ARM", "ARM", "\",\"", "\"eabi\"", "ARM", "8", "5", "0" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "isTargetELF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nRemoving branches out of \"", "<<", "printMBBReference", "(", "MBB", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "Count", ";", "if", "(", "Count", "&&", "(", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_jump", ")", ")", "llvm_unreachable", "(", "\"Malformed basic block: unconditional branch not last\"", ")", ";", "MBB", ".", "erase", "(", "&", "MBB", ".", "back", "(", ")", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "Hexagon", "Hexagon", "\"code size not handled\"", "\"\\nRemoving branches out of \"", "0", "Hexagon::J2_jump", "\"Malformed basic block: unconditional branch not last\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "if", "(", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "1", "0", "0", "0", "1", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "2", "1", "0", "0", "2", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "NewMIs", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "LoadRegFromStackSlot", "(", "MF", ",", "DL", ",", "DestReg", ",", "FrameIdx", ",", "RC", ",", "NewMIs", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "NewMIs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MBB", ".", "insert", "(", "MI", ",", "NewMIs", "[", "i", "]", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "ix86_avx_u128_mode_needed", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", ")", "return", "AVX_U128_ANY", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "link", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "link", ",", "0", ")", ")", "==", "USE", ")", "{", "rtx", "arg", "=", "XEXP", "(", "XEXP", "(", "link", ",", "0", ")", ",", "0", ")", ";", "if", "(", "ix86_check_avx_upper_register", "(", "arg", ")", ")", "return", "AVX_U128_DIRTY", ";", "}", "}", "bool", "avx_upper_reg_found", "=", "false", ";", "note_stores", "(", "insn", ",", "ix86_check_avx_upper_stores", ",", "&", "avx_upper_reg_found", ")", ";", "if", "(", "avx_upper_reg_found", ")", "return", "AVX_U128_DIRTY", ";", "const", "function_abi", "&", "abi", "=", "insn_callee_abi", "(", "insn", ")", ";", "if", "(", "!", "hard_reg_set_subset_p", "(", "reg_class_contents", "[", "SSE_REGS", "]", ",", "abi", ".", "mode_clobbers", "(", "V4DImode", ")", ")", ")", "return", "AVX_U128_ANY", ";", "return", "AVX_U128_CLEAN", ";", "}", "subrtx_iterator", "::", "array_type", "array", ";", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "ix86_check_avx_upper_register", "(", "dest", ")", ")", "{", "if", "(", "standard_sse_constant_p", "(", "src", ",", "GET_MODE", "(", "dest", ")", ")", "!=", "1", ")", "return", "AVX_U128_DIRTY", ";", "else", "return", "AVX_U128_ANY", ";", "}", "else", "{", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "src", ",", "NONCONST", ")", "if", "(", "ix86_check_avx_upper_register", "(", "*", "iter", ")", ")", "return", "AVX_U128_DIRTY", ";", "}", "return", "AVX_U128_ANY", ";", "}", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "ix86_check_avx_upper_register", "(", "*", "iter", ")", ")", "return", "AVX_U128_DIRTY", ";", "return", "AVX_U128_ANY", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "i386", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MFI", ")", ";", "assert", "(", "allSGPRSpillsAreDead", "(", "MFI", ",", "None", ")", "&&", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", ")", ";", "if", "(", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", "->", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "else", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "TRI", "->", "getSpillAlignment", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "Instruction", "*", "ARMTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "if", "(", "!", "getInsertFencesForAtomic", "(", ")", ")", "return", "nullptr", ";", "switch", "(", "Ord", ")", "{", "case", "NotAtomic", ":", "case", "Unordered", ":", "llvm_unreachable", "(", "\"Invalid fence: unordered/non-atomic\"", ")", ";", "case", "Monotonic", ":", "case", "Acquire", ":", "return", "nullptr", ";", "case", "SequentiallyConsistent", ":", "if", "(", "!", "IsStore", ")", "return", "nullptr", ";", "case", "Release", ":", "case", "AcquireRelease", ":", "if", "(", "Subtarget", "->", "isSwift", "(", ")", ")", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISHST", ")", ";", "else", "return", "makeDMB", "(", "Builder", ",", "ARM_MB", "::", "ISH", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown fence ordering in emitLeadingFence\"", ")", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "ARM", "ARM", "\"Invalid fence: unordered/non-atomic\"", "ARM_MB::ISHST", "ARM_MB::ISH", "\"Unknown fence ordering in emitLeadingFence\"" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "MMIX" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addOptimizedRegAlloc", "(", ")", "{", "if", "(", "OptExecMaskPreRA", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIOptimizeExecMaskingPreRAID", ")", ";", "insertPass", "(", "&", "SIOptimizeExecMaskingPreRAID", ",", "&", "SIFormMemoryClausesID", ")", ";", "}", "else", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFormMemoryClausesID", ")", ";", "}", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "RegisterCoalescerID", ",", "&", "SIPreAllocateWWMRegsID", ",", "false", ")", ";", "if", "(", "EnableDCEInRA", ")", "insertPass", "(", "&", "RenameIndependentSubregsID", ",", "&", "DeadMachineInstructionElimID", ")", ";", "TargetPassConfig", "::", "addOptimizedRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

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

[]

[ "<s>", "static", "bool", "dimode_scalar_to_vector_candidate_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "def_set", ")", "return", "false", ";", "if", "(", "has_non_address_hard_reg", "(", "insn", ")", ")", "return", "false", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", "return", "convertible_comparison_p", "(", "insn", ")", ";", "if", "(", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "src", ")", ")", "||", "GET_MODE", "(", "dst", ")", "!=", "DImode", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "dst", ")", "&&", "!", "MEM_P", "(", "dst", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "ASHIFTRT", ":", "if", "(", "!", "TARGET_AVX512VL", ")", "return", "false", ";", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "(", "!", "SUBREG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "||", "SUBREG_BYTE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "0", "||", "!", "REG_P", "(", "SUBREG_REG", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", ")", "&&", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ",", "0", ",", "63", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "QImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "PLUS", ":", "case", "MINUS", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "NEG", ":", "case", "NOT", ":", "break", ";", "case", "REG", ":", "return", "true", ";", "case", "MEM", ":", "case", "CONST_INT", ":", "return", "REG_P", "(", "dst", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "AND", "||", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "NOT", "||", "!", "REG_P", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "DImode", "version", "of", "scalar_to_vector_candidate_p", "." ]

[ "i386", "1", "1", "1", "0", "1", "1", "1", "0", "63", "1", "1", "1", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "int", "mcore_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "reg", "=", "ROUND_REG", "(", "*", "get_cumulative_args", "(", "cum", ")", ",", "arg", ".", "mode", ")", ";", "if", "(", "!", "arg", ".", "named", ")", "return", "0", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "arg", ")", ")", "return", "0", ";", "if", "(", "reg", ">=", "NPARM_REGS", ")", "return", "0", ";", "if", "(", "reg", "+", "mcore_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", "<=", "NPARM_REGS", ")", "return", "0", ";", "reg", "=", "NPARM_REGS", "-", "reg", ";", "return", "reg", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "of", "argument", "registers", "required", "to", "hold", "*", "part", "*", "of", "a", "parameter", "of", "machine", "mode", "MODE", "and", "type", "TYPE", "(", "which", "may", "be", "NULL", "if", "the", "type", "is", "not", "known", ")", ".", "If", "the", "argument", "fits", "entirely", "in", "the", "argument", "registers", ",", "or", "entirely", "on", "the", "stack", ",", "then", "0", "is", "returned", ".", "CUM", "is", "the", "number", "of", "argument", "registers", "already", "used", "by", "earlier", "parameters", "to", "the", "function", "." ]

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesAll", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineModuleInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DwarfWriter", ">", "(", ")", ";", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "NPEnginePassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "NPEngine" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SparcTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "BROpcode", ";", "unsigned", "CC", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown SELECT_CC!\"", ")", ";", "case", "SP", "::", "SELECT_CC_Int_ICC", ":", "case", "SP", "::", "SELECT_CC_FP_ICC", ":", "case", "SP", "::", "SELECT_CC_DFP_ICC", ":", "case", "SP", "::", "SELECT_CC_QFP_ICC", ":", "BROpcode", "=", "SP", "::", "BCOND", ";", "break", ";", "case", "SP", "::", "SELECT_CC_Int_FCC", ":", "case", "SP", "::", "SELECT_CC_FP_FCC", ":", "case", "SP", "::", "SELECT_CC_DFP_FCC", ":", "case", "SP", "::", "SELECT_CC_QFP_FCC", ":", "BROpcode", "=", "SP", "::", "FBCOND", ";", "break", ";", "}", "CC", "=", "(", "SPCC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "It", "=", "BB", ";", "++", "It", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "sinkMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "It", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "sinkMBB", "->", "splice", "(", "sinkMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "sinkMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "BROpcode", ")", ")", ".", "addMBB", "(", "sinkMBB", ")", ".", "addImm", "(", "CC", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "BB", "=", "sinkMBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Sparc", "Sparc", "\"Unknown SELECT_CC!\"", "SP::SELECT_CC_Int_ICC", "SP::SELECT_CC_FP_ICC", "SP::SELECT_CC_DFP_ICC", "SP::SELECT_CC_QFP_ICC", "SP::BCOND", "SP::SELECT_CC_Int_FCC", "SP::SELECT_CC_FP_FCC", "SP::SELECT_CC_DFP_FCC", "SP::SELECT_CC_QFP_FCC", "SP::FBCOND", "SPCC::CondCodes", "3", "SP::PHI", "0", "2", "1" ]

[]

[ "<s>", "void", "MipsAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "FK_Data_2", ":", "case", "Mips", "::", "fixup_Mips_16", ":", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "FullSize", "=", "2", ";", "break", ";", "case", "FK_Data_8", ":", "case", "Mips", "::", "fixup_Mips_64", ":", "FullSize", "=", "8", ";", "break", ";", "case", "FK_Data_4", ":", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "bool", "microMipsLEByteOrder", "=", "needsMMLEByteOrder", "(", "(", "unsigned", ")", "Kind", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "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", "=", "IsLittle", "?", "(", "microMipsLEByteOrder", "?", "calculateMMLEIndex", "(", "i", ")", ":", "i", ")", ":", "(", "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", "." ]

[ "Mips", "Mips", "7", "8", "Mips::fixup_Mips_16", "Mips::fixup_MICROMIPS_PC10_S1", "2", "Mips::fixup_Mips_64", "8", "4", "0", "Mips", "0", "Mips", "1", "8", "1", "64", "0", "Mips", "1", "8", "0xff" ]

[]

[ "<s>", "yaml", "::", "MachineFunctionInfo", "*", "GCNTargetMachine", "::", "createDefaultFuncInfoYAML", "(", ")", "const", "{", "return", "new", "yaml", "::", "SIMachineFunctionInfo", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "default", "initialized", "instance", "of", "the", "YAML", "representation", "for", "the", "MachineFunctionInfo", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "*", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", "->", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "return", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "DBG_VALUE", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", "||", "(", "isInt", "<", "16", ">", "(", "Offset", ")", "&&", "(", "Offset", "%", "offsetMinAlign", "(", "*", "MI", ")", ")", "==", "0", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"", "PPC::DBG_VALUE", "16", "0" ]

[]

[ "<s>", "bool", "MINA32DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MINA32Subtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "MINA32", "MINA32", "MINA32" ]

[]

[ "<s>", "bool", "SIInsertSkips", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "SkipThreshold", "=", "SkipThresholdFlag", ";", "bool", "HaveKill", "=", "false", ";", "bool", "MadeChange", "=", "false", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "16", ">", "ExecBranchStack", ";", "MachineFunction", "::", "iterator", "NextBB", ";", "MachineBasicBlock", "*", "EmptyMBBAtEnd", "=", "nullptr", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "BI", "=", "NextBB", ")", "{", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "bool", "HaveSkipBlock", "=", "false", ";", "if", "(", "!", "ExecBranchStack", ".", "empty", "(", ")", "&&", "ExecBranchStack", ".", "back", "(", ")", "==", "&", "MBB", ")", "{", "ExecBranchStack", ".", "pop_back", "(", ")", ";", "}", "if", "(", "HaveKill", "&&", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "HaveKill", "=", "false", ";", "}", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "ExecBranchStack", ".", "push_back", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ";", "MadeChange", "|=", "skipMaskBranch", "(", "MI", ",", "MBB", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "if", "(", "HaveSkipBlock", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "break", ";", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "MadeChange", "=", "true", ";", "kill", "(", "MI", ")", ";", "if", "(", "ExecBranchStack", ".", "empty", "(", ")", ")", "{", "if", "(", "skipIfDead", "(", "MI", ",", "*", "NextBB", ")", ")", "{", "HaveSkipBlock", "=", "true", ";", "NextBB", "=", "std", "::", "next", "(", "BI", ")", ";", "BE", "=", "MF", ".", "end", "(", ")", ";", "}", "}", "else", "{", "HaveKill", "=", "true", ";", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_RETURN_TO_EPILOG", ":", "assert", "(", "!", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ")", ";", "if", "(", "BI", "!=", "--", "MF", ".", "end", "(", ")", "||", "I", "!=", "MBB", ".", "getFirstTerminator", "(", ")", ")", "{", "if", "(", "!", "EmptyMBBAtEnd", ")", "{", "EmptyMBBAtEnd", "=", "MF", ".", "CreateMachineBasicBlock", "(", ")", ";", "MF", ".", "insert", "(", "MF", ".", "end", "(", ")", ",", "EmptyMBBAtEnd", ")", ";", "}", "MBB", ".", "addSuccessor", "(", "EmptyMBBAtEnd", ")", ";", "BuildMI", "(", "*", "BI", ",", "I", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "EmptyMBBAtEnd", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "16", "AMDGPU::SI_MASK_BRANCH", "0", "AMDGPU::S_BRANCH", "0", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU::SI_RETURN_TO_EPILOG", "SI", "AMDGPU::S_BRANCH" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 branch relaxation pass\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 branch relaxation pass\"" ]

[]

[ "<s>", "static", "int", "uses_TOC", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "sub", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "USE", ")", "{", "sub", "=", "XEXP", "(", "sub", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "sub", ")", "==", "UNSPEC", "&&", "XINT", "(", "sub", ",", "1", ")", "==", "UNSPEC_TOC", ")", "return", "1", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "This", "retuns", "nonzero", "if", "the", "current", "function", "uses", "the", "TOC", ".", "This", "is", "determined", "by", "the", "presence", "of", "(", "unspec", "...", "7", ")", ",", "which", "is", "generated", "by", "the", "various", "load_toc_", "*", "patterns", "." ]

[ "powerpcspe", "0", "0", "0", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "Hexagon_CCState", "::", "AnalyzeCallOperands", "(", "SmallVectorImpl", "<", "EVT", ">", "&", "ArgVTs", ",", "SmallVectorImpl", "<", "ISD", "::", "ArgFlagsTy", ">", "&", "Flags", ",", "Hexagon_CCAssignFn", "Fn", ")", "{", "unsigned", "NumOps", "=", "ArgVTs", ".", "size", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "{", "EVT", "ArgVT", "=", "ArgVTs", "[", "i", "]", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Flags", "[", "i", "]", ";", "if", "(", "Fn", "(", "i", ",", "ArgVT", ",", "ArgVT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "*", "this", ",", "-", "1", ",", "-", "1", ",", "false", ")", ")", "{", "dbgs", "(", ")", "<<", "\"Call operand #\"", "<<", "i", "<<", "\" has unhandled type \"", "<<", "ArgVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ";", "abort", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "AnalyzeCallOperands", "-", "Same", "as", "above", "except", "it", "takes", "vectors", "of", "types", "and", "argument", "flags", "." ]

[ "Hexagon", "Hexagon", "ISD::ArgFlagsTy", "Hexagon", "0", "ISD::ArgFlagsTy", "1", "1", "\"Call operand #\"", "\" has unhandled type \"", "\"\\n\"" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::v32i1", "MVT::v32i8" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCondOpt", ")", "addPass", "(", "createAArch64ConditionOptimizerPass", "(", ")", ")", ";", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableCondBrTuning", ")", "addPass", "(", "createAArch64CondBrTuning", "(", ")", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "addPass", "(", "createAArch64VectorByElementOptPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MOSCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "auto", "&", "TFI", "=", "static_cast", "<", "const", "MOSFrameLowering", "&", ">", "(", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "auto", "Return", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "TFI", ".", "isISR", "(", "MF", ")", "?", "MOS", "::", "RTI", ":", "MOS", "::", "RTS", ")", ";", "if", "(", "Val", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "*", "getTLI", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ">", "ValueVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "ValueVTs", ")", ";", "SmallVector", "<", "LLT", ">", "ValueLLTs", ";", "computeValueLLTs", "(", "DL", ",", "*", "Val", "->", "getType", "(", ")", ",", "ValueLLTs", ")", ";", "assert", "(", "ValueVTs", ".", "size", "(", ")", "==", "VRegs", ".", "size", "(", ")", "&&", "\"Need one MVT for each VReg.\"", ")", ";", "assert", "(", "ValueLLTs", ".", "size", "(", ")", "==", "VRegs", ".", "size", "(", ")", "&&", "\"Need one LLT for each VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ">", "Args", ";", "for", "(", "const", "auto", "&", "I", ":", "zip", "(", "VRegs", ",", "ValueVTs", ",", "ValueLLTs", ")", ")", "{", "Args", ".", "emplace_back", "(", "std", "::", "get", "<", "0", ">", "(", "I", ")", ",", "std", "::", "get", "<", "1", ">", "(", "I", ")", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "0", ")", ";", "setArgFlags", "(", "Args", ".", "back", "(", ")", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "adjustArgFlags", "(", "Args", ".", "back", "(", ")", ",", "std", "::", "get", "<", "2", ">", "(", "I", ")", ")", ";", "}", "MOSOutgoingReturnHandler", "Handler", "(", "MIRBuilder", ",", "Return", ",", "MRI", ")", ";", "MOSValueAssigner", "Assigner", "(", "false", ",", "MRI", ",", "MF", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "Handler", ",", "Assigner", ",", "Args", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Return", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "MOS", "MOS", "MOS", "MOS::RTI", "MOS::RTS", "\"Need one MVT for each VReg.\"", "\"Need one LLT for each VReg.\"", "0", "1", "0", "2", "MOS", "MOS" ]

[]

[ "<s>", "void", "AlphaFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAG", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "RETDAGp", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDQ", ")", ",", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ";", "}", "if", "(", "NumBytes", "!=", "0", ")", "{", "if", "(", "NumBytes", "<=", "Alpha", "::", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", "<=", "Alpha", "::", "IMM_HIGH", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Too big a stack frame at \"", "+", "Twine", "(", "NumBytes", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::RETDAG", "Alpha::RETDAGp", "\"Can only insert epilog into returning blocks\"", "Alpha::BISr", "Alpha::R30", "Alpha::R15", "Alpha::R15", "Alpha::LDQ", "Alpha::R15", "0", "Alpha::R15", "0", "Alpha::IMM_HIGH", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::IMM_HIGH", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"" ]

[]

[ "<s>", "void", "PPCInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "removeDeadCode", "(", ")", "{", "ValueVect", "BO", ";", "BO", ".", "push_back", "(", "&", "Fn", "->", "front", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "BO", ".", "size", "(", ")", ";", "++", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "]", ")", ";", "for", "(", "auto", "DTN", ":", "children", "<", "DomTreeNode", "*", ">", "(", "DT", "->", "getNode", "(", "B", ")", ")", ")", "BO", ".", "push_back", "(", "DTN", "->", "getBlock", "(", ")", ")", ";", "}", "for", "(", "Value", "*", "V", ":", "llvm", "::", "reverse", "(", "BO", ")", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "V", ")", ";", "ValueVect", "Ins", ";", "for", "(", "Instruction", "&", "I", ":", "llvm", "::", "reverse", "(", "*", "B", ")", ")", "Ins", ".", "push_back", "(", "&", "I", ")", ";", "for", "(", "Value", "*", "I", ":", "Ins", ")", "{", "Instruction", "*", "In", "=", "cast", "<", "Instruction", ">", "(", "I", ")", ";", "if", "(", "isInstructionTriviallyDead", "(", "In", ")", ")", "In", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "0" ]

[]

[ "<s>", "static", "void", "m32c_function_arg_advance", "(", "cumulative_args_t", "ca_v", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "ca_v", ")", ";", "if", "(", "ca", "->", "force_mem", ")", "ca", "->", "force_mem", "=", "0", ";", "else", "ca", "->", "parm_num", "++", ";", "}", "</s>" ]

[ "Implements", "FUNCTION_ARG_ADVANCE", ".", "force_mem", "is", "set", "for", "functions", "returning", "structures", ",", "so", "we", "always", "reset", "that", ".", "Otherwise", ",", "we", "only", "need", "to", "know", "the", "sequence", "number", "of", "the", "argument", "to", "know", "what", "to", "do", "with", "it", "." ]

[ "m32c", "0" ]

[]

[ "<s>", "Sched", "::", "Preference", "PPCTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "if", "(", "DisableILPPref", ")", "return", "TargetLowering", "::", "getSchedulingPreference", "(", "N", ")", ";", "return", "Sched", "::", "ILP", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "int", "n_dregs_to_save", "(", "bool", "is_inthandler", ")", "{", "unsigned", "i", ";", "for", "(", "i", "=", "REG_R0", ";", "i", "<=", "REG_R7", ";", "i", "++", ")", "{", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "(", "is_inthandler", "||", "!", "call_used_regs", "[", "i", "]", ")", ")", "return", "REG_R7", "-", "i", "+", "1", ";", "if", "(", "current_function_calls_eh_return", ")", "{", "unsigned", "j", ";", "for", "(", "j", "=", "0", ";", ";", "j", "++", ")", "{", "unsigned", "test", "=", "EH_RETURN_DATA_REGNO", "(", "j", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "i", ")", "return", "REG_R7", "-", "i", "+", "1", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "DREGS", "to", "save", "with", "a", "push_multiple", "operation", ".", "This", "could", "include", "registers", "that", "are", "n't", "modified", "in", "the", "function", ",", "since", "push_multiple", "only", "takes", "a", "range", "of", "registers", ".", "If", "IS_INTHANDLER", ",", "then", "everything", "that", "is", "live", "must", "be", "saved", ",", "even", "if", "normally", "call-clobbered", "." ]

[ "bfin", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "PatmosSPMark", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Mark function reachable from single-path roots\\n\"", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ".", "getMMI", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"sp-root\"", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"sp-reachable\"", ")", ")", "{", "PatmosMachineFunctionInfo", "*", "PMFI", "=", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "PMFI", "->", "setSinglePath", "(", ")", ";", "NumSPTotal", "++", ";", "scanAndRewriteCalls", "(", "MF", ")", ";", "}", "removeUncalledSPFunctions", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"[Single-Path] Mark function reachable from single-path roots\\n\"", "\"sp-root\"", "\"sp-reachable\"", "Patmos", "Patmos" ]

[]

[ "<s>", "const", "uint16_t", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "callsEHReturn", "=", "false", ";", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "callsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "if", "(", "ghcCall", ")", "return", "CSR_NoRegs_SaveList", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "callsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "callsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "X86", "X86" ]

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "isN64", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_GPRel64BlockAddress", ";", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "X86FastPreTileConfig", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFunc", ")", "{", "MF", "=", "&", "MFunc", ";", "MRI", "=", "&", "MFunc", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MFunc", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "X86FI", "=", "MFunc", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MFI", "=", "&", "MFunc", ".", "getFrameInfo", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "CfgSS", "=", "-", "1", ";", "unsigned", "NumVirtRegs", "=", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "bool", "HasVirtTileReg", "=", "false", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "NumVirtRegs", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Register", "VirtReg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "VirtReg", ")", "->", "getID", "(", ")", "==", "X86", "::", "TILERegClassID", ")", "{", "HasVirtTileReg", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasVirtTileReg", ")", "return", "false", ";", "StackSlotForVirtReg", ".", "resize", "(", "NumVirtRegs", ")", ";", "MayLiveAcrossBlocks", ".", "clear", "(", ")", ";", "MayLiveAcrossBlocks", ".", "resize", "(", "NumVirtRegs", "*", "3", ")", ";", "bool", "Change", "=", "false", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MFunc", ")", "canonicalizePHIs", "(", "MBB", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "RPOT", ")", "{", "convertPHIs", "(", "*", "MBB", ")", ";", "Change", "|=", "configBasicBlock", "(", "*", "MBB", ")", ";", "}", "if", "(", "Change", ")", "InitializeTileConfigStackSpace", "(", ")", ";", "StackSlotForVirtReg", ".", "clear", "(", ")", ";", "return", "Change", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "1", "0", "X86::TILERegClassID", "3" ]

[]

[ "<s>", "const", "Triple", "&", "getTargetTriple", "(", ")", "const", "{", "return", "TargetTriple", ";", "}", "</s>" ]

[ "Get", "the", "target", "triple", "which", "is", "a", "string", "describing", "the", "target", "host", "." ]

[ "PowerPC" ]

[]

[ "<s>", "MachineInstr", "*", "HexagonInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "int", "FI", ")", "const", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "node_value_type", "&", "getValue", "(", ")", "const", "{", "return", "Value", ";", "}", "</s>" ]

[ "Return", "the", "contained", "Value", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "v850_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "result", "=", "NULL_RTX", ";", "int", "size", ",", "align", ";", "if", "(", "!", "named", ")", "return", "NULL_RTX", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "size", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "~", "(", "UNITS_PER_WORD", "-", "1", ")", ";", "if", "(", "size", "<", "1", ")", "{", "cum", "->", "nbytes", "=", "4", "*", "UNITS_PER_WORD", ";", "return", "NULL_RTX", ";", "}", "if", "(", "!", "TARGET_GCC_ABI", ")", "align", "=", "UNITS_PER_WORD", ";", "else", "if", "(", "size", "<=", "UNITS_PER_WORD", "&&", "type", ")", "align", "=", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ";", "else", "align", "=", "size", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "align", "-", "1", ")", "&", "~", "(", "align", "-", "1", ")", ";", "if", "(", "cum", "->", "nbytes", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "4", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "0", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "6", ")", ";", "break", ";", "case", "1", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "7", ")", ";", "break", ";", "case", "2", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "8", ")", ";", "break", ";", "case", "3", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "9", ")", ";", "break", ";", "default", ":", "result", "=", "NULL_RTX", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "to", "represent", "where", "an", "argument", "with", "mode", "MODE", "and", "type", "TYPE", "will", "be", "passed", "to", "a", "function", ".", "If", "the", "result", "is", "NULL_RTX", ",", "the", "argument", "will", "be", "pushed", "." ]

[ "v850", "1", "1", "1", "4", "1", "1", "4", "4", "0", "6", "1", "7", "2", "8", "3", "9" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TBB", ",", "unsigned", "TCycles", ",", "unsigned", "TExtra", ",", "MachineBasicBlock", "&", "FBB", ",", "unsigned", "FCycles", ",", "unsigned", "FExtra", ",", "BranchProbability", "Probability", ")", "const", "{", "if", "(", "!", "TCycles", ")", "return", "false", ";", "const", "unsigned", "ScalingUpFactor", "=", "1024", ";", "unsigned", "PredCost", "=", "(", "TCycles", "+", "FCycles", "+", "TExtra", "+", "FExtra", ")", "*", "ScalingUpFactor", ";", "unsigned", "UnpredCost", ";", "if", "(", "!", "Subtarget", ".", "hasBranchPredictor", "(", ")", ")", "{", "unsigned", "NotTakenBranchCost", "=", "1", ";", "unsigned", "TakenBranchCost", "=", "Subtarget", ".", "getMispredictionPenalty", "(", ")", ";", "unsigned", "TUnpredCycles", ",", "FUnpredCycles", ";", "if", "(", "!", "FCycles", ")", "{", "TUnpredCycles", "=", "TCycles", "+", "NotTakenBranchCost", ";", "FUnpredCycles", "=", "TakenBranchCost", ";", "}", "else", "{", "TUnpredCycles", "=", "TCycles", "+", "TakenBranchCost", ";", "FUnpredCycles", "=", "FCycles", "+", "NotTakenBranchCost", ";", "PredCost", "-=", "1", "*", "ScalingUpFactor", ";", "}", "unsigned", "TUnpredCost", "=", "Probability", ".", "scale", "(", "TUnpredCycles", "*", "ScalingUpFactor", ")", ";", "unsigned", "FUnpredCost", "=", "Probability", ".", "getCompl", "(", ")", ".", "scale", "(", "FUnpredCycles", "*", "ScalingUpFactor", ")", ";", "UnpredCost", "=", "TUnpredCost", "+", "FUnpredCost", ";", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", "&&", "TCycles", "+", "FCycles", ">", "4", ")", "{", "PredCost", "+=", "(", "(", "TCycles", "+", "FCycles", "-", "4", ")", "/", "4", ")", "*", "ScalingUpFactor", ";", "}", "}", "else", "{", "unsigned", "TUnpredCost", "=", "Probability", ".", "scale", "(", "TCycles", "*", "ScalingUpFactor", ")", ";", "unsigned", "FUnpredCost", "=", "Probability", ".", "getCompl", "(", ")", ".", "scale", "(", "FCycles", "*", "ScalingUpFactor", ")", ";", "UnpredCost", "=", "TUnpredCost", "+", "FUnpredCost", ";", "UnpredCost", "+=", "1", "*", "ScalingUpFactor", ";", "UnpredCost", "+=", "Subtarget", ".", "getMispredictionPenalty", "(", ")", "*", "ScalingUpFactor", "/", "10", ";", "}", "return", "PredCost", "<=", "UnpredCost", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "ARM", "ARM", "1024", "1", "1", "4", "4", "4", "1", "10" ]

[]

[ "<s>", "static", "vl_vtype_info", "get_vl_vtype_info", "(", "const", "insn_info", "*", "insn", ")", "{", "set_info", "*", "set", "=", "nullptr", ";", "rtx", "avl", "=", "::", "get_avl", "(", "insn", "->", "rtl", "(", ")", ")", ";", "if", "(", "avl", "&&", "REG_P", "(", "avl", ")", ")", "{", "if", "(", "vlmax_avl_p", "(", "avl", ")", "&&", "has_vl_op", "(", "insn", "->", "rtl", "(", ")", ")", ")", "set", "=", "find_access", "(", "insn", "->", "uses", "(", ")", ",", "REGNO", "(", "get_vl", "(", "insn", "->", "rtl", "(", ")", ")", ")", ")", "->", "def", "(", ")", ";", "else", "if", "(", "!", "vlmax_avl_p", "(", "avl", ")", ")", "set", "=", "find_access", "(", "insn", "->", "uses", "(", ")", ",", "REGNO", "(", "avl", ")", ")", "->", "def", "(", ")", ";", "else", "set", "=", "nullptr", ";", "}", "uint8_t", "sew", "=", "get_sew", "(", "insn", "->", "rtl", "(", ")", ")", ";", "enum", "vlmul_type", "vlmul", "=", "get_vlmul", "(", "insn", "->", "rtl", "(", ")", ")", ";", "uint8_t", "ratio", "=", "get_attr_ratio", "(", "insn", "->", "rtl", "(", ")", ")", ";", "if", "(", "ratio", "==", "INVALID_ATTRIBUTE", ")", "ratio", "=", "calculate_ratio", "(", "sew", ",", "vlmul", ")", ";", "bool", "ta", "=", "tail_agnostic_p", "(", "insn", "->", "rtl", "(", ")", ")", ";", "bool", "ma", "=", "mask_agnostic_p", "(", "insn", "->", "rtl", "(", ")", ")", ";", "int", "merge_op_idx", "=", "get_attr_merge_op_idx", "(", "insn", "->", "rtl", "(", ")", ")", ";", "if", "(", "merge_op_idx", "!=", "INVALID_ATTRIBUTE", "&&", "satisfies_constraint_vu", "(", "recog_data", ".", "operand", "[", "merge_op_idx", "]", ")", ")", "{", "ta", "=", "true", ";", "ma", "=", "true", ";", "}", "vl_vtype_info", "info", "(", "avl_info", "(", "avl", ",", "set", ")", ",", "sew", ",", "vlmul", ",", "ratio", ",", "ta", ",", "ma", ")", ";", "return", "info", ";", "}", "</s>" ]

[ "Get", "VL/VTYPE", "information", "for", "INSN", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "MipsOperand", ">", "CreateMem", "(", "std", "::", "unique_ptr", "<", "MipsOperand", ">", "Base", ",", "const", "MCExpr", "*", "Off", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "MipsAsmParser", "&", "Parser", ")", "{", "auto", "Op", "=", "make_unique", "<", "MipsOperand", ">", "(", "k_Memory", ",", "Parser", ")", ";", "Op", "->", "Mem", ".", "Base", "=", "Base", ".", "release", "(", ")", ";", "Op", "->", "Mem", ".", "Off", "=", "Off", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveXRegister", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "CustomCallSavedXRegs", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "if", "(", "AArch64", "::", "isX18ReservedByDefault", "(", "TT", ")", ")", "ReserveXRegister", ".", "set", "(", "18", ")", ";", "ReserveXRegister", ".", "set", "(", "19", ")", ";", "ReserveXRegister", ".", "set", "(", "20", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::GPR64commonRegClass", "AArch64::GPR64commonRegClass", "AArch64::isX18ReservedByDefault", "18", "19", "20", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "!", "Subtarget", ".", "hasStdExtZfh", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "!", "Subtarget", ".", "hasStdExtF", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "&&", "!", "Subtarget", ".", "hasStdExtD", "(", ")", ")", "return", "false", ";", "if", "(", "Imm", ".", "isNegZero", "(", ")", ")", "return", "false", ";", "return", "Imm", ".", "isZero", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "instruction", "select", "the", "specified", "FP", "immediate", "natively", "." ]

[ "RI5CY", "RISCV", "MVT::f16", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "static", "int", "ia64_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "words", "=", "ia64_function_arg_words", "(", "arg", ".", "type", ",", "arg", ".", "mode", ")", ";", "int", "offset", "=", "ia64_function_arg_offset", "(", "cum", ",", "arg", ".", "type", ",", "words", ")", ";", "if", "(", "cum", "->", "words", "+", "offset", ">=", "MAX_ARGUMENT_SLOTS", ")", "return", "0", ";", "if", "(", "words", "+", "cum", "->", "words", "+", "offset", "<=", "MAX_ARGUMENT_SLOTS", ")", "return", "0", ";", "return", "(", "MAX_ARGUMENT_SLOTS", "-", "cum", "->", "words", "-", "offset", ")", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Return", "number", "of", "bytes", ",", "at", "the", "beginning", "of", "the", "argument", ",", "that", "must", "be", "put", "in", "registers", ".", "0", "is", "the", "argument", "is", "entirely", "in", "registers", "or", "entirely", "in", "memory", "." ]

[ "ia64", "0", "0" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Xtensa" ]

[]

[ "<s>", "bool", "s390_can_eliminate", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "from", "==", "BASE_REGNUM", "&&", "to", "==", "BASE_REGNUM", ")", "{", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "s390_init_frame_layout", "(", ")", ";", "return", "cfun", "->", "machine", "->", "base_reg", "==", "NULL_RTX", ";", "}", "return", "false", ";", "}", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", "||", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", ";", "gcc_assert", "(", "from", "==", "FRAME_POINTER_REGNUM", "||", "from", "==", "ARG_POINTER_REGNUM", "||", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", ";", "if", "(", "from", "==", "RETURN_ADDRESS_POINTER_REGNUM", ")", "if", "(", "!", "current_function_calls_eh_return", "&&", "!", "current_function_stdarg", "&&", "!", "cfun_frame_layout", ".", "save_return_addr_p", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "FROM", "can", "be", "eliminated", "via", "register", "TO", "." ]

[ "s390" ]

[]

[ "<s>", "StringRef", "getString", "(", ")", "const", "{", "return", "Data", ";", "}", "</s>" ]

[ "Returns", "features", "as", "a", "string", "." ]

[ "TVM" ]

[]

[ "<s>", "static", "sbitmap", "rs6000_components_for_bb", "(", "basic_block", "bb", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "bitmap", "in", "=", "DF_LIVE_IN", "(", "bb", ")", ";", "bitmap", "gen", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "gen", ";", "bitmap", "kill", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "kill", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "cfun", "->", "machine", "->", "n_components", ")", ";", "bitmap_clear", "(", "components", ")", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_gp_reg_save", ";", "regno", "<", "32", ";", "regno", "++", ")", "if", "(", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "for", "(", "unsigned", "regno", "=", "info", "->", "first_fp_reg_save", ";", "regno", "<", "64", ";", "regno", "++", ")", "if", "(", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "if", "(", "bitmap_bit_p", "(", "in", ",", "LR_REGNO", ")", "||", "bitmap_bit_p", "(", "gen", ",", "LR_REGNO", ")", "||", "bitmap_bit_p", "(", "kill", ",", "LR_REGNO", ")", ")", "bitmap_set_bit", "(", "components", ",", "0", ")", ";", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB", "." ]

[ "powerpcspe", "32", "64", "0" ]

[]

[ "<s>", "SDValue", "AAPTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "uint32_t", "*", "RegMask", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_AAP", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ";", "RegMask", "[", "Reg", "/", "32", "]", "&=", "~", "(", "1u", "<<", "(", "Reg", "&", "32", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "AAP", "AAP", "ISD::InputArg", "16", "AAP", "0", "1", "2", "0", "0", "32", "1u", "32" ]

[]

[ "<s>", "static", "int", "ix86_mode_after", "(", "int", "entity", ",", "int", "mode", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_after", "(", "mode", ",", "insn", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "return", "mode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "mode", "that", "an", "insn", "results", "in", "." ]

[ "i386" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getUndefRegClearance", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "hasUndefRegUpdate", "(", "MI", ".", "getOpcode", "(", ")", ",", "OpNum", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "isUndef", "(", ")", "&&", "Register", "::", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "return", "UndefRegClearance", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "certain", "undef", "register", "reads", "." ]

[ "X86", "X86", "0", "0" ]

[]

[ "<s>", "static", "void", "reorder_var_tracking_notes", "(", "void", ")", "{", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ";", "rtx_insn", "*", "queue", "=", "NULL", ";", "bool", "in_bundle", "=", "false", ";", "for", "(", "insn", "=", "BB_HEAD", "(", "bb", ")", ";", "insn", "!=", "BB_END", "(", "bb", ")", ";", "insn", "=", "next", ")", "{", "next", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "QImode", ")", "{", "while", "(", "queue", ")", "{", "rtx_insn", "*", "next_queue", "=", "PREV_INSN", "(", "queue", ")", ";", "SET_PREV_INSN", "(", "NEXT_INSN", "(", "insn", ")", ")", "=", "queue", ";", "SET_NEXT_INSN", "(", "queue", ")", "=", "NEXT_INSN", "(", "insn", ")", ";", "SET_NEXT_INSN", "(", "insn", ")", "=", "queue", ";", "SET_PREV_INSN", "(", "queue", ")", "=", "insn", ";", "queue", "=", "next_queue", ";", "}", "in_bundle", "=", "false", ";", "}", "else", "if", "(", "GET_MODE", "(", "insn", ")", "==", "SImode", ")", "in_bundle", "=", "true", ";", "}", "else", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_VAR_LOCATION", ")", "{", "if", "(", "in_bundle", ")", "{", "rtx_insn", "*", "prev", "=", "PREV_INSN", "(", "insn", ")", ";", "SET_PREV_INSN", "(", "next", ")", "=", "prev", ";", "SET_NEXT_INSN", "(", "prev", ")", "=", "next", ";", "SET_PREV_INSN", "(", "insn", ")", "=", "queue", ";", "queue", "=", "insn", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "Ensure", "that", "no", "var", "tracking", "notes", "are", "emitted", "in", "the", "middle", "of", "a", "three-instruction", "bundle", "." ]

[ "tilepro" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasOpaqueSPAdjustment", "(", ")", "||", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getForceFramePointer", "(", ")", "||", "MMI", ".", "callsUnwindInit", "(", ")", "||", "MMI", ".", "callsEHReturn", "(", ")", "||", "MFI", "->", "hasStackMap", "(", ")", "||", "MFI", "->", "hasPatchPoint", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_md_vectorized_function", "(", "tree", "fndecl", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "machine_mode", "in_mode", ",", "out_mode", ";", "int", "in_n", ",", "out_n", ";", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "\"rs6000_builtin_md_vectorized_function (%s, %s, %s)\\n\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ",", "GET_MODE_NAME", "(", "TYPE_MODE", "(", "type_out", ")", ")", ",", "GET_MODE_NAME", "(", "TYPE_MODE", "(", "type_in", ")", ")", ")", ";", "if", "(", "TREE_CODE", "(", "type_out", ")", "!=", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type_in", ")", "!=", "VECTOR_TYPE", ")", "return", "NULL_TREE", ";", "out_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "out_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "enum", "rs6000_builtins", "fn", "=", "(", "enum", "rs6000_builtins", ")", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "switch", "(", "fn", ")", "{", "case", "RS6000_BUILTIN_RSQRTF", ":", "if", "(", "VECTOR_UNIT_ALTIVEC_OR_VSX_P", "(", "V4SFmode", ")", "&&", "out_mode", "==", "SFmode", "&&", "out_n", "==", "4", "&&", "in_mode", "==", "SFmode", "&&", "in_n", "==", "4", ")", "return", "rs6000_builtin_decls", "[", "ALTIVEC_BUILTIN_VRSQRTFP", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RSQRT", ":", "if", "(", "VECTOR_UNIT_VSX_P", "(", "V2DFmode", ")", "&&", "out_mode", "==", "DFmode", "&&", "out_n", "==", "2", "&&", "in_mode", "==", "DFmode", "&&", "in_n", "==", "2", ")", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_2DF", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RECIPF", ":", "if", "(", "VECTOR_UNIT_ALTIVEC_OR_VSX_P", "(", "V4SFmode", ")", "&&", "out_mode", "==", "SFmode", "&&", "out_n", "==", "4", "&&", "in_mode", "==", "SFmode", "&&", "in_n", "==", "4", ")", "return", "rs6000_builtin_decls", "[", "ALTIVEC_BUILTIN_VRECIPFP", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RECIP", ":", "if", "(", "VECTOR_UNIT_VSX_P", "(", "V2DFmode", ")", "&&", "out_mode", "==", "DFmode", "&&", "out_n", "==", "2", "&&", "in_mode", "==", "DFmode", "&&", "in_n", "==", "2", ")", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RECIP_V2DF", "]", ";", "break", ";", "default", ":", "break", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_md_vectorized_function", "." ]

[ "rs6000", "\"rs6000_builtin_md_vectorized_function (%s, %s, %s)\\n\"", "4", "4", "2", "2", "4", "4", "2", "2" ]

[]

[ "<s>", "static", "bool", "mn10300_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", ">", "8", "||", "size", "==", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "parameter", "should", "be", "passed", "by", "reference", "." ]

[ "mn10300", "8", "0" ]

[]

[ "<s>", "static", "bool", "is_microcoded_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_cpu_attr", "==", "CPU_CELL", ")", "return", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_ALWAYS", ";", "if", "(", "rs6000_sched_groups", "&&", "(", "rs6000_cpu", "==", "PROCESSOR_POWER4", "||", "rs6000_cpu", "==", "PROCESSOR_POWER5", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_YES", ")", "||", "(", "(", "type", "==", "TYPE_LOAD", "||", "type", "==", "TYPE_STORE", ")", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_YES", ")", "||", "type", "==", "TYPE_MFCR", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "a", "true", "if", "INSN", "is", "microcoded", ".", "Return", "false", "otherwise", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "optimization_options", "(", "int", "level", "ATTRIBUTE_UNUSED", ",", "int", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "flag_errno_math", "=", "0", ";", "set_param_value", "(", "\"max-grow-copy-bb-insns\"", ",", "16", ")", ";", "}", "</s>" ]

[ "Change", "optimizations", "to", "be", "performed", ",", "depending", "on", "the", "optimization", "level", ".", "LEVEL", "is", "the", "optimization", "level", "specified", ";", "2", "if", "`", "-O2", "'", "is", "specified", ",", "1", "if", "`", "-O", "'", "is", "specified", ",", "and", "0", "if", "neither", "is", "specified", ".", "SIZE", "is", "nonzero", "if", "`", "-Os", "'", "is", "specified", "and", "zero", "otherwise", "." ]

[ "rs6000", "0", "\"max-grow-copy-bb-insns\"", "16" ]

[]

[ "<s>", "bool", "c6x_block_reg_pad_upward", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "first", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "!", "TARGET_BIG_ENDIAN", ")", "return", "true", ";", "if", "(", "!", "first", ")", "return", "true", ";", "if", "(", "!", "type", ")", "return", "true", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "size", "==", "3", ";", "}", "</s>" ]

[ "Return", "true", "if", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "FIRST", ")", "should", "return", "upward", "rather", "than", "downward", "." ]

[ "c6x", "3" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "PPCTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getNewValOperand", "(", ")", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "EnableQuadwordAtomics", "&&", "Subtarget", ".", "hasQuadwordAtomics", "(", ")", "&&", "Size", "==", "128", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AI", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

[ "<s>", "SDValue", "mprocTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "mproc", "mproc", "ISD::InputArg" ]

[]

[ "<s>", "static", "bool", "sh_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "return", "(", "TARGET_SHMEDIA", "?", "(", "(", "mode", "!=", "DFmode", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_FLOAT", ")", "||", "x", "==", "CONST0_RTX", "(", "mode", ")", "||", "!", "TARGET_SHMEDIA_FPU", "||", "TARGET_SHMEDIA64", ")", ":", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "||", "mode", "==", "DFmode", "||", "mode", "==", "SFmode", "||", "mode", "==", "DImode", "||", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "can_store_by_pieces", "constructs", "VOIDmode", "CONST_DOUBLEs", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "::", "ArgumentListType", "&", "Args", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumArgs", "=", "Args", ".", "size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "Args", ".", "begin", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "MVT", "ValVT", "=", "MVT", "::", "getVT", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "bool", "Res", "=", "AssignFn", "(", "i", ",", "ValVT", ",", "ValVT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "CCInfo", ")", ";", "assert", "(", "!", "Res", "&&", "\"Call operand has unhandled type\"", ")", ";", "(", "void", ")", "Res", ";", "}", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Args", ".", "size", "(", ")", "&&", "\"We have a different number of location and args?!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Not yet implemented\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "VRegs", "[", "i", "]", ",", "VA", ".", "getLocReg", "(", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "assert", "(", "0", "&&", "\"Not yet implemented\"", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "AArch64", "AArch64", "16", "AArch64", "AArch64", "0", "MVT::getVT", "ISD::ArgFlagsTy", "\"Call operand has unhandled type\"", "\"We have a different number of location and args?!\"", "0", "\"Not yet implemented\"", "\"Unknown loc info!\"", "0", "\"Not yet implemented\"" ]

[]

[ "<s>", "const", "char", "*", "PIC16TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "PIC16ISD", "::", "Lo", ":", "return", "\"PIC16ISD::Lo\"", ";", "case", "PIC16ISD", "::", "Hi", ":", "return", "\"PIC16ISD::Hi\"", ";", "case", "PIC16ISD", "::", "MTLO", ":", "return", "\"PIC16ISD::MTLO\"", ";", "case", "PIC16ISD", "::", "MTHI", ":", "return", "\"PIC16ISD::MTHI\"", ";", "case", "PIC16ISD", "::", "MTPCLATH", ":", "return", "\"PIC16ISD::MTPCLATH\"", ";", "case", "PIC16ISD", "::", "PIC16Connect", ":", "return", "\"PIC16ISD::PIC16Connect\"", ";", "case", "PIC16ISD", "::", "Banksel", ":", "return", "\"PIC16ISD::Banksel\"", ";", "case", "PIC16ISD", "::", "PIC16Load", ":", "return", "\"PIC16ISD::PIC16Load\"", ";", "case", "PIC16ISD", "::", "PIC16LdArg", ":", "return", "\"PIC16ISD::PIC16LdArg\"", ";", "case", "PIC16ISD", "::", "PIC16LdWF", ":", "return", "\"PIC16ISD::PIC16LdWF\"", ";", "case", "PIC16ISD", "::", "PIC16Store", ":", "return", "\"PIC16ISD::PIC16Store\"", ";", "case", "PIC16ISD", "::", "PIC16StWF", ":", "return", "\"PIC16ISD::PIC16StWF\"", ";", "case", "PIC16ISD", "::", "BCF", ":", "return", "\"PIC16ISD::BCF\"", ";", "case", "PIC16ISD", "::", "LSLF", ":", "return", "\"PIC16ISD::LSLF\"", ";", "case", "PIC16ISD", "::", "LRLF", ":", "return", "\"PIC16ISD::LRLF\"", ";", "case", "PIC16ISD", "::", "RLF", ":", "return", "\"PIC16ISD::RLF\"", ";", "case", "PIC16ISD", "::", "RRF", ":", "return", "\"PIC16ISD::RRF\"", ";", "case", "PIC16ISD", "::", "CALL", ":", "return", "\"PIC16ISD::CALL\"", ";", "case", "PIC16ISD", "::", "CALLW", ":", "return", "\"PIC16ISD::CALLW\"", ";", "case", "PIC16ISD", "::", "SUBCC", ":", "return", "\"PIC16ISD::SUBCC\"", ";", "case", "PIC16ISD", "::", "SELECT_ICC", ":", "return", "\"PIC16ISD::SELECT_ICC\"", ";", "case", "PIC16ISD", "::", "BRCOND", ":", "return", "\"PIC16ISD::BRCOND\"", ";", "case", "PIC16ISD", "::", "RET", ":", "return", "\"PIC16ISD::RET\"", ";", "case", "PIC16ISD", "::", "Dummy", ":", "return", "\"PIC16ISD::Dummy\"", ";", "}", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16ISD::Lo", "\"PIC16ISD::Lo\"", "PIC16ISD::Hi", "\"PIC16ISD::Hi\"", "PIC16ISD::MTLO", "\"PIC16ISD::MTLO\"", "PIC16ISD::MTHI", "\"PIC16ISD::MTHI\"", "PIC16ISD::MTPCLATH", "\"PIC16ISD::MTPCLATH\"", "PIC16ISD::PIC16Connect", "\"PIC16ISD::PIC16Connect\"", "PIC16ISD::Banksel", "\"PIC16ISD::Banksel\"", "PIC16ISD::PIC16Load", "\"PIC16ISD::PIC16Load\"", "PIC16ISD::PIC16LdArg", "\"PIC16ISD::PIC16LdArg\"", "PIC16ISD::PIC16LdWF", "\"PIC16ISD::PIC16LdWF\"", "PIC16ISD::PIC16Store", "\"PIC16ISD::PIC16Store\"", "PIC16ISD::PIC16StWF", "\"PIC16ISD::PIC16StWF\"", "PIC16ISD::BCF", "\"PIC16ISD::BCF\"", "PIC16ISD::LSLF", "\"PIC16ISD::LSLF\"", "PIC16ISD::LRLF", "\"PIC16ISD::LRLF\"", "PIC16ISD::RLF", "\"PIC16ISD::RLF\"", "PIC16ISD::RRF", "\"PIC16ISD::RRF\"", "PIC16ISD::CALL", "\"PIC16ISD::CALL\"", "PIC16ISD::CALLW", "\"PIC16ISD::CALLW\"", "PIC16ISD::SUBCC", "\"PIC16ISD::SUBCC\"", "PIC16ISD::SELECT_ICC", "\"PIC16ISD::SELECT_ICC\"", "PIC16ISD::BRCOND", "\"PIC16ISD::BRCOND\"", "PIC16ISD::RET", "\"PIC16ISD::RET\"", "PIC16ISD::Dummy", "\"PIC16ISD::Dummy\"" ]

[]

[ "<s>", "SDNode", "*", "X86DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "MachineFunction", "*", "MF", "=", "CurBB", "->", "getParent", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "int", "mips_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "COPY_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "rclass", "]", ")", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "ST_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "ST_REGS", "]", ")", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "mips_hard_regno_mode_ok", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "{", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_MSA_REG", ")", ";", "else", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "}", "AND_COMPL_HARD_REG_SET", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ".", "Usually", "all", "registers", "are", "word-sized", ".", "The", "only", "supported", "exception", "is", "-mgp64", "-msingle-float", ",", "which", "has", "64-bit", "words", "but", "32-bit", "float", "registers", ".", "A", "word-based", "calculation", "is", "correct", "even", "in", "that", "case", ",", "since", "-msingle-float", "disallows", "multi-FPR", "values", ".", "The", "FP", "status", "registers", "are", "an", "exception", "to", "this", "rule", ".", "They", "are", "always", "4", "bytes", "wide", "as", "they", "only", "hold", "condition", "code", "modes", ",", "and", "CCmode", "is", "always", "considered", "to", "be", "4", "bytes", "wide", "." ]

[ "mips", "0x8000", "4", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "TeakFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "static", "void", "m68hc11_reassign_regs", "(", "rtx", "first", ")", "{", "rtx", "insn", ";", "ix_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_X_REGNUM", ")", ";", "iy_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_Y_REGNUM", ")", ";", "z_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_Z_REGNUM", ")", ";", "z_reg_qi", "=", "gen_rtx_REG", "(", "QImode", ",", "HARD_Z_REGNUM", ")", ";", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "body", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CODE_LABEL", "||", "GET_CODE", "(", "insn", ")", "==", "NOTE", "||", "GET_CODE", "(", "insn", ")", "==", "BARRIER", ")", "continue", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "body", ")", "==", "USE", ")", "continue", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "body", ")", "==", "ASM_INPUT", "||", "GET_CODE", "(", "body", ")", "==", "ASM_OPERANDS", "||", "GET_CODE", "(", "body", ")", "==", "UNSPEC", "||", "GET_CODE", "(", "body", ")", "==", "UNSPEC_VOLATILE", ")", "continue", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", "||", "GET_CODE", "(", "body", ")", "==", "PARALLEL", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "{", "if", "(", "reg_mentioned_p", "(", "z_reg", ",", "body", ")", ")", "{", "m68hc11_z_replacement", "(", "insn", ")", ";", "}", "}", "else", "{", "printf", "(", "\"insn not handled by Z replacement:\\n\"", ")", ";", "fflush", "(", "stdout", ")", ";", "debug_rtx", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "Scan", "all", "the", "insn", "and", "re-affects", "some", "registers", "-", "The", "Z", "register", "(", "if", "it", "was", "used", ")", ",", "is", "affected", "to", "X", "or", "Y", "depending", "on", "the", "instruction", "." ]

[ "m68hc11", "\"insn not handled by Z replacement:\\n\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AArch64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "MI", "->", "dump", "(", ")", ";", "assert", "(", "0", "&&", "\"Unexpected instruction for custom inserter!\"", ")", ";", "break", ";", "case", "AArch64", "::", "F128CSEL", ":", "return", "EmitF128CSEL", "(", "MI", ",", "BB", ")", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "return", "emitPatchPoint", "(", "MI", ",", "BB", ")", ";", "}", "llvm_unreachable", "(", "\"Unexpected instruction for custom inserter!\"", ")", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "AArch64", "AArch64", "0", "\"Unexpected instruction for custom inserter!\"", "AArch64::F128CSEL", "\"Unexpected instruction for custom inserter!\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "static", "void", "rs6000_set_up_by_prologue", "(", "struct", "hard_reg_set_container", "*", "set", ")", "{", "if", "(", "!", "TARGET_SINGLE_PIC_BASE", "&&", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", "&&", "get_pool_size", "(", ")", "!=", "0", ")", "add_to_hard_reg_set", "(", "&", "set", "->", "set", ",", "Pmode", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "}", "</s>" ]

[ "Add", "r30", "to", "hard", "reg", "set", "if", "the", "prologue", "sets", "it", "up", "and", "it", "is", "not", "pic_offset_table_rtx", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "static", "void", "pa_output_pic_pcrel_sequence", "(", "rtx", "*", "operands", ")", "{", "gcc_assert", "(", "SYMBOL_REF_P", "(", "operands", "[", "0", "]", ")", "||", "LABEL_P", "(", "operands", "[", "0", "]", ")", ")", ";", "if", "(", "TARGET_PA_20", ")", "{", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "operands", "[", "3", "]", "=", "gen_label_rtx", "(", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "operands", "[", "3", "]", ")", ")", ";", "output_asm_insn", "(", "\"mfia %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addil L'%0-%l3,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-%l3(%%r1),%2\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"mfia %1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"addil L'%0-$PIC_pcrel$0+12,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-$PIC_pcrel$0+16(%%r1),%2\"", ",", "operands", ")", ";", "}", "}", "else", "{", "output_asm_insn", "(", "\"{bl|b,l} .+8,%1\"", ",", "operands", ")", ";", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "operands", "[", "3", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"addil L'%0-%l3,%1\"", ",", "operands", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "operands", "[", "3", "]", ")", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-%l3(%%r1),%2\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"addil L'%0-$PIC_pcrel$0+4,%1\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-$PIC_pcrel$0+8(%%r1),%2\"", ",", "operands", ")", ";", "}", "}", "}", "</s>" ]

[ "Output", "a", "PIC", "pc-relative", "instruction", "sequence", "to", "load", "the", "address", "of", "OPERANDS", "[", "0", "]", "to", "register", "OPERANDS", "[", "2", "]", ".", "OPERANDS", "[", "0", "]", "is", "a", "symbol", "ref", "or", "a", "code", "label", ".", "OPERANDS", "[", "1", "]", "specifies", "the", "register", "to", "use", "to", "load", "the", "program", "counter", ".", "OPERANDS", "[", "3", "]", "may", "be", "used", "for", "label", "generation", "The", "sequence", "is", "always", "three", "instructions", "in", "length", ".", "The", "program", "counter", "recorded", "for", "PA", "1.X", "is", "eight", "bytes", "more", "than", "that", "for", "PA", "2.0", ".", "Register", "%", "r1", "is", "clobbered", "." ]

[ "pa", "0", "0", "3", "\"L\"", "3", "\"mfia %1\"", "\"addil L'%0-%l3,%1\"", "\"ldo R'%0-%l3(%%r1),%2\"", "\"mfia %1\"", "\"addil L'%0-$PIC_pcrel$0+12,%1\"", "\"ldo R'%0-$PIC_pcrel$0+16(%%r1),%2\"", "\"{bl|b,l} .+8,%1\"", "3", "\"addil L'%0-%l3,%1\"", "\"L\"", "3", "\"ldo R'%0-%l3(%%r1),%2\"", "\"addil L'%0-$PIC_pcrel$0+4,%1\"", "\"ldo R'%0-$PIC_pcrel$0+8(%%r1),%2\"" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "MIB", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tPUSH", "0", "1", "ARM::LR" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "BPFISD", "::", "RET_FLAG", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getReturnType", "(", ")", "->", "isAggregateType", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"only integer returns supported\"", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_BPF64", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "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", "(", "Opc", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::OutputArg", "BPFISD::RET_FLAG", "16", "\"only integer returns supported\"", "MVT::Other", "BPF", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "MVT::Other" ]

[]

[ "<s>", "X86TargetLowering", "::", "ConstraintType", "X86TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'R'", ":", "case", "'q'", ":", "case", "'Q'", ":", "case", "'f'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'y'", ":", "case", "'x'", ":", "case", "'Y'", ":", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'c'", ":", "case", "'d'", ":", "case", "'S'", ":", "case", "'D'", ":", "case", "'A'", ":", "return", "C_Register", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'G'", ":", "case", "'C'", ":", "case", "'e'", ":", "case", "'Z'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "X86", "X86", "X86", "1", "0" ]

[]

[ "<s>", "const", "AMDGPUInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "InstrInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "R600" ]

[]

[ "<s>", "static", "scalar_int_mode", "rs6000_eh_return_filter_mode", "(", "void", ")", "{", "return", "TARGET_32BIT", "?", "SImode", ":", "word_mode", ";", "}", "</s>" ]

[ "target", "hook", "eh_return_filter_mode" ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", ",", "EVT", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "static", "tree", "gcn_global_lock_addr", "(", ")", "{", "tree", "v", "=", "global_lock_var", ";", "if", "(", "!", "v", ")", "{", "tree", "name", "=", "get_identifier", "(", "\"__reduction_lock\"", ")", ";", "tree", "type", "=", "build_qualified_type", "(", "unsigned_type_node", ",", "TYPE_QUAL_VOLATILE", ")", ";", "v", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "VAR_DECL", ",", "name", ",", "type", ")", ";", "global_lock_var", "=", "v", ";", "DECL_ARTIFICIAL", "(", "v", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "v", ")", "=", "1", ";", "TREE_STATIC", "(", "v", ")", "=", "1", ";", "TREE_PUBLIC", "(", "v", ")", "=", "1", ";", "TREE_USED", "(", "v", ")", "=", "1", ";", "mark_addressable", "(", "v", ")", ";", "mark_decl_referenced", "(", "v", ")", ";", "}", "return", "build_fold_addr_expr", "(", "v", ")", ";", "}", "</s>" ]

[ "Lazily", "generate", "the", "global_lock_var", "decl", "and", "return", "its", "address", "." ]

[ "gcn", "\"__reduction_lock\"", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "Kind", "==", "k_Memory", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "Mips" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Instrumentation", "->", "InstrumentAndEmitInstruction", "(", "Inst", ",", "Operands", ",", "getContext", "(", ")", ",", "MII", ",", "Out", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MipsSETargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "MipsTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "Mips", "::", "BPOSGE32_PSEUDO", ":", "return", "emitBPOSGE32", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Mips", "Mips", "Mips", "Mips::BPOSGE32_PSEUDO" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "Register", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "ADDriOpc", "=", "TM", ".", "isPPC64", "(", ")", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", "->", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "TII", ".", "get", "(", "ADDriOpc", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "BaseReg", ",", "TII", ".", "getRegClass", "(", "MCID", ",", "0", ",", "this", ",", "MF", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "MCID", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::ADDI8", "PPC::ADDI", "PPC", "PPC", "0" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "getAMDGPUTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "return", "createR600MachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600" ]

[]

[ "<s>", "bool", "MOSAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "MOS", "MOS" ]

[]