Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "Optional", "<", "MCFixupKind", ">", "ELFPPCAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "TT", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "Type", ";", "if", "(", "TT", ".", "isPPC64", "(", ")", ")", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "else", "{", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "}", "if", "(", "Type", "!=", "-", "1u", ")", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "PowerPC", "PPC", "PPC", "1u", "1u", "1u" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "llvm_unreachable", "(", "\"applyFixup() unimplemented\"", ")", ";", "}", "</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", "." ]

[ "VE", "\"applyFixup() unimplemented\"" ]

[]

[ "<s>", "bool", "x86_maybe_negate_const_int", "(", "rtx", "*", "loc", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "val", ";", "if", "(", "!", "CONST_INT_P", "(", "*", "loc", ")", ")", "return", "false", ";", "switch", "(", "mode", ")", "{", "case", "DImode", ":", "gcc_assert", "(", "x86_64_immediate_operand", "(", "*", "loc", ",", "mode", ")", ")", ";", "mode", "=", "SImode", ";", "break", ";", "case", "SImode", ":", "case", "HImode", ":", "case", "QImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "mode_signbit_p", "(", "mode", ",", "*", "loc", ")", ")", "return", "false", ";", "val", "=", "INTVAL", "(", "*", "loc", ")", ";", "if", "(", "(", "val", "<", "0", "&&", "val", "!=", "-", "128", ")", "||", "val", "==", "128", ")", "{", "*", "loc", "=", "GEN_INT", "(", "-", "val", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "profitable", ",", "negate", "(", "without", "causing", "overflow", ")", "integer", "constant", "of", "mode", "MODE", "at", "location", "LOC", ".", "Return", "true", "in", "this", "case", "." ]

[ "i386", "0", "128", "128" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "FalkorHWPFFix", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "auto", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Falkor", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineLoopInfo", "&", "LI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "Modified", "=", "false", ";", "for", "(", "MachineLoop", "*", "I", ":", "LI", ")", "for", "(", "MachineLoop", "*", "L", ":", "depth_first", "(", "I", ")", ")", "if", "(", "L", "->", "isInnermost", "(", ")", ")", "runOnLoop", "(", "*", "L", ",", "Fn", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "XCore", "XCore", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "GetElementPtr", "&&", "Idx", "!=", "0", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "{", "if", "(", "Imm", "==", "255", "||", "Imm", "==", "65535", ")", "return", "0", ";", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "Imm", ".", "isAllOnes", "(", ")", ")", "return", "0", ";", "if", "(", "Inst", "&&", "(", "(", "ST", "->", "hasV6Ops", "(", ")", "&&", "!", "ST", "->", "isThumb", "(", ")", ")", "||", "ST", "->", "isThumb2", "(", ")", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "<=", "32", ")", "{", "if", "(", "isSSATMinMaxPattern", "(", "Inst", ",", "Imm", ")", "||", "(", "isa", "<", "ICmpInst", ">", "(", "Inst", ")", "&&", "Inst", "->", "hasOneUse", "(", ")", "&&", "isSSATMinMaxPattern", "(", "cast", "<", "Instruction", ">", "(", "*", "Inst", "->", "user_begin", "(", ")", ")", ",", "Imm", ")", ")", ")", "return", "0", ";", "}", "if", "(", "Inst", "&&", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Idx", "==", "1", "&&", "Imm", ".", "isAllOnesValue", "(", ")", ")", "{", "ICmpInst", "::", "Predicate", "Pred", "=", "cast", "<", "ICmpInst", ">", "(", "Inst", ")", "->", "getPredicate", "(", ")", ";", "if", "(", "Pred", "==", "ICmpInst", "::", "ICMP_SGT", "||", "Pred", "==", "ICmpInst", "::", "ICMP_SLE", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "Imm", "+", "1", ",", "Ty", ",", "CostKind", ")", ")", ";", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "0", "0", "0", "255", "65535", "0", "32", "1", "12", "0", "1", "8", "0", "0", "32", "0", "1", "1" ]

[]

[ "<s>", "void", "M88kInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "printInstruction", "(", "MI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k" ]

[]

[ "<s>", "static", "void", "mips_multi_add_label", "(", "const", "char", "*", "label", ")", "{", "struct", "mips_multi_member", "*", "member", ";", "member", "=", "mips_multi_add", "(", ")", ";", "member", "->", "is_label_p", "=", "true", ";", "member", "->", "format", "=", "label", ";", "}", "</s>" ]

[ "Add", "the", "given", "label", "definition", "to", "the", "current", "multi-insn", "sequence", ".", "The", "definition", "should", "include", "the", "colon", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "pru_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "regno", "==", "FIRST_RETVAL_REGNUM", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "pru" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "AMDGPUOperand", ">", "CreateReg", "(", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "const", "MCRegisterInfo", "*", "TRI", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "TRI", "=", "TRI", ";", "Op", "->", "Reg", ".", "Modifiers", "=", "-", "1", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

[ "R600", "1" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "enableStackSlotScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "return", "AFI", "->", "hasCalleeSaveStackFreeSpace", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "stack", "slot", "holes", "in", "the", "fixed", "and", "callee-save", "stack", "area", "should", "be", "used", "when", "allocating", "other", "stack", "locations", "to", "reduce", "stack", "size", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Lower br_unless\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Lower br_unless\"" ]

[]

[ "<s>", "static", "tree", "ix86_veclibabi_acml", "(", "combined_fn", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "20", "]", "=", "\"__vr.._\"", ";", "tree", "fntype", ",", "new_fndecl", ",", "args", ";", "unsigned", "arity", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "TARGET_64BIT", "||", "!", "flag_unsafe_math_optimizations", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_SIN", ":", "CASE_CFN_COS", ":", "CASE_CFN_EXP", ":", "CASE_CFN_LOG", ":", "CASE_CFN_LOG2", ":", "CASE_CFN_LOG10", ":", "if", "(", "el_mode", "==", "DFmode", "&&", "n", "==", "2", ")", "{", "name", "[", "4", "]", "=", "'d'", ";", "name", "[", "5", "]", "=", "'2'", ";", "}", "else", "if", "(", "el_mode", "==", "SFmode", "&&", "n", "==", "4", ")", "{", "name", "[", "4", "]", "=", "'s'", ";", "name", "[", "5", "]", "=", "'4'", ";", "}", "else", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "tree", "fndecl", "=", "mathfn_built_in", "(", "TREE_TYPE", "(", "type_in", ")", ",", "fn", ")", ";", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "sprintf", "(", "name", "+", "7", ",", "\"%s\"", ",", "bname", "+", "10", ")", ";", "arity", "=", "0", ";", "for", "(", "args", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "arity", "++", ";", "if", "(", "arity", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

[ "Handler", "for", "an", "ACML-style", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "i386", "20", "\"__vr.._\"", "2", "4", "5", "4", "4", "5", "7", "\"%s\"", "10", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "arc_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "register", "rtx", "base", ",", "index", "=", "0", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "if", "(", "SYMBOL_REF_SMALL_P", "(", "addr", ")", ")", "fprintf", "(", "file", ",", "\"@sda\"", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "MULT", ")", "index", "=", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "index", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "base", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ",", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "base", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "base", ")", ";", "if", "(", "CONSTANT_P", "(", "base", ")", "&&", "CONST_INT_P", "(", "index", ")", ")", "fputc", "(", "'+'", ",", "file", ")", ";", "else", "fputc", "(", "','", ",", "file", ")", ";", "gcc_assert", "(", "OBJECT_P", "(", "index", ")", ")", ";", "arc_print_operand_address", "(", "file", ",", "index", ")", ";", "break", ";", "case", "CONST", ":", "{", "rtx", "c", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "c", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "output_address", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "break", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "if", "(", "flag_pic", ")", "arc_output_pic_addr_const", "(", "file", ",", "addr", ",", "0", ")", ";", "else", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "arc", "0", "\"@sda\"", "0", "0", "0", "1", "0", "0", "1", "0", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "bpf_core_reloc_add", "(", "const", "tree", "type", ",", "const", "char", "*", "section_name", ",", "vec", "<", "unsigned", "int", ">", "*", "accessors", ",", "rtx_code_label", "*", "label", ")", "{", "char", "buf", "[", "40", "]", ";", "unsigned", "int", "i", ",", "n", "=", "0", ";", "if", "(", "accessors", "->", "length", "(", ")", "<", "1", ")", "return", ";", "for", "(", "i", "=", "0", ";", "i", "<", "accessors", "->", "length", "(", ")", "-", "1", ";", "i", "++", ")", "n", "+=", "snprintf", "(", "buf", "+", "n", ",", "sizeof", "(", "buf", ")", "-", "n", ",", "\"%u:\"", ",", "(", "*", "accessors", ")", "[", "i", "]", ")", ";", "snprintf", "(", "buf", "+", "n", ",", "sizeof", "(", "buf", ")", "-", "n", ",", "\"%u\"", ",", "(", "*", "accessors", ")", "[", "i", "]", ")", ";", "bpf_core_reloc_ref", "bpfcr", "=", "ggc_cleared_alloc", "<", "bpf_core_reloc_t", ">", "(", ")", ";", "ctf_container_ref", "ctfc", "=", "ctf_get_tu_ctfc", "(", ")", ";", "ctf_add_string", "(", "ctfc", ",", "buf", ",", "&", "(", "bpfcr", "->", "bpfcr_astr_off", ")", ",", "CTF_AUX_STRTAB", ")", ";", "bpfcr", "->", "bpfcr_type", "=", "get_btf_id", "(", "ctf_lookup_tree_type", "(", "ctfc", ",", "type", ")", ")", ";", "bpfcr", "->", "bpfcr_insn_label", "=", "label", ";", "bpfcr", "->", "bpfcr_kind", "=", "BPF_RELO_FIELD_BYTE_OFFSET", ";", "bpf_core_section_ref", "sec", ";", "FOR_EACH_VEC_ELT", "(", "*", "bpf_core_sections", ",", "i", ",", "sec", ")", "if", "(", "strcmp", "(", "sec", "->", "name", ",", "section_name", ")", "==", "0", ")", "{", "vec_safe_push", "(", "sec", "->", "relocs", ",", "bpfcr", ")", ";", "return", ";", "}", "sec", "=", "ggc_cleared_alloc", "<", "bpf_core_section_t", ">", "(", ")", ";", "ctf_add_string", "(", "ctfc", ",", "section_name", ",", "&", "sec", "->", "name_offset", ",", "CTF_AUX_STRTAB", ")", ";", "if", "(", "strcmp", "(", "section_name", ",", "\"\"", ")", ")", "ctfc", "->", "ctfc_aux_strlen", "+=", "strlen", "(", "section_name", ")", "+", "1", ";", "sec", "->", "name", "=", "section_name", ";", "vec_alloc", "(", "sec", "->", "relocs", ",", "1", ")", ";", "vec_safe_push", "(", "sec", "->", "relocs", ",", "bpfcr", ")", ";", "vec_safe_push", "(", "bpf_core_sections", ",", "sec", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "BPF", "CO-RE", "relocation", "record", ",", "and", "add", "it", "to", "the", "appropriate", "CO-RE", "section", "." ]

[ "bpf", "40", "0", "1", "0", "1", "\"%u:\"", "\"%u\"", "0", "\"\"", "1", "1" ]

[]

[ "<s>", "void", "HexagonSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "int", "SrcOpIdx", ",", "SUnit", "*", "Dst", ",", "int", "DstOpIdx", ",", "SDep", "&", "Dep", ")", "const", "{", "MachineInstr", "*", "SrcInst", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstInst", "=", "Dst", "->", "getInstr", "(", ")", ";", "if", "(", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "getInstrInfo", "(", ")", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclSrc", ";", "SmallSet", "<", "SUnit", "*", ",", "4", ">", "ExclDst", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "if", "(", "!", "hasV60Ops", "(", ")", ")", "return", ";", "if", "(", "DstInst", "->", "isCopy", "(", ")", ")", "Dep", ".", "setLatency", "(", "0", ")", ";", "if", "(", "(", "DstInst", "->", "isRegSequence", "(", ")", "||", "DstInst", "->", "isCopy", "(", ")", ")", "&&", "Dst", "->", "NumSuccs", "==", "1", ")", "{", "Register", "DReg", "=", "DstInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MachineInstr", "*", "DDst", "=", "Dst", "->", "Succs", "[", "0", "]", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ";", "unsigned", "UseIdx", "=", "-", "1", ";", "for", "(", "unsigned", "OpNum", "=", "0", ";", "OpNum", "<", "DDst", "->", "getNumOperands", "(", ")", ";", "OpNum", "++", ")", "{", "const", "MachineOperand", "&", "MO", "=", "DDst", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "DReg", ")", "{", "UseIdx", "=", "OpNum", ";", "break", ";", "}", "}", "int", "DLatency", "=", "(", "InstrInfo", ".", "getOperandLatency", "(", "&", "InstrItins", ",", "*", "SrcInst", ",", "0", ",", "*", "DDst", ",", "UseIdx", ")", ")", ";", "DLatency", "=", "std", "::", "max", "(", "DLatency", ",", "0", ")", ";", "Dep", ".", "setLatency", "(", "(", "unsigned", ")", "DLatency", ")", ";", "}", "ExclSrc", ".", "clear", "(", ")", ";", "ExclDst", ".", "clear", "(", ")", ";", "if", "(", "EnableDotCurSched", "&&", "QII", "->", "isToBeScheduledASAP", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ",", "ExclSrc", ",", "ExclDst", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "updateLatency", "(", "*", "SrcInst", ",", "*", "DstInst", ",", "Dep", ")", ";", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "4", "4", "0", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CCAssignFnForCall", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "}", "else", "{", "analyzeFormalArgumentsCompute", "(", "CCInfo", ",", "Ins", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "AMDGPU", "::", "isShader", "(", "CallConv", ")", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "R600", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUASI", ".", "PARAM_I_ADDRESS", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "getOrigArgIndex", "(", ")", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Alignment", "=", "MinAlign", "(", "VT", ".", "getStoreSize", "(", ")", ",", "PartOffset", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "PartOffset", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "Alignment", ",", "MachineMemOperand", "::", "MONonTemporal", "|", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "AMDGPU", "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "AMDGPU::isShader", "0", "ISD::InputArg", "AMDGPU::isShader", "R600::R600_Reg128RegClass", "SI", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "ISD::UNINDEXED", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "ix86_hard_regno_scratch_ok", "(", "unsigned", "int", "regno", ")", "{", "return", "(", "!", "cfun", "->", "machine", "->", "no_caller_saved_registers", "||", "(", "!", "epilogue_completed", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "REGNO", "can", "be", "used", "as", "a", "scratch", "register", "in", "peephole2", "." ]

[ "i386" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SICFrameLowering", "::", "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", ")", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "static", "rtx", "nios2_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fn", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "ret_type", ")", ",", "FIRST_RETVAL_REGNO", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "bool", "rs6000_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "bool", "ret", "=", "false", ";", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "if", "(", "!", "callee_tree", ")", "ret", "=", "true", ";", "else", "if", "(", "!", "caller_tree", ")", "ret", "=", "false", ";", "else", "{", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "if", "(", "(", "caller_opts", "->", "x_rs6000_isa_flags", "&", "callee_opts", "->", "x_rs6000_isa_flags", ")", "==", "callee_opts", "->", "x_rs6000_isa_flags", ")", "ret", "=", "true", ";", "}", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_can_inline_p:, caller %s, callee %s, %s inline\\n\"", ",", "(", "DECL_NAME", "(", "caller", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "caller", ")", ")", ":", "\"<unknown>\"", ")", ",", "(", "DECL_NAME", "(", "callee", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "callee", ")", ")", ":", "\"<unknown>\"", ")", ",", "(", "ret", "?", "\"can\"", ":", "\"cannot\"", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "determine", "if", "one", "function", "can", "safely", "inline", "another", "." ]

[ "rs6000", "\"rs6000_can_inline_p:, caller %s, callee %s, %s inline\\n\"", "\"<unknown>\"", "\"<unknown>\"", "\"can\"", "\"cannot\"" ]

[]

[ "<s>", "static", "void", "indirect_thunk_name", "(", "char", "name", "[", "32", "]", ",", "unsigned", "int", "regno", ",", "enum", "indirect_thunk_prefix", "need_prefix", ",", "bool", "ret_p", ")", "{", "if", "(", "regno", "!=", "INVALID_REGNUM", "&&", "regno", "!=", "CX_REG", "&&", "ret_p", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "const", "char", "*", "prefix", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_nt", "&&", "regno", "!=", "INVALID_REGNUM", ")", "{", "prefix", "=", "\"_nt\"", ";", "}", "else", "prefix", "=", "\"\"", ";", "const", "char", "*", "ret", "=", "ret_p", "?", "\"return\"", ":", "\"indirect\"", ";", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "{", "const", "char", "*", "reg_prefix", ";", "if", "(", "LEGACY_INT_REGNO_P", "(", "regno", ")", ")", "reg_prefix", "=", "TARGET_64BIT", "?", "\"r\"", ":", "\"e\"", ";", "else", "reg_prefix", "=", "\"\"", ";", "sprintf", "(", "name", ",", "\"__x86_%s_thunk%s_%s%s\"", ",", "ret", ",", "prefix", ",", "reg_prefix", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "else", "sprintf", "(", "name", ",", "\"__x86_%s_thunk%s\"", ",", "ret", ",", "prefix", ")", ";", "}", "else", "{", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LITR\"", ",", "regno", ")", ";", "else", "{", "if", "(", "ret_p", ")", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LRT\"", ",", "0", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LIT\"", ",", "0", ")", ";", "}", "}", "}", "</s>" ]

[ "Fills", "in", "the", "label", "name", "that", "should", "be", "used", "for", "the", "indirect", "thunk", "." ]

[ "i386", "32", "\"_nt\"", "\"\"", "\"return\"", "\"indirect\"", "\"r\"", "\"e\"", "\"\"", "\"__x86_%s_thunk%s_%s%s\"", "\"__x86_%s_thunk%s\"", "\"LITR\"", "\"LRT\"", "0", "\"LIT\"", "0" ]

[]

[ "<s>", "inline", "bool", "isKMergeMasked", "(", "uint64_t", "TSFlags", ")", "{", "return", "isKMasked", "(", "TSFlags", ")", "&&", "(", "TSFlags", "&", "X86II", "::", "EVEX_Z", ")", "==", "0", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "k-merge-masked", "opcodes", "." ]

[ "X86", "X86II::EVEX_Z", "0" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "Idx", "==", "getVGPRPressureSet", "(", ")", "||", "Idx", "==", "getAGPRPressureSet", "(", ")", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "if", "(", "Idx", "==", "getSGPRPressureSet", "(", ")", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "return", "AMDGPURegisterInfo", "::", "getRegPressureSetLimit", "(", "MF", ",", "Idx", ")", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "AMDGPU", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU" ]

[]

[ "<s>", "static", "void", "sparc_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "rtx", "g1", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "if", "(", "size", "<=", "PROBE_INTERVAL", ")", "{", "emit_move_insn", "(", "g1", ",", "GEN_INT", "(", "first", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "g1", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "g1", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "g1", ",", "-", "size", ")", ")", ";", "}", "else", "if", "(", "size", "<=", "5", "*", "PROBE_INTERVAL", ")", "{", "HOST_WIDE_INT", "i", ";", "emit_move_insn", "(", "g1", ",", "GEN_INT", "(", "first", "+", "PROBE_INTERVAL", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "g1", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "g1", ")", ")", ")", ";", "emit_stack_probe", "(", "g1", ")", ";", "for", "(", "i", "=", "2", "*", "PROBE_INTERVAL", ";", "i", "<", "size", ";", "i", "+=", "PROBE_INTERVAL", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "g1", ",", "plus_constant", "(", "Pmode", ",", "g1", ",", "-", "PROBE_INTERVAL", ")", ")", ")", ";", "emit_stack_probe", "(", "g1", ")", ";", "}", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "g1", ",", "(", "i", "-", "PROBE_INTERVAL", ")", "-", "size", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "rounded_size", ";", "rtx", "g4", "=", "gen_rtx_REG", "(", "Pmode", ",", "4", ")", ";", "emit_move_insn", "(", "g1", ",", "GEN_INT", "(", "first", ")", ")", ";", "rounded_size", "=", "size", "&", "-", "PROBE_INTERVAL", ";", "emit_move_insn", "(", "g4", ",", "GEN_INT", "(", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "g1", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "g1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "g4", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "g1", ",", "g4", ")", ")", ")", ";", "if", "(", "TARGET_ARCH64", ")", "emit_insn", "(", "gen_probe_stack_rangedi", "(", "g1", ",", "g1", ",", "g4", ")", ")", ";", "else", "emit_insn", "(", "gen_probe_stack_rangesi", "(", "g1", ",", "g1", ",", "g4", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "g4", ",", "rounded_size", "-", "size", ")", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", ".", "Note", "that", "we", "do", "n't", "use", "the", "REG+REG", "addressing", "mode", "for", "the", "probes", "because", "of", "the", "stack", "bias", "in", "64-bit", "mode", ".", "And", "it", "does", "n't", "really", "buy", "us", "anything", "so", "the", "advantages", "of", "having", "a", "single", "code", "win", "here", "." ]

[ "sparc", "1", "5", "2", "4" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AMDGPURegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", ")", "const", "{", "return", "&", "CalleeSavedReg", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_LEG", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "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", "(", "LEGISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "pad_groups", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx", "prev_head_insn", ",", "rtx", "tail", ")", "{", "rtx", "insn", ",", "next_insn", ";", "rtx", "nop", ";", "int", "issue_rate", ";", "int", "can_issue_more", ";", "int", "group_end", ";", "int", "group_count", "=", "0", ";", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "can_issue_more", "=", "issue_rate", ";", "insn", "=", "get_next_active_insn", "(", "prev_head_insn", ",", "tail", ")", ";", "next_insn", "=", "get_next_active_insn", "(", "insn", ",", "tail", ")", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "can_issue_more", "=", "rs6000_variable_issue", "(", "dump", ",", "sched_verbose", ",", "insn", ",", "can_issue_more", ")", ";", "group_end", "=", "(", "next_insn", "==", "NULL_RTX", "||", "GET_MODE", "(", "next_insn", ")", "==", "TImode", ")", ";", "if", "(", "next_insn", "==", "NULL_RTX", ")", "break", ";", "if", "(", "group_end", ")", "{", "if", "(", "can_issue_more", "&&", "(", "rs6000_sched_insert_nops", "==", "sched_finish_pad_groups", ")", "&&", "!", "insn_terminates_group_p", "(", "insn", ",", "current_group", ")", "&&", "!", "insn_terminates_group_p", "(", "next_insn", ",", "previous_group", ")", ")", "{", "if", "(", "!", "is_branch_slot_insn", "(", "next_insn", ")", ")", "can_issue_more", "--", ";", "while", "(", "can_issue_more", ")", "{", "nop", "=", "gen_nop", "(", ")", ";", "emit_insn_before", "(", "nop", ",", "next_insn", ")", ";", "can_issue_more", "--", ";", "}", "}", "can_issue_more", "=", "issue_rate", ";", "group_count", "++", ";", "}", "insn", "=", "next_insn", ";", "next_insn", "=", "get_next_active_insn", "(", "insn", ",", "tail", ")", ";", "}", "return", "group_count", ";", "}", "</s>" ]

[ "Scan", "the", "insn", "sequence", "between", "PREV_HEAD_INSN", "and", "TAIL", "and", "examine", "the", "dispatch", "group", "boundaries", "that", "the", "scheduler", "had", "marked", ".", "Pad", "with", "nops", "any", "dispatch", "groups", "which", "have", "vacant", "issue", "slots", ",", "in", "order", "to", "force", "the", "scheduler", "'s", "grouping", "on", "the", "processor", "dispatcher", ".", "The", "function", "returns", "the", "number", "of", "dispatch", "groups", "found", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "CAHP" ]

[]

[ "<s>", "bool", "invalidate", "(", "Function", "&", ",", "const", "PreservedAnalyses", "&", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Handle", "invalidation", "events", "from", "the", "new", "pass", "manager", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "X86IntelAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "Mang", "->", "markCharUnacceptable", "(", "'.'", ")", ";", "O", "<<", "\"\\t.686\\n\\t.MMX\\n\\t.XMM\\n\\t.model flat\\n\\n\"", ";", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "isDeclaration", "(", ")", ")", "{", "std", "::", "string", "Name", "=", "Mang", "->", "getMangledName", "(", "I", ")", ";", "decorateName", "(", "Name", ",", "I", ")", ";", "O", "<<", "\"\\tEXTERN \"", ";", "if", "(", "I", "->", "hasDLLImportLinkage", "(", ")", ")", "{", "O", "<<", "\"__imp_\"", ";", "}", "O", "<<", "Name", "<<", "\":near\\n\"", ";", "}", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isDeclaration", "(", ")", ")", "{", "std", "::", "string", "Name", "=", "Mang", "->", "getMangledName", "(", "I", ")", ";", "O", "<<", "\"\\tEXTERN \"", ";", "if", "(", "I", "->", "hasDLLImportLinkage", "(", ")", ")", "{", "O", "<<", "\"__imp_\"", ";", "}", "O", "<<", "Name", "<<", "\":byte\\n\"", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\t.686\\n\\t.MMX\\n\\t.XMM\\n\\t.model flat\\n\\n\"", "\"\\tEXTERN \"", "\"__imp_\"", "\":near\\n\"", "\"\\tEXTERN \"", "\"__imp_\"", "\":byte\\n\"" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "computeDataLayout", "(", "TargetTriple", ")", ")", ",", "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", "(", "DL", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "FrameLowering", "(", "TargetFrameLowering", "::", "StackGrowsDown", ",", "getStackAlignment", "(", ")", ",", "is64Bit", "(", ")", "?", "-", "8", ":", "-", "4", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "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", "8", "4" ]

[]

[ "<s>", "bool", "nds32_symbol_load_store_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "mem_src", "=", "NULL_RTX", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "mem_src", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "mem_src", "=", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "mem_src", "!=", "NULL_RTX", ")", "{", "if", "(", "(", "GET_CODE", "(", "mem_src", ")", "==", "ZERO_EXTEND", ")", "||", "(", "GET_CODE", "(", "mem_src", ")", "==", "SIGN_EXTEND", ")", ")", "mem_src", "=", "XEXP", "(", "mem_src", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "||", "(", "GET_CODE", "(", "XEXP", "(", "mem_src", ",", "0", ")", ")", "==", "LO_SUM", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "is", "load/store", "with", "SYMBOL_REF", "addressing", "mode", "and", "memory", "mode", "is", "SImode", "." ]

[ "nds32", "0", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_ADVSIMD_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "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", "(", ")", "." ]

[ "Mips", "Mips", "Mips::RA" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "LoopPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "AssumptionCacheTracker", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "static", "bool", "aarch64_macro_fusion_p", "(", "void", ")", "{", "return", "aarch64_tune_params", "->", "fuseable_ops", "!=", "AARCH64_FUSE_NOTHING", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_MACRO_FUSION_P", ".", "Return", "true", "if", "target", "supports", "instruction", "fusion", "of", "some", "sort", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "rs6000_emit_eh_reg_restore", "(", "rtx", "source", ",", "rtx", "scratch", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "operands", "[", "2", "]", ";", "operands", "[", "0", "]", "=", "source", ";", "operands", "[", "1", "]", "=", "scratch", ";", "if", "(", "info", "->", "lr_save_p", ")", "{", "rtx", "frame_rtx", "=", "stack_pointer_rtx", ";", "HOST_WIDE_INT", "sp_offset", "=", "0", ";", "rtx", "tmp", ";", "if", "(", "frame_pointer_needed", "||", "current_function_calls_alloca", "||", "info", "->", "total_size", ">", "32767", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "frame_rtx", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "rs6000_sr_alias_set", ")", ";", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "tmp", ")", ";", "frame_rtx", "=", "operands", "[", "1", "]", ";", "}", "else", "if", "(", "info", "->", "push_p", ")", "sp_offset", "=", "info", "->", "total_size", ";", "tmp", "=", "plus_constant", "(", "frame_rtx", ",", "info", "->", "lr_save_offset", "+", "sp_offset", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "rs6000_sr_alias_set", ")", ";", "emit_move_insn", "(", "tmp", ",", "operands", "[", "0", "]", ")", ";", "}", "else", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "LINK_REGISTER_REGNUM", ")", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Emit", "instructions", "to", "restore", "the", "link", "register", "after", "determining", "where", "its", "value", "has", "been", "stored", "." ]

[ "rs6000", "2", "0", "1", "0", "32767", "1", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "int", "num_insns_constant", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "val", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST_INT", ":", "val", "=", "INTVAL", "(", "op", ")", ";", "break", ";", "case", "CONST_WIDE_INT", ":", "{", "int", "insns", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "CONST_WIDE_INT_NUNITS", "(", "op", ")", ";", "i", "++", ")", "insns", "+=", "num_insns_constant_multi", "(", "CONST_WIDE_INT_ELT", "(", "op", ",", "i", ")", ",", "DImode", ")", ";", "return", "insns", ";", "}", "case", "CONST_DOUBLE", ":", "{", "const", "struct", "real_value", "*", "rv", "=", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ";", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SDmode", ")", "{", "long", "l", ";", "if", "(", "mode", "==", "SDmode", ")", "REAL_VALUE_TO_TARGET_DECIMAL32", "(", "*", "rv", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "rv", ",", "l", ")", ";", "val", "=", "l", ";", "mode", "=", "SImode", ";", "}", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DDmode", ")", "{", "long", "l", "[", "2", "]", ";", "if", "(", "mode", "==", "DDmode", ")", "REAL_VALUE_TO_TARGET_DECIMAL64", "(", "*", "rv", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "rv", ",", "l", ")", ";", "val", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "l", "[", "WORDS_BIG_ENDIAN", "?", "0", ":", "1", "]", "<<", "32", ";", "val", "|=", "l", "[", "WORDS_BIG_ENDIAN", "?", "1", ":", "0", "]", "&", "0xffffffffUL", ";", "mode", "=", "DImode", ";", "}", "else", "if", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", "||", "mode", "==", "KFmode", "||", "mode", "==", "IFmode", ")", "{", "long", "l", "[", "4", "]", ";", "int", "insns", ";", "if", "(", "mode", "==", "TDmode", ")", "REAL_VALUE_TO_TARGET_DECIMAL128", "(", "*", "rv", ",", "l", ")", ";", "else", "REAL_VALUE_TO_TARGET_LONG_DOUBLE", "(", "*", "rv", ",", "l", ")", ";", "val", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "l", "[", "WORDS_BIG_ENDIAN", "?", "0", ":", "3", "]", "<<", "32", ";", "val", "|=", "l", "[", "WORDS_BIG_ENDIAN", "?", "1", ":", "2", "]", "&", "0xffffffffUL", ";", "insns", "=", "num_insns_constant_multi", "(", "val", ",", "DImode", ")", ";", "val", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "l", "[", "WORDS_BIG_ENDIAN", "?", "2", ":", "1", "]", "<<", "32", ";", "val", "|=", "l", "[", "WORDS_BIG_ENDIAN", "?", "3", ":", "0", "]", "&", "0xffffffffUL", ";", "insns", "+=", "num_insns_constant_multi", "(", "val", ",", "DImode", ")", ";", "return", "insns", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "num_insns_constant_multi", "(", "val", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "it", "takes", "to", "form", "a", "constant", "in", "as", "many", "gprs", "are", "needed", "for", "MODE", "." ]

[ "rs6000", "0", "0", "2", "0", "1", "32", "1", "0", "0xffffffffUL", "4", "0", "3", "32", "1", "2", "0xffffffffUL", "2", "1", "32", "3", "0", "0xffffffffUL" ]

[]

[ "<s>", "int", "single_const_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "big_const_operand", "(", "op", ",", "mode", ")", "||", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "truth", "value", "of", "whether", "OP", "is", "a", "constant", "that", "require", "only", "one", "load", "to", "put", "in", "a", "register", "." ]

[ "mt", "0", "1" ]

[]

[ "<s>", "void", "setDesc", "(", "const", "MCInstrDesc", "&", "mcid", ")", "{", "MCID", "=", "&", "mcid", ";", "}", "</s>" ]

[ "Replace", "the", "instruction", "descriptor", "(", "thus", "opcode", ")", "of", "the", "current", "instruction", "with", "a", "new", "one", "." ]

[ "Hexagon" ]

[]

[ "<s>", "MachineOperand", "&", "AArch64InstrInfo", "::", "getMemOpBaseRegImmOfsOffsetOperand", "(", "MachineInstr", "&", "LdSt", ")", "const", "{", "assert", "(", "LdSt", ".", "mayLoadOrStore", "(", ")", "&&", "\"Expected a memory operation.\"", ")", ";", "MachineOperand", "&", "OfsOp", "=", "LdSt", ".", "getOperand", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "-", "1", ")", ";", "assert", "(", "OfsOp", ".", "isImm", "(", ")", "&&", "\"Offset operand wasn't immediate.\"", ")", ";", "return", "OfsOp", ";", "}", "</s>" ]

[ "Return", "the", "immediate", "offset", "of", "the", "base", "register", "in", "a", "load/store", "LdSt", "." ]

[ "AArch64", "AArch64", "\"Expected a memory operation.\"", "1", "\"Offset operand wasn't immediate.\"" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "4095", ",", "OnlyOptimizeForSize", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableSVEPostVec", ")", "{", "addPass", "(", "createSVEAddressingModesPass", "(", ")", ")", ";", "addPass", "(", "createDeadCodeEliminationPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "MCS51ShiftExpand", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "SmallVector", "<", "BinaryOperator", "*", ",", "1", ">", "ShiftInsts", ";", "auto", "&", "Ctx", "=", "F", ".", "getContext", "(", ")", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "if", "(", "!", "I", ".", "isShift", "(", ")", ")", "continue", ";", "if", "(", "I", ".", "getType", "(", ")", "!=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ")", "continue", ";", "if", "(", "isa", "<", "ConstantInt", ">", "(", "I", ".", "getOperand", "(", "1", ")", ")", ")", "continue", ";", "ShiftInsts", ".", "push_back", "(", "cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ")", ";", "}", "for", "(", "auto", "*", "I", ":", "ShiftInsts", ")", "{", "expand", "(", "I", ")", ";", "}", "return", "ShiftInsts", ".", "size", "(", ")", ">", "0", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "MCS51", "MCS51", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "sh_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "const", "unsigned", "SH_FE_INVALID", "=", "64", ";", "const", "unsigned", "SH_FE_DIVBYZERO", "=", "32", ";", "const", "unsigned", "SH_FE_OVERFLOW", "=", "16", ";", "const", "unsigned", "SH_FE_UNDERFLOW", "=", "8", ";", "const", "unsigned", "SH_FE_INEXACT", "=", "4", ";", "const", "unsigned", "HOST_WIDE_INT", "SH_FE_ALL_EXCEPT", "=", "(", "SH_FE_INVALID", "|", "SH_FE_DIVBYZERO", "|", "SH_FE_OVERFLOW", "|", "SH_FE_UNDERFLOW", "|", "SH_FE_INEXACT", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "SH_FE_EXCEPT_SHIFT", "=", "5", ";", "tree", "fenv_var", ",", "mask", ",", "ld_fenv", ",", "masked_fenv", ";", "tree", "new_fenv_var", ",", "reload_fenv", ",", "restore_fnenv", ";", "tree", "update_call", ",", "atomic_feraiseexcept", ",", "hold_fnclex", ";", "if", "(", "!", "TARGET_FPU_ANY", ")", "return", ";", "fenv_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "mask", "=", "build_int_cst", "(", "unsigned_type_node", ",", "~", "(", "(", "SH_FE_ALL_EXCEPT", "<<", "SH_FE_EXCEPT_SHIFT", ")", "|", "SH_FE_ALL_EXCEPT", ")", ")", ";", "ld_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "sh_builtin_get_fpscr", ",", "0", ")", ")", ";", "masked_fenv", "=", "build2", "(", "BIT_AND_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "mask", ")", ";", "hold_fnclex", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "fenv_var", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "masked_fenv", ",", "ld_fenv", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "*", "hold", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "fenv_var", ",", "hold_fnclex", ")", ";", "*", "clear", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "masked_fenv", ")", ";", "new_fenv_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "reload_fenv", "=", "build2", "(", "MODIFY_EXPR", ",", "unsigned_type_node", ",", "new_fenv_var", ",", "build_call_expr", "(", "sh_builtin_get_fpscr", ",", "0", ")", ")", ";", "restore_fnenv", "=", "build_call_expr", "(", "sh_builtin_set_fpscr", ",", "1", ",", "fenv_var", ")", ";", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "new_fenv_var", ")", ")", ";", "*", "update", "=", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "build2", "(", "COMPOUND_EXPR", ",", "void_type_node", ",", "reload_fenv", ",", "restore_fnenv", ")", ",", "update_call", ")", ";", "}", "</s>" ]

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

[ "sh", "64", "32", "16", "8", "4", "5", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isPreLd", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "LDRWpre", ":", "case", "AArch64", "::", "LDRXpre", ":", "case", "AArch64", "::", "LDRSpre", ":", "case", "AArch64", "::", "LDRDpre", ":", "case", "AArch64", "::", "LDRQpre", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "pre-indexed", "load", "." ]

[ "AArch64", "AArch64", "AArch64::LDRWpre", "AArch64::LDRXpre", "AArch64::LDRSpre", "AArch64::LDRDpre", "AArch64::LDRQpre" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createRISCVISelDag", "(", "getRISCVTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "void", "mn10300_split_cbranch", "(", "machine_mode", "cmp_mode", ",", "rtx", "cmp_op", ",", "rtx", "label_ref", ")", "{", "rtx", "flags", ",", "x", ";", "flags", "=", "gen_rtx_REG", "(", "cmp_mode", ",", "CC_REG", ")", ";", "x", "=", "gen_rtx_COMPARE", "(", "cmp_mode", ",", "XEXP", "(", "cmp_op", ",", "0", ")", ",", "XEXP", "(", "cmp_op", ",", "1", ")", ")", ";", "x", "=", "gen_rtx_SET", "(", "flags", ",", "x", ")", ";", "emit_insn", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "GET_CODE", "(", "cmp_op", ")", ",", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "label_ref", ",", "pc_rtx", ")", ";", "x", "=", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ";", "emit_jump_insn", "(", "x", ")", ";", "}", "</s>" ]

[ "A", "helper", "function", "for", "splitting", "cbranch", "patterns", "after", "reload", "." ]

[ "mn10300", "0", "1" ]

[]

[ "<s>", "static", "void", "aarch64_emit_load_exclusive", "(", "machine_mode", "mode", ",", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "model_rtx", ")", "{", "if", "(", "mode", "==", "TImode", ")", "emit_insn", "(", "gen_aarch64_load_exclusive_pair", "(", "gen_lowpart", "(", "DImode", ",", "rval", ")", ",", "gen_highpart", "(", "DImode", ",", "rval", ")", ",", "mem", ",", "model_rtx", ")", ")", ";", "else", "emit_insn", "(", "gen_aarch64_load_exclusive", "(", "mode", ",", "rval", ",", "mem", ",", "model_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "load", "exclusive", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "&", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "return", ";", "}", "if", "(", "TII", "->", "isMIMG", "(", "MI", ")", ")", "{", "unsigned", "VReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "DmaskIdx", "=", "MI", ".", "getNumOperands", "(", ")", "==", "12", "?", "3", ":", "4", ";", "unsigned", "Writemask", "=", "MI", ".", "getOperand", "(", "DmaskIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", ".", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "0", ")", ")", ")", "{", "unsigned", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", ".", "RemoveOperand", "(", "0", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "0", "12", "3", "4", "0", "0", "4", "1", "1", "0", "1", "AMDGPU::VGPR_32RegClass", "2", "AMDGPU::VReg_64RegClass", "3", "AMDGPU::VReg_96RegClass", "AMDGPU::getAtomicNoRetOp", "1", "0", "0", "1", "0", "AMDGPU::EXTRACT_SUBREG", "0", "0", "0", "AMDGPU::IMPLICIT_DEF" ]

[]

[ "<s>", "SDValue", "HSAILTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsic_Wo_ChainCombine", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "unsigned", "int", "TL45AsmBackend", "::", "getNumFixupKinds", "(", ")", "const", "{", "return", "TL45", "::", "Fixups", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "TL45", "TL45", "TL45::Fixups" ]

[]

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

[ "targetHandlesStackFrameRounding", "-", "Returns", "true", "if", "the", "target", "is", "responsible", "for", "rounding", "up", "the", "stack", "frame", "(", "probably", "at", "emitPrologue", "time", ")", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "bool", "ft32_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "1", ";", "return", "(", "to", "==", "FRAME_POINTER_REGNUM", ")", "||", "!", "ft32_frame_pointer_required", "(", ")", ";", "}", "</s>" ]

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

[ "ft32", "1" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "&", "AMDGPUAnnotateKernelFeaturesID", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createSITypeRewriter", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "\"Empty shufflevector input\"", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "\"Unmatched number of shufflevectors and indices\"", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "0", "]", "->", "getType", "(", ")", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "bool", "EltIs64Bits", "=", "DL", ".", "getTypeSizeInBits", "(", "EltTy", ")", "==", "64", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "VecSize", "!=", "64", "&&", "VecSize", "!=", "128", ")", "||", "EltIs64Bits", ")", "return", "false", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "arm_neon_vld2", ",", "Intrinsic", "::", "arm_neon_vld3", ",", "Intrinsic", "::", "arm_neon_vld4", "}", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "SmallVector", "<", "Value", "*", ",", "2", ">", "Ops", ";", "Type", "*", "Int8Ptr", "=", "Builder", ".", "getInt8PtrTy", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "Int8Ptr", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "getInt32", "(", "LI", "->", "getAlignment", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "VecTy", ",", "Int8Ptr", "}", ";", "Function", "*", "VldnFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "CallInst", "*", "VldN", "=", "Builder", ".", "CreateCall", "(", "VldnFunc", ",", "Ops", ",", "\"vldN\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SV", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "VldN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SV", "->", "getType", "(", ")", ")", ";", "SV", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "ARM", "ARM", "2", "\"Invalid interleave factor\"", "\"Empty shufflevector input\"", "\"Unmatched number of shufflevectors and indices\"", "0", "64", "64", "128", "Intrinsic::ID", "3", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "2", "Intrinsic::getDeclaration", "2", "\"vldN\"", "0" ]

[]

[ "<s>", "virtual", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"P2 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "P2", "\"P2 Assembly Printer\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR64_loRegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR64_loRegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "static", "unsigned", "s390_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "s390_tune", "<", "PROCESSOR_2097_Z10", ")", "return", "nunroll", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "subrtx_iterator", "::", "array_type", "array", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "INSN_CODE", "(", "insn", ")", "!=", "-", "1", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", ")", "mem_count", "+=", "1", ";", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "==", "0", ")", "return", "nunroll", ";", "switch", "(", "loop_depth", "(", "loop", ")", ")", "{", "case", "1", ":", "return", "MIN", "(", "nunroll", ",", "28", "/", "mem_count", ")", ";", "case", "2", ":", "return", "MIN", "(", "nunroll", ",", "22", "/", "mem_count", ")", ";", "default", ":", "return", "MIN", "(", "nunroll", ",", "16", "/", "mem_count", ")", ";", "}", "}", "</s>" ]

[ "This", "target", "hook", "implementation", "for", "TARGET_LOOP_UNROLL_ADJUST", "calculates", "a", "new", "number", "struct", "loop", "*", "loop", "should", "be", "unrolled", "if", "tuned", "for", "cpus", "with", "a", "built-in", "stride", "prefetcher", ".", "The", "loop", "is", "analyzed", "for", "memory", "accesses", "by", "calling", "check_dpu", "for", "each", "rtx", "of", "the", "loop", ".", "Depending", "on", "the", "loop_depth", "and", "the", "amount", "of", "memory", "accesses", "a", "new", "number", "<", "=nunroll", "is", "returned", "to", "improve", "the", "behaviour", "of", "the", "hardware", "prefetch", "unit", "." ]

[ "s390", "0", "0", "1", "1", "0", "1", "28", "2", "22", "16" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "int", "OffsetOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", ";", "int", "RegOpIdx", "=", "OffsetOpIdx", "+", "1", ";", "int", "ChanOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "chan", ")", ";", "if", "(", "isRegisterLoad", "(", "*", "MI", ")", ")", "{", "int", "DstOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "dst", ")", ";", "unsigned", "RegIndex", "=", "MI", "->", "getOperand", "(", "RegOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Channel", "=", "MI", "->", "getOperand", "(", "ChanOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Address", "=", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ";", "unsigned", "OffsetReg", "=", "MI", "->", "getOperand", "(", "OffsetOpIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "OffsetReg", "==", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", "{", "buildMovInstr", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "DstOpIdx", ")", ".", "getReg", "(", ")", ",", "getIndirectAddrRegClass", "(", ")", "->", "getRegister", "(", "Address", ")", ")", ";", "}", "else", "{", "buildIndirectRead", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "DstOpIdx", ")", ".", "getReg", "(", ")", ",", "Address", ",", "OffsetReg", ")", ";", "}", "}", "else", "if", "(", "isRegisterStore", "(", "*", "MI", ")", ")", "{", "int", "ValOpIdx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "val", ")", ";", "unsigned", "RegIndex", "=", "MI", "->", "getOperand", "(", "RegOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Channel", "=", "MI", "->", "getOperand", "(", "ChanOpIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "Address", "=", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ";", "unsigned", "OffsetReg", "=", "MI", "->", "getOperand", "(", "OffsetOpIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "OffsetReg", "==", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", "{", "buildMovInstr", "(", "MBB", ",", "MI", ",", "getIndirectAddrRegClass", "(", ")", "->", "getRegister", "(", "Address", ")", ",", "MI", "->", "getOperand", "(", "ValOpIdx", ")", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "buildIndirectWrite", "(", "MBB", ",", "MI", ",", "MI", "->", "getOperand", "(", "ValOpIdx", ")", ".", "getReg", "(", ")", ",", "calculateIndirectAddress", "(", "RegIndex", ",", "Channel", ")", ",", "OffsetReg", ")", ";", "}", "}", "else", "{", "return", "false", ";", "}", "MBB", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::INDIRECT_BASE_ADDR" ]

[]

[ "<s>", "void", "AMDGPUSubtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "MachineInstr", "*", "begin", ",", "MachineInstr", "*", "end", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "if", "(", "getGeneration", "(", ")", ">=", "SOUTHERN_ISLANDS", ")", "{", "Policy", ".", "ShouldTrackPressure", "=", "true", ";", "Policy", ".", "OnlyTopDown", "=", "false", ";", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "}", "}", "</s>" ]

[ "Override", "generic", "scheduling", "policy", "within", "a", "region", "." ]

[ "R600" ]

[]

[ "<s>", "unsigned", "size", "(", ")", "const", "{", "return", "IDs", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isDataInvariant", "(", "MachineInstr", "&", "MI", ")", "{", "if", "(", "MI", ".", "mayLoad", "(", ")", "||", "MI", ".", "mayStore", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCopyLike", "(", ")", "||", "MI", ".", "isInsertSubreg", "(", ")", ")", "return", "true", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "using", "namespace", "X86", ";", "if", "(", "isIMUL", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isBSF", "(", "Opcode", ")", "||", "isBSR", "(", "Opcode", ")", "||", "isLZCNT", "(", "Opcode", ")", "||", "isPOPCNT", "(", "Opcode", ")", "||", "isTZCNT", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isBLCFILL", "(", "Opcode", ")", "||", "isBLCI", "(", "Opcode", ")", "||", "isBLCIC", "(", "Opcode", ")", "||", "isBLCMSK", "(", "Opcode", ")", "||", "isBLCS", "(", "Opcode", ")", "||", "isBLSFILL", "(", "Opcode", ")", "||", "isBLSI", "(", "Opcode", ")", "||", "isBLSIC", "(", "Opcode", ")", "||", "isBLSMSK", "(", "Opcode", ")", "||", "isBLSR", "(", "Opcode", ")", "||", "isTZMSK", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isBEXTR", "(", "Opcode", ")", "||", "isBZHI", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isROL", "(", "Opcode", ")", "||", "isROR", "(", "Opcode", ")", "||", "isSAR", "(", "Opcode", ")", "||", "isSHL", "(", "Opcode", ")", "||", "isSHR", "(", "Opcode", ")", "||", "isSHLD", "(", "Opcode", ")", "||", "isSHRD", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isADC", "(", "Opcode", ")", "||", "isADD", "(", "Opcode", ")", "||", "isAND", "(", "Opcode", ")", "||", "isOR", "(", "Opcode", ")", "||", "isSBB", "(", "Opcode", ")", "||", "isSUB", "(", "Opcode", ")", "||", "isXOR", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isADCX", "(", "Opcode", ")", "||", "isADOX", "(", "Opcode", ")", "||", "isANDN", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isDEC", "(", "Opcode", ")", "||", "isINC", "(", "Opcode", ")", "||", "isNEG", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isNOT", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isMOVSX", "(", "Opcode", ")", "||", "isMOVZX", "(", "Opcode", ")", "||", "isMOVSXD", "(", "Opcode", ")", "||", "isMOV", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isRORX", "(", "Opcode", ")", "||", "isSARX", "(", "Opcode", ")", "||", "isSHLX", "(", "Opcode", ")", "||", "isSHRX", "(", "Opcode", ")", ")", "return", "true", ";", "if", "(", "isLEA", "(", "Opcode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "has", "no", "behavior", "(", "specified", "or", "otherwise", ")", "that", "is", "based", "on", "the", "value", "of", "any", "of", "its", "register", "operands", "." ]

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

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "OpC", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "OpC", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "B", ":", "case", "PPC", "::", "BLR", ":", "case", "PPC", "::", "BLR8", ":", "case", "PPC", "::", "BCTR", ":", "case", "PPC", "::", "BCTR8", ":", "case", "PPC", "::", "BCTRL", ":", "case", "PPC", "::", "BCTRL8", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "PowerPC", "PPC", "PPC::B", "PPC::BLR", "PPC::BLR8", "PPC::BCTR", "PPC::BCTR8", "PPC::BCTRL", "PPC::BCTRL8" ]

[]

[ "<s>", "virtual", "const", "MSP430InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "const", "AMDGPUSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "STI", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "STI", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "STI", ".", "dumpCode", "(", ")", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ",", "MF", "->", "getSubtarget", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "auto", "&", "ObjStreamer", "=", "static_cast", "<", "MCObjectStreamer", "&", ">", "(", "*", "OutStreamer", ")", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "encodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "MF", "->", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "AMDGPU", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "static", "int", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "bool", "doMergeWithPrevious", ")", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "prior", "(", "MBBI", ")", ":", "MBBI", ";", "MachineBasicBlock", "::", "iterator", "NI", "=", "doMergeWithPrevious", "?", "0", ":", "next", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "Offset", "+=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "Offset", "-=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "NI", ";", "}", "return", "Offset", ";", "}", "</s>" ]

[ "Check", "the", "instruction", "before/after", "the", "passed", "instruction", "." ]

[ "X86", "0", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "2", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "2" ]

[]

[ "<s>", "bool", "MachineConstPropagator", "::", "run", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Starting MachineConstPropagator\\n\"", ",", "nullptr", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "Cells", ".", "clear", "(", ")", ";", "EdgeExec", ".", "clear", "(", ")", ";", "InstrExec", ".", "clear", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "propagate", "(", "MF", ")", ";", "bool", "Changed", "=", "rewrite", "(", "MF", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"End of MachineConstPropagator (Changed=\"", "<<", "Changed", "<<", "\")\\n\"", ";", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", ",", "nullptr", ")", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "Hexagon", "\"Starting MachineConstPropagator\\n\"", "\"End of MachineConstPropagator (Changed=\"", "\")\\n\"" ]

[]

[ "<s>", "static", "tree", "ia64_gimplify_va_arg", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", ")", "{", "if", "(", "pass_va_arg_by_reference", "(", "type", ")", ")", "{", "tree", "ptrtype", "=", "build_pointer_type", "(", "type", ")", ";", "tree", "addr", "=", "std_gimplify_va_arg_expr", "(", "valist", ",", "ptrtype", ",", "pre_p", ",", "post_p", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "?", "int_size_in_bytes", "(", "type", ")", ">", "8", ":", "TYPE_ALIGN", "(", "type", ")", ">", "8", "*", "BITS_PER_UNIT", ")", "{", "tree", "t", "=", "fold_build_pointer_plus_hwi", "(", "valist", ",", "2", "*", "UNITS_PER_WORD", "-", "1", ")", ";", "t", "=", "build2", "(", "BIT_AND_EXPR", ",", "TREE_TYPE", "(", "t", ")", ",", "t", ",", "build_int_cst", "(", "TREE_TYPE", "(", "t", ")", ",", "-", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "valist", ")", ",", "t", ",", "pre_p", ")", ";", "}", "return", "std_gimplify_va_arg_expr", "(", "valist", ",", "type", ",", "pre_p", ",", "post_p", ")", ";", "}", "</s>" ]

[ "Implement", "va_arg", "." ]

[ "ia64", "8", "8", "2", "1", "2" ]

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "void", "rs6000_emit_swdiv", "(", "rtx", "dst", ",", "rtx", "n", ",", "rtx", "d", ",", "bool", "note_p", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "rtx", "one", ",", "x0", ",", "e0", ",", "x1", ",", "xprev", ",", "eprev", ",", "xnext", ",", "enext", ",", "u", ",", "v", ";", "int", "i", ";", "int", "passes", "=", "(", "TARGET_RECIP_PRECISION", ")", "?", "1", ":", "3", ";", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "V2DFmode", ")", "passes", "++", ";", "enum", "insn_code", "code", "=", "optab_handler", "(", "smul_optab", ",", "mode", ")", ";", "insn_gen_fn", "gen_mul", "=", "GEN_FCN", "(", "code", ")", ";", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", ")", ";", "one", "=", "rs6000_load_constant_and_splat", "(", "mode", ",", "dconst1", ")", ";", "x0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "d", ")", ",", "UNSPEC_FRES", ")", ")", ")", ";", "if", "(", "passes", ">", "1", ")", "{", "e0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_nmsub", "(", "e0", ",", "d", ",", "x0", ",", "one", ")", ";", "x1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_madd", "(", "x1", ",", "e0", ",", "x0", ",", "x0", ")", ";", "for", "(", "i", "=", "0", ",", "xprev", "=", "x1", ",", "eprev", "=", "e0", ";", "i", "<", "passes", "-", "2", ";", "++", "i", ",", "xprev", "=", "xnext", ",", "eprev", "=", "enext", ")", "{", "enext", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_mul", "(", "enext", ",", "eprev", ",", "eprev", ")", ")", ";", "xnext", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_madd", "(", "xnext", ",", "enext", ",", "xprev", ",", "xprev", ")", ";", "}", "}", "else", "xprev", "=", "x0", ";", "u", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_mul", "(", "u", ",", "n", ",", "xprev", ")", ")", ";", "v", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rs6000_emit_nmsub", "(", "v", ",", "d", ",", "u", ",", "n", ")", ";", "rs6000_emit_madd", "(", "dst", ",", "v", ",", "xprev", ",", "u", ")", ";", "if", "(", "note_p", ")", "add_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "gen_rtx_DIV", "(", "mode", ",", "n", ",", "d", ")", ")", ";", "}", "</s>" ]

[ "Newton-Raphson", "approximation", "of", "floating", "point", "divide", "DST", "=", "N/D", ".", "If", "NOTE_P", ",", "add", "a", "reg_note", "saying", "that", "this", "was", "a", "division", ".", "Support", "both", "scalar", "and", "vector", "divide", ".", "Assumes", "no", "trapping", "math", "and", "finite", "arguments", "." ]

[ "rs6000", "1", "3", "1", "1", "0", "2" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "getRegBankInfo", "(", ")", "const", "override", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getRegBankInfo", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "AMDGPU", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "MachineInstr", "*", "SystemZInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MFI", ",", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "if", "(", "LogicOp", "And", "=", "interpretAndImmediate", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "uint64_t", "Imm", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<<", "And", ".", "ImmLSB", ";", "Imm", "|=", "allOnes", "(", "And", ".", "RegSize", ")", "&", "~", "(", "allOnes", "(", "And", ".", "ImmSize", ")", "<<", "And", ".", "ImmLSB", ")", ";", "unsigned", "Start", ",", "End", ";", "if", "(", "isRxSBGMask", "(", "Imm", ",", "And", ".", "RegSize", ",", "Start", ",", "End", ")", ")", "{", "unsigned", "NewOpcode", ";", "if", "(", "And", ".", "RegSize", "==", "64", ")", "{", "NewOpcode", "=", "SystemZ", "::", "RISBG", ";", "if", "(", "STI", ".", "hasMiscellaneousExtensions", "(", ")", ")", "NewOpcode", "=", "SystemZ", "::", "RISBGN", ";", "}", "else", "{", "NewOpcode", "=", "SystemZ", "::", "RISBMux", ";", "Start", "&=", "31", ";", "End", "&=", "31", ";", "}", "MachineOperand", "&", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpcode", ")", ")", ".", "add", "(", "Dest", ")", ".", "addReg", "(", "0", ")", ".", "addReg", "(", "Src", ".", "getReg", "(", ")", ",", "getKillRegState", "(", "Src", ".", "isKill", "(", ")", ")", ",", "Src", ".", "getSubReg", "(", ")", ")", ".", "addImm", "(", "Start", ")", ".", "addImm", "(", "End", "+", "128", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "LV", ")", "{", "unsigned", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "I", "=", "1", ";", "I", "<", "NumOps", ";", "++", "I", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isKill", "(", ")", ")", "LV", "->", "replaceKillInstruction", "(", "Op", ".", "getReg", "(", ")", ",", "MI", ",", "*", "MIB", ")", ";", "}", "}", "transferDeadCC", "(", "&", "MI", ",", "MIB", ")", ";", "return", "MIB", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "SystemZ", "SystemZ", "2", "64", "SystemZ::RISBG", "SystemZ::RISBGN", "SystemZ::RISBMux", "31", "31", "0", "1", "0", "128", "0", "1" ]

[]

[ "<s>", "bool", "z8k_regno_ok_for_base_p", "(", "int", "regno", ",", "bool", "strict_p", ")", "{", "if", "(", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "regno", "!=", "0", ")", "{", "if", "(", "!", "strict_p", ")", "return", "true", ";", "if", "(", "!", "reg_renumber", ")", "return", "false", ";", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "}", "return", "regno", "<", "FIRST_PSEUDO_REGISTER", "&&", "regno", ">", "0", ";", "}", "</s>" ]

[ "It", "'s", "ok", "for", "a", "base", "reg", "if", "it", "'s", "in", "a", "hard", "reg", "which", "is", "not", "0", "or", "it", "will", "be", "renumbered", "on", "the", "way", "out", "and", "its", "not", "-1", "or", "0" ]

[ "z8k", "0", "0" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "WebAssembly", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getPICJumpTableRelocBase", "(", "SDValue", "Table", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", "||", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "TargetLowering", "::", "getPICJumpTableRelocBase", "(", "Table", ",", "DAG", ")", ";", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Medium", ":", "return", "TargetLowering", "::", "getPICJumpTableRelocBase", "(", "Table", ",", "DAG", ")", ";", "default", ":", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "GlobalBaseReg", ",", "SDLoc", "(", ")", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Returns", "relocation", "base", "for", "the", "given", "PIC", "jumptable", "." ]

[ "PowerPC", "PPC", "PPC", "PPCISD::GlobalBaseReg" ]

[]

[ "<s>", "rtx", "alpha_gp_save_rtx", "(", "void", ")", "{", "rtx", "seq", ",", "m", "=", "cfun", "->", "machine", "->", "gp_save_rtx", ";", "if", "(", "m", "==", "NULL", ")", "{", "start_sequence", "(", ")", ";", "m", "=", "assign_stack_local", "(", "DImode", ",", "UNITS_PER_WORD", ",", "BITS_PER_WORD", ")", ";", "m", "=", "validize_mem", "(", "m", ")", ";", "emit_move_insn", "(", "m", ",", "pic_offset_table_rtx", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_after", "(", "seq", ",", "entry_of_function", "(", ")", ")", ";", "cfun", "->", "machine", "->", "gp_save_rtx", "=", "m", ";", "}", "return", "m", ";", "}", "</s>" ]

[ "Return", "or", "create", "a", "pseudo", "containing", "the", "gp", "value", "for", "the", "current", "function", ".", "Needed", "only", "if", "TARGET_LD_BUGGY_LDGP", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "addrSinkUsingGEPs", "(", ")", "const", "override", "{", "return", "useAA", "(", ")", "||", "isTargetILP32", "(", ")", ";", "}", "</s>" ]

[ "Sink", "addresses", "into", "blocks", "using", "GEP", "instructions", "rather", "than", "pointer", "casts", "and", "arithmetic", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AZPRPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createAZPRDelaySlotFillerPass", "(", "getAZPRTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AZPR", "AZPR", "AZPR", "AZPR" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_predicated_cond", "(", "rtx", "target", ",", "rtx_code", "code", ",", "rtx", "pred", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "unspec", "=", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "pred", ")", ",", "gen_rtvec", "(", "3", ",", "pred", ",", "op0", ",", "op1", ")", ",", "aarch64_unspec_cond_code", "(", "code", ")", ")", ";", "emit_set_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Emit", ":", "(", "set", "TARGET", "(", "unspec", "[", "PRED", "OP0", "OP1", "]", "UNSPEC_COND_", "<", "X", ">", ")", ")", "where", "<", "X", ">", "is", "the", "operation", "associated", "with", "comparison", "CODE", ".", "This", "form", "of", "instruction", "is", "used", "when", "(", "and", "(", "CODE", "OP0", "OP1", ")", "PRED", ")", "would", "have", "different", "semantics", ",", "such", "as", "when", "PRED", "might", "not", "be", "all-true", "and", "when", "comparing", "inactive", "lanes", "could", "have", "side", "effects", "." ]

[ "aarch64", "3" ]

[]

[ "<s>", "MCObjectWriter", "*", "SICAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createSICELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ",", "IsLittle", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "SIC", "SIC", "SIC" ]

[]

[ "<s>", "static", "const", "char", "*", "pru_output_ltle_signed_cbranch", "(", "rtx", "*", "operands", ",", "bool", "is_near", ")", "{", "static", "char", "buf", "[", "1024", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "op1", ";", "rtx", "op2", ";", "const", "char", "*", "cmp_opstr", ";", "int", "bufi", "=", "0", ";", "op1", "=", "operands", "[", "1", "]", ";", "op2", "=", "operands", "[", "2", "]", ";", "gcc_assert", "(", "GET_CODE", "(", "op1", ")", "==", "REG", "&&", "GET_CODE", "(", "op2", ")", "==", "REG", ")", ";", "if", "(", "code", "==", "LT", ")", "cmp_opstr", "=", "\"qblt\"", ";", "else", "if", "(", "code", "==", "LE", ")", "cmp_opstr", "=", "\"qble\"", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "is_near", ")", "bufi", "=", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbc\\t.+12, %%1, %d\\n\\t\"", "\"qbbc\\t%%l3, %%2, %d\\n\\t\"", "\"%s\\t%%l3, %%2, %%1\\n\\t\"", "\"qbbs\\t.+8, %%2, %d\\n\\t\"", "\"%s\\t%%l3, %%2, %%1\"", ",", "sign_bit_position", "(", "op1", ")", ",", "sign_bit_position", "(", "op2", ")", ",", "cmp_opstr", ",", "sign_bit_position", "(", "op2", ")", ",", "cmp_opstr", ")", ";", "else", "bufi", "=", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "\"qbbc\\t.+12, %%1, %d\\n\\t\"", "\"qbbc\\t.+20, %%2, %d\\n\\t\"", "\"%s\\t.+16, %%2, %%1\\n\\t\"", "\"qbbs\\t.+16, %%2, %d\\n\\t\"", "\"%s\\t.+8, %%2, %%1\\n\\t\"", "\"jmp\\t.+8\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"", ",", "sign_bit_position", "(", "op1", ")", ",", "sign_bit_position", "(", "op2", ")", ",", "cmp_opstr", ",", "sign_bit_position", "(", "op2", ")", ",", "cmp_opstr", ")", ";", "gcc_assert", "(", "bufi", ">", "0", ")", ";", "gcc_assert", "(", "(", "unsigned", "int", ")", "bufi", "<", "sizeof", "(", "buf", ")", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Output", "asm", "code", "for", "a", "signed-compare", "LT/LE", "conditional", "branch", "." ]

[ "pru", "1024", "0", "0", "1", "2", "\"qblt\"", "\"qble\"", "\"qbbc\\t.+12, %%1, %d\\n\\t\"", "\"qbbc\\t%%l3, %%2, %d\\n\\t\"", "\"%s\\t%%l3, %%2, %%1\\n\\t\"", "\"qbbs\\t.+8, %%2, %d\\n\\t\"", "\"%s\\t%%l3, %%2, %%1\"", "\"qbbc\\t.+12, %%1, %d\\n\\t\"", "\"qbbc\\t.+20, %%2, %d\\n\\t\"", "\"%s\\t.+16, %%2, %%1\\n\\t\"", "\"qbbs\\t.+16, %%2, %d\\n\\t\"", "\"%s\\t.+8, %%2, %%1\\n\\t\"", "\"jmp\\t.+8\\n\\t\"", "\"jmp\\t%%%%label(%%l3)\"", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "ShouldPrint", "=", "false", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "hasSSE2", "(", ")", ")", "{", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "hasAVX", "(", ")", "&&", "UseVZeroUpper", ")", "{", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getX86Subtarget", "(", ")", ".", "padShortFunctions", "(", ")", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "if", "(", "getX86Subtarget", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "addPass", "(", "createX86NaClRewritePass", "(", ")", ")", ";", "ShouldPrint", "=", "true", ";", "}", "return", "ShouldPrint", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ";", "bool", "IsAcquire", "=", "Ord", "==", "Acquire", "||", "Ord", "==", "AcquireRelease", "||", "Ord", "==", "SequentiallyConsistent", ";", "if", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxp", ":", "Intrinsic", "::", "aarch64_ldxp", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ",", "\"lohi\"", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Intrinsic", "::", "ID", "Int", "=", "IsAcquire", "?", "Intrinsic", "::", "aarch64_ldaxr", ":", "Intrinsic", "::", "aarch64_ldxr", ";", "Function", "*", "Ldxr", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateTruncOrBitCast", "(", "Builder", ".", "CreateCall", "(", "Ldxr", ",", "Addr", ")", ",", "cast", "<", "PointerType", ">", "(", "Addr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "}", "</s>" ]

[ "Perform", "a", "load-linked", "operation", "on", "Addr", ",", "returning", "a", "``", "Value", "*", "''", "with", "the", "corresponding", "pointee", "type", "." ]

[ "AArch64", "AArch64", "128", "Intrinsic::ID", "Intrinsic::aarch64_ldaxp", "Intrinsic::aarch64_ldxp", "Intrinsic::getDeclaration", "\"lohi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "Intrinsic::getDeclaration" ]

[]

[ "<s>", "MVT", "X86TargetLowering", "::", "hasFastEqualityCompare", "(", "unsigned", "NumBits", ")", "const", "{", "MVT", "VT", "=", "MVT", "::", "getIntegerVT", "(", "NumBits", ")", ";", "if", "(", "isTypeLegal", "(", "VT", ")", ")", "return", "VT", ";", "if", "(", "NumBits", "==", "128", "&&", "isTypeLegal", "(", "MVT", "::", "v16i8", ")", ")", "return", "MVT", "::", "v16i8", ";", "if", "(", "NumBits", "==", "256", "&&", "isTypeLegal", "(", "MVT", "::", "v32i8", ")", ")", "return", "MVT", "::", "v32i8", ";", "return", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ";", "}", "</s>" ]

[ "Vector-sized", "comparisons", "are", "fast", "using", "PCMPEQ", "+", "PMOVMSK", "or", "PTEST", "." ]

[ "X86", "X86", "MVT::getIntegerVT", "128", "MVT::v16i8", "MVT::v16i8", "256", "MVT::v32i8", "MVT::v32i8", "MVT::INVALID_SIMPLE_VALUE_TYPE" ]

[]

[ "<s>", "int", "main", "(", ")", "{", "int", "i", ",", "j", ";", "double", "q", ",", "r", ",", "err", ",", "max_err", "=", "0", ",", "max_s_err", "=", "0", ";", "puts", "(", "\"/* This table has been generated by divtab-sh4.cc. */\"", ")", ";", "puts", "(", "\"\\t.balign 4\"", ")", ";", "puts", "(", "\"LOCAL(div_table_clz):\"", ")", ";", "printf", "(", "\"\\t.byte\\t%d\\n\"", ",", "0", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<=", "128", ";", "i", "++", ")", "{", "int", "n", "=", "0", ";", "if", "(", "i", "==", "128", ")", "puts", "(", "\"\\ /* Lookup table translating positive divisor to index into table of\\n\\ normalized inverse. N.B. the '0' entry is also the last entry of the\\n\\ previous table, and causes an unaligned access for division by zero. */\\n\\ LOCAL(div_table_ix):\"", ")", ";", "for", "(", "j", "=", "i", ";", "j", "<=", "128", ";", "j", "+=", "j", ")", "n", "++", ";", "printf", "(", "\"\\t.byte\\t%d\\n\"", ",", "n", "-", "7", ")", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<=", "128", ";", "i", "++", ")", "{", "j", "=", "i", "<", "0", "?", "-", "i", ":", "i", ";", "while", "(", "j", "<", "128", ")", "j", "+=", "j", ";", "printf", "(", "\"\\t.byte\\t%d\\n\"", ",", "j", "*", "2", "-", "96", "*", "4", ")", ";", "}", "puts", "(", "\"\\ /* 1/64 .. 1/127, normalized. There is an implicit leading 1 in bit 32. */\\n\\ .balign 4\\n\\ LOCAL(zero_l):\"", ")", ";", "for", "(", "i", "=", "64", ";", "i", "<", "128", ";", "i", "++", ")", "{", "if", "(", "i", "==", "96", ")", "puts", "(", "\"LOCAL(div_table):\"", ")", ";", "q", "=", "4.", "*", "(", "1", "<<", "30", ")", "*", "128", "/", "i", ";", "r", "=", "ceil", "(", "q", ")", ";", "printf", "(", "\"\\t.long\\t0x%X\\n\"", ",", "(", "unsigned", ")", "r", ")", ";", "err", "=", "r", "-", "q", ";", "if", "(", "err", ">", "max_err", ")", "max_err", "=", "err", ";", "err", "=", "err", "*", "i", "/", "128", ";", "if", "(", "err", ">", "max_s_err", ")", "max_s_err", "=", "err", ";", "}", "printf", "(", "\"\\t/* maximum error: %f scaled: %f*/\\n\"", ",", "max_err", ",", "max_s_err", ")", ";", "exit", "(", "0", ")", ";", "}", "</s>" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "sh", "0", "0", "\"/* This table has been generated by divtab-sh4.cc. */\"", "\"\\t.balign 4\"", "\"LOCAL(div_table_clz):\"", "\"\\t.byte\\t%d\\n\"", "0", "1", "128", "0", "128", "\"\\ /* Lookup table translating positive divisor to index into table of\\n\\ normalized inverse. N.B. the '0' entry is also the last entry of the\\n\\ previous table, and causes an unaligned access for division by zero. */\\n\\ LOCAL(div_table_ix):\"", "128", "\"\\t.byte\\t%d\\n\"", "7", "1", "128", "0", "128", "\"\\t.byte\\t%d\\n\"", "2", "96", "4", "\"\\ /* 1/64 .. 1/127, normalized. There is an implicit leading 1 in bit 32. */\\n\\ .balign 4\\n\\ LOCAL(zero_l):\"", "64", "128", "96", "\"LOCAL(div_table):\"", "4.", "1", "30", "128", "\"\\t.long\\t0x%X\\n\"", "128", "\"\\t/* maximum error: %f scaled: %f*/\\n\"", "0" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsConstReadLimitations", "(", "const", "std", "::", "vector", "<", "unsigned", ">", "&", "Consts", ")", "const", "{", "assert", "(", "Consts", ".", "size", "(", ")", "<=", "12", "&&", "\"Too many operands in instructions group\"", ")", ";", "unsigned", "Pair1", "=", "0", ",", "Pair2", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "Consts", ".", "size", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "unsigned", "ReadConstHalf", "=", "Consts", "[", "i", "]", "&", "2", ";", "unsigned", "ReadConstIndex", "=", "Consts", "[", "i", "]", "&", "(", "~", "3", ")", ";", "unsigned", "ReadHalfConst", "=", "ReadConstIndex", "|", "ReadConstHalf", ";", "if", "(", "!", "Pair1", ")", "{", "Pair1", "=", "ReadHalfConst", ";", "continue", ";", "}", "if", "(", "Pair1", "==", "ReadHalfConst", ")", "continue", ";", "if", "(", "!", "Pair2", ")", "{", "Pair2", "=", "ReadHalfConst", ";", "continue", ";", "}", "if", "(", "Pair2", "!=", "ReadHalfConst", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]

[ "R600", "12", "\"Too many operands in instructions group\"", "0", "0", "0", "2", "3" ]

[]

[ "<s>", "static", "rtx", "ft32_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "*", "cum", "<", "8", ")", "return", "gen_rtx_REG", "(", "mode", ",", "*", "cum", ")", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "the", "next", "register", "to", "be", "used", "to", "hold", "a", "function", "argument", "or", "NULL_RTX", "if", "there", "'s", "no", "more", "space", "." ]

[ "ft32", "8" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "createPHISourceCopy", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "InsPt", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "Src", ",", "Register", "SrcSubReg", ",", "Register", "Dst", ")", "const", "{", "if", "(", "InsPt", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_IF", "||", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_ELSE", "||", "InsPt", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_IF_BREAK", ")", "&&", "InsPt", "->", "definesRegister", "(", "Src", ")", ")", "{", "InsPt", "++", ";", "return", "BuildMI", "(", "MBB", ",", "InsPt", ",", "InsPt", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ST", ".", "isWave32", "(", ")", "?", "AMDGPU", "::", "S_MOV_B32_term", ":", "AMDGPU", "::", "S_MOV_B64_term", ")", ",", "Dst", ")", ".", "addReg", "(", "Src", ",", "0", ",", "SrcSubReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ",", "RegState", "::", "Implicit", ")", ";", "}", "return", "TargetInstrInfo", "::", "createPHISourceCopy", "(", "MBB", ",", "InsPt", ",", "DL", ",", "Src", ",", "SrcSubReg", ",", "Dst", ")", ";", "}", "</s>" ]

[ "During", "PHI", "eleimination", "lets", "target", "to", "make", "necessary", "checks", "and", "insert", "the", "copy", "to", "the", "PHI", "destination", "register", "in", "a", "target", "specific", "manner", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_IF_BREAK", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_MOV_B64_term", "0", "AMDGPU::EXEC" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TVM Assembly Printer\"", ";", "}", "</s>" ]

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

[ "TVM", "\"TVM Assembly Printer\"" ]

[]

[ "<s>", "void", "mmix_trampoline_template", "(", "FILE", "*", "stream", ")", "{", "fprintf", "(", "stream", ",", "\"\\tGETA $255,1F\\n\\t\"", ")", ";", "fprintf", "(", "stream", ",", "\"LDOU %s,$255,0\\n\\t\"", ",", "reg_names", "[", "MMIX_STATIC_CHAIN_REGNUM", "]", ")", ";", "fprintf", "(", "stream", ",", "\"LDOU $255,$255,8\\n\\t\"", ")", ";", "fprintf", "(", "stream", ",", "\"GO $255,$255,0\\n\"", ")", ";", "fprintf", "(", "stream", ",", "\"1H\\tOCTA 0\\n\\t\"", ")", ";", "fprintf", "(", "stream", ",", "\"OCTA 0\\n\"", ")", ";", "}", "</s>" ]

[ "TRAMPOLINE_TEMPLATE", "." ]

[ "mmix", "\"\\tGETA $255,1F\\n\\t\"", "\"LDOU %s,$255,0\\n\\t\"", "\"LDOU $255,$255,8\\n\\t\"", "\"GO $255,$255,0\\n\"", "\"1H\\tOCTA 0\\n\\t\"", "\"OCTA 0\\n\"" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "int", "cr16_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "to", ")", "{", "return", "(", "to", "!=", "GENERAL_REGS", "?", "8", ":", "2", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_REGISTER_MOVE_COST", "'", "." ]

[ "cr16", "8", "2" ]

[]

[ "<s>", "const", "uint32_t", "*", "rvexRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_O32_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "rvex", "rvex" ]

[]

[ "<s>", "void", "getFunctionConstantRange", "(", "unsigned", "&", "Start", ",", "unsigned", "&", "End", ")", "const", "{", "Start", "=", "FirstFuncConstantID", ";", "End", "=", "FirstInstID", ";", "}", "</s>" ]

[ "getFunctionConstantRange", "-", "Return", "the", "range", "of", "values", "that", "corresponds", "to", "function-local", "constants", "." ]

[ "DirectX" ]

[]

[ "<s>", "static", "int", "min_insn_size", "(", "rtx_insn", "*", "insn", ")", "{", "int", "l", "=", "0", ",", "len", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "!", "active_insn_p", "(", "insn", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "if", "(", "CALL_P", "(", "insn", ")", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", "&&", "!", "SIBLING_CALL_P", "(", "insn", ")", ")", "return", "5", ";", "len", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "len", "<=", "1", ")", "return", "1", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "switch", "(", "type", ")", "{", "case", "TYPE_MULTI", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", "return", "0", ";", "break", ";", "case", "TYPE_OTHER", ":", "case", "TYPE_FCMP", ":", "break", ";", "default", ":", "return", "len", ";", "}", "l", "=", "get_attr_length_address", "(", "insn", ")", ";", "if", "(", "l", "<", "4", "&&", "symbolic_reference_mentioned_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "l", "=", "4", ";", "}", "if", "(", "l", ")", "return", "1", "+", "l", ";", "else", "return", "2", ";", "}", "</s>" ]

[ "We", "do", "n't", "have", "exact", "information", "about", "the", "insn", "sizes", ",", "but", "we", "may", "assume", "quite", "safely", "that", "we", "are", "informed", "about", "all", "1", "byte", "insns", "and", "memory", "address", "sizes", ".", "This", "is", "enough", "to", "eliminate", "unnecessary", "padding", "in", "99", "%", "of", "cases", "." ]

[ "i386", "0", "0", "1", "0", "5", "1", "1", "0", "0", "4", "4", "1", "2" ]

[]

[ "<s>", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "BranchProbability", "Probability", ")", "const", "override", "{", "return", "NumCycles", "==", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "ARM", "1" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "!", "notEmpty", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "AMDGPU" ]

[]