Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "PTXInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MII", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "llvm_unreachable", "(", "\"loadRegFromStackSlot should not be called for PTX\"", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "\"loadRegFromStackSlot should not be called for PTX\"" ]

[]

[ "<s>", "bool", "isScalarFPTypeInSSEReg", "(", "MVT", "VT", ")", "const", "{", "return", "(", "VT", "==", "MVT", "::", "f64", "&&", "X86ScalarSSEf64", ")", "||", "(", "VT", "==", "MVT", "::", "f32", "&&", "X86ScalarSSEf32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "scalar", "FP", "type", "is", "computed", "in", "an", "SSE", "register", ",", "not", "on", "the", "X87", "floating", "point", "stack", "." ]

[ "X86", "MVT::f64", "X86", "MVT::f32", "X86" ]

[]

[ "<s>", "int", "gen_v9_scc", "(", "enum", "rtx_code", "compare_code", ",", "register", "rtx", "*", "operands", ")", "{", "rtx", "temp", ",", "op0", ",", "op1", ";", "if", "(", "!", "TARGET_ARCH64", "&&", "(", "GET_MODE", "(", "sparc_compare_op0", ")", "==", "DImode", "||", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "DImode", ")", ")", "return", "0", ";", "op0", "=", "sparc_compare_op0", ";", "op1", "=", "sparc_compare_op1", ";", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_INT", "&&", "op1", "==", "const0_rtx", "&&", "v9_regcmp_p", "(", "compare_code", ")", ")", "{", "if", "(", "compare_code", "==", "NE", "&&", "GET_MODE", "(", "operands", "[", "0", "]", ")", "==", "DImode", "&&", "rtx_equal_p", "(", "op0", ",", "operands", "[", "0", "]", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "op0", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "operands", "[", "0", "]", ")", ")", ")", ";", "return", "1", ";", "}", "if", "(", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "op0", ")", ")", "{", "op0", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "sparc_compare_op0", ")", ")", ";", "emit_move_insn", "(", "op0", ",", "sparc_compare_op0", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "const0_rtx", ")", ")", ";", "if", "(", "GET_MODE", "(", "op0", ")", "!=", "DImode", ")", "{", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "temp", ",", "op0", ",", "0", ")", ";", "}", "else", "temp", "=", "op0", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "temp", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "operands", "[", "0", "]", ")", ")", ")", ";", "return", "1", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "gen_compare_reg", "(", "compare_code", ",", "op0", ",", "op1", ")", ";", "switch", "(", "GET_MODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "CCmode", ":", "case", "CCXmode", ":", "case", "CCFPEmode", ":", "case", "CCFPmode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "GET_MODE", "(", "operands", "[", "1", "]", ")", ",", "operands", "[", "1", "]", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "operands", "[", "0", "]", ")", ")", ")", ";", "return", "1", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "used", "for", "v9", "only", ".", "CODE", "is", "the", "code", "for", "an", "Scc", "'s", "comparison", ".", "OPERANDS", "[", "0", "]", "is", "the", "target", "of", "the", "Scc", "insn", ".", "OPERANDS", "[", "1", "]", "is", "the", "value", "we", "compare", "against", "const0_rtx", "(", "which", "has", "n't", "been", "generated", "yet", ")", ".", "This", "function", "is", "needed", "to", "turn", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "into", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", ":", "DI", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "IE", ":", "The", "instruction", "recognizer", "needs", "to", "see", "the", "mode", "of", "the", "comparison", "to", "find", "the", "right", "instruction", ".", "We", "could", "use", "``", "gt", ":", "DI", "''", "right", "in", "the", "define_expand", ",", "but", "leaving", "it", "out", "allows", "us", "to", "handle", "DI", ",", "SI", ",", "etc", ".", "We", "refer", "to", "the", "global", "sparc", "compare", "operands", "sparc_compare_op0", "and", "sparc_compare_op1", "." ]

[ "sparc", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1", "1", "0", "0", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "XCoreTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "XCore", "::", "GRRegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "1", "0", "0U", "XCore::GRRegsRegClass" ]

[]

[ "<s>", "static", "bool", "aarch64_handle_attr_isa_flags", "(", "char", "*", "str", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", ";", "uint64_t", "isa_flags", "=", "aarch64_isa_flags", ";", "if", "(", "strncmp", "(", "\"+nothing\"", ",", "str", ",", "8", ")", "==", "0", ")", "{", "isa_flags", "=", "0", ";", "str", "+=", "8", ";", "}", "std", "::", "string", "invalid_extension", ";", "parse_res", "=", "aarch64_parse_extension", "(", "str", ",", "&", "isa_flags", ",", "&", "invalid_extension", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "aarch64_isa_flags", "=", "isa_flags", ";", "return", "true", ";", "}", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing value in %<target()%> pragma or attribute\"", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier %s of value (\\\"%s\\\") in \"", "\"%<target()%> pragma or attribute\"", ",", "invalid_extension", ".", "c_str", "(", ")", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Parse", "an", "architecture", "extensions", "target", "attribute", "string", "specified", "in", "STR", ".", "For", "example", "``", "+fp+nosimd", "''", ".", "Show", "any", "errors", "if", "needed", ".", "Return", "TRUE", "if", "successful", ".", "Update", "aarch64_isa_flags", "to", "reflect", "the", "ISA", "features", "modified", ".", "PRAGMA_OR_ATTR", "is", "used", "in", "potential", "error", "messages", "." ]

[ "aarch64", "\"+nothing\"", "8", "0", "0", "8", "\"missing value in %<target()%> pragma or attribute\"", "\"invalid feature modifier %s of value (\\\"%s\\\") in \"", "\"%<target()%> pragma or attribute\"" ]

[]

[ "<s>", "static", "int", "c_prefix", "(", "const", "char", "*", "str", ")", "{", "static", "const", "char", "*", "const", "prefixes", "[", "]", "=", "{", "\"attiny\"", ",", "\"atmega\"", ",", "\"atxmega\"", ",", "\"ata\"", ",", "\"at90\"", "}", ";", "int", "i", ",", "n", "=", "(", "int", ")", "(", "sizeof", "(", "prefixes", ")", "/", "sizeof", "(", "*", "prefixes", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "str_prefix_p", "(", "str", ",", "prefixes", "[", "i", "]", ")", ")", "return", "i", ";", "return", "n", ";", "}", "</s>" ]

[ "Used", "by", "string", "comparator", "to", "group", "MCUs", "by", "their", "name", "prefix", "like", "``", "attiny", "''", "or", "``", "atmega", "''", "." ]

[ "avr", "\"attiny\"", "\"atmega\"", "\"atxmega\"", "\"ata\"", "\"at90\"", "0" ]

[]

[ "<s>", "void", "cris_conditional_register_usage", "(", ")", "{", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "}", "</s>" ]

[ "The", "CONDITIONAL_REGISTER_USAGE", "worker", "." ]

[ "cris", "1" ]

[]

[ "<s>", "static", "Mfix", "*", "create_csky_fix_barrier", "(", "Mfix", "*", "fix", ",", "Mfix", "*", "fix_next", ",", "HOST_WIDE_INT", "max_address", ")", "{", "rtx_barrier", "*", "barrier", ";", "rtx_insn", "*", "from", "=", "(", "fix", "?", "fix", "->", "insn", ":", "get_insns", "(", ")", ")", ";", "rtx_insn", "*", "selected", "=", "NULL", ";", "int", "selected_cost", ";", "HOST_WIDE_INT", "selected_address", "=", "0", ";", "Mfix", "*", "new_fix", ";", "HOST_WIDE_INT", "count", "=", "(", "fix", "?", "fix", "->", "address", ":", "0", ")", ";", "HOST_WIDE_INT", "max_count", "=", "max_address", ";", "rtx_code_label", "*", "label", "=", "gen_label_rtx", "(", ")", ";", "selected_cost", "=", "get_csky_barrier_cost", "(", "from", ")", ";", "while", "(", "from", "&&", "count", "<", "max_count", ")", "{", "int", "new_cost", ";", "rtx_jump_table_data", "*", "table", ";", "count", "+=", "get_attr_length", "(", "from", ")", ";", "if", "(", "tablejump_p", "(", "from", ",", "NULL", ",", "&", "table", ")", ")", "{", "count", "+=", "get_csky_jump_table_size", "(", "table", ")", ";", "new_cost", "=", "get_csky_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "table", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "table", ")", ";", "continue", ";", "}", "new_cost", "=", "get_csky_barrier_cost", "(", "from", ")", ";", "if", "(", "count", "<", "max_count", "&&", "(", "!", "selected", "||", "new_cost", "<=", "selected_cost", ")", ")", "{", "selected", "=", "from", ";", "selected_cost", "=", "new_cost", ";", "selected_address", "=", "count", ";", "}", "from", "=", "NEXT_INSN", "(", "from", ")", ";", "}", "gcc_assert", "(", "selected", ")", ";", "from", "=", "emit_jump_insn_after", "(", "gen_jump", "(", "label", ")", ",", "selected", ")", ";", "JUMP_LABEL", "(", "from", ")", "=", "label", ";", "barrier", "=", "emit_barrier_after", "(", "from", ")", ";", "emit_label_after", "(", "label", ",", "barrier", ")", ";", "new_fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "new_fix", ")", ")", ";", "new_fix", "->", "insn", "=", "barrier", ";", "new_fix", "->", "address", "=", "selected_address", ";", "if", "(", "fix", ")", "{", "new_fix", "->", "next", "=", "fix", "->", "next", ";", "fix", "->", "next", "=", "new_fix", ";", "}", "else", "new_fix", "->", "next", "=", "fix_next", ";", "return", "new_fix", ";", "}", "</s>" ]

[ "Find", "the", "best", "place", "in", "the", "insn", "stream", "in", "the", "range", "(", "FIX-", ">", "address", ",", "MAX_ADDRESS", ")", "to", "forcibly", "insert", "a", "minipool", "barrier", ".", "Create", "the", "barrier", "by", "inserting", "a", "jump", "and", "add", "a", "new", "fix", "entry", "for", "it", "." ]

[ "csky", "0", "0" ]

[]

[ "<s>", "bool", "WebAssemblyFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "auto", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "hasStackMap", "(", ")", "||", "MFI", "->", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "static", "const", "uint32_t", "Nopcode", "=", "0x7f000000", ",", "ParseIn", "=", "0x00004000", ",", "ParseEnd", "=", "0x0000c000", ";", "while", "(", "Count", "%", "HEXAGON_INSTR_SIZE", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Alignment not a multiple of the instruction size:\"", "<<", "Count", "%", "HEXAGON_INSTR_SIZE", "<<", "\"/\"", "<<", "HEXAGON_INSTR_SIZE", "<<", "\"\\n\"", ")", ";", "--", "Count", ";", "OS", "<<", "'\\0'", ";", "}", "while", "(", "Count", ")", "{", "Count", "-=", "HEXAGON_INSTR_SIZE", ";", "uint32_t", "ParseBits", "=", "(", "Count", "%", "(", "HEXAGON_PACKET_SIZE", "*", "HEXAGON_INSTR_SIZE", ")", ")", "?", "ParseIn", ":", "ParseEnd", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Nopcode", "|", "ParseBits", ",", "Endian", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Hexagon", "0x7f000000", "0x00004000", "0x0000c000", "\"Alignment not a multiple of the instruction size:\"", "\"/\"", "\"\\n\"", "support::endian" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_ext", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "offset", ";", "unsigned", "int", "location", "=", "d", "->", "perm", "[", "0", "]", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "int", "required", "=", "location", "+", "i", ";", "if", "(", "d", "->", "one_vector_p", ")", "{", "required", "&=", "(", "nelt", "-", "1", ")", ";", "}", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "required", ")", "return", "false", ";", "}", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_extv16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_extv8qi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_extv4hi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_extv8hi", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_extv2si", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_extv4si", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_aarch64_extv4hf", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_aarch64_extv8hf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_extv2sf", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_extv4sf", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_extv2di", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_extv2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "(", "location", "!=", "0", ")", ")", "{", "std", "::", "swap", "(", "d", "->", "op0", ",", "d", "->", "op1", ")", ";", "location", "=", "nelt", "-", "location", ";", "}", "offset", "=", "GEN_INT", "(", "location", ")", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "offset", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "EXT", "insn", "." ]

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

[]

[ "<s>", "unsigned", "CSKYInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "CSKY", "::", "ST16B", ":", "case", "CSKY", "::", "ST16H", ":", "case", "CSKY", "::", "ST16W", ":", "case", "CSKY", "::", "ST32B", ":", "case", "CSKY", "::", "ST32H", ":", "case", "CSKY", "::", "ST32W", ":", "case", "CSKY", "::", "FST_S", ":", "case", "CSKY", "::", "FST_D", ":", "case", "CSKY", "::", "f2FST_S", ":", "case", "CSKY", "::", "f2FST_D", ":", "case", "CSKY", "::", "SPILL_CARRY", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "CSKY", "CSKY", "0", "CSKY::ST16B", "CSKY::ST16H", "CSKY::ST16W", "CSKY::ST32B", "CSKY::ST32H", "CSKY::ST32W", "CSKY::FST_S", "CSKY::FST_D", "CSKY::f2FST_S", "CSKY::f2FST_D", "CSKY::SPILL_CARRY", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "iq2000_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_mcpu_", ":", "if", "(", "strcmp", "(", "arg", ",", "\"iq10\"", ")", "==", "0", ")", "iq2000_tune", "=", "PROCESSOR_IQ10", ";", "else", "if", "(", "strcmp", "(", "arg", ",", "\"iq2000\"", ")", "==", "0", ")", "iq2000_tune", "=", "PROCESSOR_IQ2000", ";", "else", "return", "false", ";", "return", "true", ";", "case", "OPT_march_", ":", "return", "(", "strcmp", "(", "arg", ",", "\"default\"", ")", "==", "0", "||", "strcmp", "(", "arg", ",", "\"DEFAULT\"", ")", "==", "0", "||", "strcmp", "(", "arg", ",", "\"iq2000\"", ")", "==", "0", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_HANDLE_OPTION", "." ]

[ "iq2000", "\"iq10\"", "0", "\"iq2000\"", "0", "\"default\"", "0", "\"DEFAULT\"", "0", "\"iq2000\"", "0" ]

[]

[ "<s>", "static", "rtx", "eco32_function_arg", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "NULL_RTX", ";", "if", "(", "!", "named", "||", "(", "*", "cum", ">=", "ECO32_NUM_ARG_REGS", ")", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_REG", "(", "mode", ",", "*", "cum", "+", "ECO32_FIRST_ARG_REGNO", ")", ";", "}", "</s>" ]

[ "On", "the", "ECO32", "the", "first", "ECO32_MAX_PARM_REGS", "args", "are", "normally", "in", "registers", "and", "the", "rest", "are", "pushed", "." ]

[ "eco32" ]

[]

[ "<s>", "bool", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "{", "return", "VT", "!=", "MVT", "::", "f128", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "Mandarin", "MVT::f128" ]

[]

[ "<s>", "void", "OutgoingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "Register", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ExtReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "Mips" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "PhysReg", "==", "AArch64", "::", "WZR", "||", "PhysReg", "==", "AArch64", "::", "XZR", ";", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "AArch64", "AArch64", "AArch64::WZR", "AArch64::XZR" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "int", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FrameOffset", ";", "}", "else", "{", "FrameReg", "=", "SP", "::", "O6", ";", "return", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "Sparc", "SP::O6" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Assembly Printer\"" ]

[]

[ "<s>", "Register", "SystemZRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SystemZFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "const", "SystemZSubtarget", "*", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "SystemZCallingConventionRegisters", "*", "Regs", "=", "Subtarget", "->", "getSpecialRegisters", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Regs", "->", "getFramePointerRegister", "(", ")", ":", "Regs", "->", "getStackPointerRegister", "(", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "analyzeOutputArgs", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "CCInfo", ",", "Outs", ",", "true", ",", "nullptr", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "assert", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "Full", "&&", "\"Unexpected CCValAssign::LocInfo\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "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", "(", "RISCVISD", "::", "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", "." ]

[ "RISCV", "RISCV", "ISD::OutputArg", "16", "4", "1", "0", "\"Can only return in registers!\"", "\"Unexpected CCValAssign::LocInfo\"", "1", "0", "RISCVISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "rtx", "rs6000_adjust_atomic_subword", "(", "rtx", "orig_mem", ",", "rtx", "*", "pshift", ",", "rtx", "*", "pmask", ")", "{", "rtx", "addr", ",", "align", ",", "shift", ",", "mask", ",", "mem", ";", "HOST_WIDE_INT", "shift_mask", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "shift_mask", "=", "(", "mode", "==", "QImode", "?", "0x18", ":", "0x10", ")", ";", "addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "addr", "=", "force_reg", "(", "GET_MODE", "(", "addr", ")", ",", "addr", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "4", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "MEM_VOLATILE_P", "(", "orig_mem", ")", ";", "if", "(", "MEM_ALIAS_SET", "(", "orig_mem", ")", "==", "ALIAS_SET_MEMORY_BARRIER", ")", "set_mem_alias_set", "(", "mem", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "shift", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "addr", "=", "gen_lowpart", "(", "SImode", ",", "addr", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "tmp", ",", "addr", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "shift", ",", "tmp", ",", "GEN_INT", "(", "shift_mask", ")", ")", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "shift", ",", "GEN_INT", "(", "shift_mask", ")", ",", "shift", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "*", "pshift", "=", "shift", ";", "mask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "*", "pmask", "=", "mask", ";", "return", "mem", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operations", ",", "we", "must", "adjust", "things", "to", "operate", "on", "SImode", ".", "Given", "the", "original", "MEM", ",", "return", "a", "new", "aligned", "memory", ".", "Also", "build", "and", "return", "the", "quantities", "by", "which", "to", "shift", "and", "mask", "." ]

[ "rs6000", "0x18", "0x10", "0", "4", "1", "3", "1", "1" ]

[]

[ "<s>", "static", "unsigned", "int", "arc_autovectorize_vector_modes", "(", "vector_modes", "*", "modes", ",", "bool", ")", "{", "if", "(", "TARGET_PLUS_QMACW", ")", "{", "modes", "->", "quick_push", "(", "V4HImode", ")", ";", "modes", "->", "quick_push", "(", "V2HImode", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES", "." ]

[ "arc", "0" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "int", "compare_eq_p", "(", "rtx", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "EQ", "||", "cond", "==", "NE", ")", ";", "}", "</s>" ]

[ "Returns", "nonzero", "if", "INSN", "is", "a", "compare", "insn", "with", "the", "EQ", "or", "NE", "condition", "." ]

[ "avr" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", "&&", "!", "isSupportedReturnType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "ArgInfo", "ArgRetInfo", "(", "VRegs", ",", "Val", "->", "getType", "(", ")", ")", ";", "setArgFlags", "(", "ArgRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "DL", ",", "ArgRetInfo", ",", "0", ",", "RetInfos", ",", "OrigArgIndices", ")", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "RetInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "OutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "RetInfos", ")", ")", "{", "return", "false", ";", "}", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "8", "8", "0", "ISD::OutputArg", "8", "16", "Mips" ]

[]

[ "<s>", "void", "function_builder", "::", "register_function_group", "(", "const", "function_group_info", "&", "group", ")", "{", "(", "*", "group", ".", "shape", ")", "->", "build", "(", "*", "this", ",", "group", ")", ";", "}", "</s>" ]

[ "Register", "all", "the", "functions", "in", "GROUP", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getGPRsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "</s>" ]

[ "getGPRsForTailCall", "-", "Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "." ]

[ "X86", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "bool", "NVPTXAllocaHoisting", "::", "runOnFunction", "(", "Function", "&", "function", ")", "{", "bool", "functionModified", "=", "false", ";", "Function", "::", "iterator", "I", "=", "function", ".", "begin", "(", ")", ";", "TerminatorInst", "*", "firstTerminatorInst", "=", "(", "I", "++", ")", "->", "getTerminator", "(", ")", ";", "for", "(", "Function", "::", "iterator", "E", "=", "function", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "BI", "=", "I", "->", "begin", "(", ")", ",", "BE", "=", "I", "->", "end", "(", ")", ";", "BI", "!=", "BE", ";", ")", "{", "AllocaInst", "*", "allocaInst", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "BI", "++", ")", ";", "if", "(", "allocaInst", "&&", "isa", "<", "ConstantInt", ">", "(", "allocaInst", "->", "getArraySize", "(", ")", ")", ")", "{", "allocaInst", "->", "moveBefore", "(", "firstTerminatorInst", ")", ";", "functionModified", "=", "true", ";", "}", "}", "}", "return", "functionModified", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "AArch64MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "VK_AUTH", "||", "E", "->", "getKind", "(", ")", "==", "VK_AUTHADDR", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "inline", "unsigned", "long", "ia64_rse_num_regs", "(", "unsigned", "long", "*", "bspstore", ",", "unsigned", "long", "*", "bsp", ")", "{", "unsigned", "long", "slots", "=", "(", "bsp", "-", "bspstore", ")", ";", "return", "slots", "-", "(", "ia64_rse_slot_num", "(", "bspstore", ")", "+", "slots", ")", "/", "0x40", ";", "}", "</s>" ]

[ "Calculate", "the", "number", "of", "registers", "in", "the", "dirty", "partition", "starting", "at", "BSPSTORE", "with", "a", "size", "of", "DIRTY", "bytes", ".", "This", "is", "n't", "simply", "DIRTY", "divided", "by", "eight", "because", "the", "64th", "slot", "is", "used", "to", "store", "ar.rnat", "." ]

[ "ia64", "0x40" ]

[]

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

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

[ "AZPR", "AZPR" ]

[]

[ "<s>", "FastISel", "*", "ARM", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ")", "{", "const", "TargetMachine", "&", "TM", "=", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ";", "const", "ARMSubtarget", "*", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetIOS", "(", ")", "&&", "!", "Subtarget", "->", "isThumb1Only", "(", ")", "&&", "!", "DisableARMFastISel", ")", "return", "new", "ARMFastISel", "(", "funcInfo", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM::createFastISel", "ARM", "ARM", "ARM", "ARM", "0" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "const", "MipsRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "MipsRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "SP", "=", "ABI", ".", "GetStackPtr", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "ZERO", "=", "ABI", ".", "GetNullPtr", "(", ")", ";", "unsigned", "MOVE", "=", "ABI", ".", "GetGPRMoveOp", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "MOVE", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "for", "(", "int", "J", "=", "0", ";", "J", "<", "4", ";", "++", "J", ")", "{", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "ABI", ".", "GetEhDataReg", "(", "J", ")", ",", "MipsFI", "->", "getEhDataRegFI", "(", "J", ")", ",", "RC", ",", "&", "RegInfo", ")", ";", "}", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "emitInterruptEpilogueStub", "(", "MF", ",", "MBB", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "0", "0", "4", "Mips", "\"interrupt\"" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", ">=", "FirstLiteralRelocationKind", ")", "return", "true", ";", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_Data_8", ":", "if", "(", "Target", ".", "isAbsolute", "(", ")", ")", "return", "false", ";", "break", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_got_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_hi20", ":", "case", "RISCV", "::", "fixup_riscv_captab_pcrel_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_ie_captab_pcrel_hi20", ":", "case", "RISCV", "::", "fixup_riscv_tls_gd_captab_pcrel_hi20", ":", "return", "true", ";", "}", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", "||", "ForceRelocs", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "RISCV", "RISCV", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_tls_got_hi20", "RISCV::fixup_riscv_tls_gd_hi20", "RISCV::fixup_riscv_captab_pcrel_hi20", "RISCV::fixup_riscv_tls_ie_captab_pcrel_hi20", "RISCV::fixup_riscv_tls_gd_captab_pcrel_hi20", "RISCV::FeatureRelax" ]

[]

[ "<s>", "static", "rtx", "riscv_expand_builtin_insn", "(", "enum", "insn_code", "icode", ",", "unsigned", "int", "n_ops", ",", "struct", "expand_operand", "*", "ops", ",", "bool", "has_target_p", ")", "{", "if", "(", "!", "maybe_expand_insn", "(", "icode", ",", "n_ops", ",", "ops", ")", ")", "{", "error", "(", "\"invalid argument to built-in function\"", ")", ";", "return", "has_target_p", "?", "gen_reg_rtx", "(", "ops", "[", "0", "]", ".", "mode", ")", ":", "const0_rtx", ";", "}", "return", "has_target_p", "?", "ops", "[", "0", "]", ".", "value", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Expand", "instruction", "ICODE", "as", "part", "of", "a", "built-in", "function", "sequence", ".", "Use", "the", "first", "NOPS", "elements", "of", "OPS", "as", "the", "instruction", "'s", "operands", ".", "HAS_TARGET_P", "is", "true", "if", "operand", "0", "is", "a", "target", ";", "it", "is", "false", "if", "the", "instruction", "has", "no", "target", ".", "Return", "the", "target", "rtx", "if", "HAS_TARGET_P", ",", "otherwise", "return", "const0_rtx", "." ]

[ "riscv", "\"invalid argument to built-in function\"", "0", "0" ]

[]

[ "<s>", "bool", "DirectXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "raw_pwrite_stream", "&", "Out", ",", "raw_pwrite_stream", "*", "DwoOut", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ",", "MachineModuleInfoWrapperPass", "*", "MMIWP", ")", "{", "PM", ".", "add", "(", "createDXILOpLoweringLegacyPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createDXILPrepareModulePass", "(", ")", ")", ";", "PM", ".", "add", "(", "createDXILTranslateMetadataPass", "(", ")", ")", ";", "switch", "(", "FileType", ")", "{", "case", "CGFT_AssemblyFile", ":", "PM", ".", "add", "(", "createPrintModulePass", "(", "Out", ",", "\"\"", ",", "true", ")", ")", ";", "break", ";", "case", "CGFT_ObjectFile", ":", "PM", ".", "add", "(", "createDXILWriterPass", "(", "Out", ")", ")", ";", "break", ";", "case", "CGFT_Null", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "DirectX", "DXIL", "DXIL", "DXIL", "\"\"", "DXIL" ]

[]

[ "<s>", "static", "const", "char", "*", "sh_check_pch_target_flags", "(", "int", "old_flags", ")", "{", "if", "(", "(", "old_flags", "^", "target_flags", ")", "&", "(", "MASK_SH1", "|", "MASK_SH2", "|", "MASK_SH3", "|", "MASK_SH_E", "|", "MASK_HARD_SH4", "|", "MASK_FPU_SINGLE", "|", "MASK_SH4", ")", ")", "return", "_", "(", "\"created and used with different architectures / ABIs\"", ")", ";", "if", "(", "(", "old_flags", "^", "target_flags", ")", "&", "MASK_HITACHI", ")", "return", "_", "(", "\"created and used with different ABIs\"", ")", ";", "if", "(", "(", "old_flags", "^", "target_flags", ")", "&", "MASK_LITTLE_ENDIAN", ")", "return", "_", "(", "\"created and used with different endianness\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_CHECK_PCH_TARGET_FLAGS", "." ]

[ "sh", "\"created and used with different architectures / ABIs\"", "\"created and used with different ABIs\"", "\"created and used with different endianness\"" ]

[]

[ "<s>", "bool", "FixFunctionBitcasts", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Fix Function Bitcasts **********\\n\"", ")", ";", "Function", "*", "Main", "=", "nullptr", ";", "CallInst", "*", "CallMain", "=", "nullptr", ";", "SmallVector", "<", "std", "::", "pair", "<", "CallBase", "*", ",", "Function", "*", ">", ",", "0", ">", "Uses", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Swift", ")", "continue", ";", "findUses", "(", "&", "F", ",", "F", ",", "Uses", ")", ";", "if", "(", "F", ".", "getName", "(", ")", "==", "\"main\"", ")", "{", "Main", "=", "&", "F", ";", "LLVMContext", "&", "C", "=", "M", ".", "getContext", "(", ")", ";", "Type", "*", "MainArgTys", "[", "]", "=", "{", "Type", "::", "getInt32Ty", "(", "C", ")", ",", "PointerType", "::", "get", "(", "Type", "::", "getInt8PtrTy", "(", "C", ")", ",", "0", ")", "}", ";", "FunctionType", "*", "MainTy", "=", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "C", ")", ",", "MainArgTys", ",", "false", ")", ";", "if", "(", "shouldFixMainFunction", "(", "F", ".", "getFunctionType", "(", ")", ",", "MainTy", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found `main` function with incorrect type: \"", "<<", "*", "F", ".", "getFunctionType", "(", ")", "<<", "\"\\n\"", ")", ";", "Value", "*", "Args", "[", "]", "=", "{", "UndefValue", "::", "get", "(", "MainArgTys", "[", "0", "]", ")", ",", "UndefValue", "::", "get", "(", "MainArgTys", "[", "1", "]", ")", "}", ";", "Value", "*", "Casted", "=", "ConstantExpr", "::", "getBitCast", "(", "Main", ",", "PointerType", "::", "get", "(", "MainTy", ",", "0", ")", ")", ";", "CallMain", "=", "CallInst", "::", "Create", "(", "MainTy", ",", "Casted", ",", "Args", ",", "\"call_main\"", ")", ";", "Uses", ".", "push_back", "(", "std", "::", "make_pair", "(", "CallMain", ",", "&", "F", ")", ")", ";", "}", "}", "}", "DenseMap", "<", "std", "::", "pair", "<", "Function", "*", ",", "FunctionType", "*", ">", ",", "Function", "*", ">", "Wrappers", ";", "for", "(", "auto", "&", "UseFunc", ":", "Uses", ")", "{", "CallBase", "*", "CB", "=", "UseFunc", ".", "first", ";", "Function", "*", "F", "=", "UseFunc", ".", "second", ";", "FunctionType", "*", "Ty", "=", "CB", "->", "getFunctionType", "(", ")", ";", "auto", "Pair", "=", "Wrappers", ".", "insert", "(", "std", "::", "make_pair", "(", "std", "::", "make_pair", "(", "F", ",", "Ty", ")", ",", "nullptr", ")", ")", ";", "if", "(", "Pair", ".", "second", ")", "Pair", ".", "first", "->", "second", "=", "createWrapper", "(", "F", ",", "Ty", ")", ";", "Function", "*", "Wrapper", "=", "Pair", ".", "first", "->", "second", ";", "if", "(", "!", "Wrapper", ")", "continue", ";", "CB", "->", "setCalledOperand", "(", "Wrapper", ")", ";", "}", "if", "(", "CallMain", ")", "{", "Main", "->", "setName", "(", "\"__original_main\"", ")", ";", "auto", "*", "MainWrapper", "=", "cast", "<", "Function", ">", "(", "CallMain", "->", "getCalledOperand", "(", ")", "->", "stripPointerCastsSafe", "(", ")", ")", ";", "delete", "CallMain", ";", "if", "(", "Main", "->", "isDeclaration", "(", ")", ")", "{", "MainWrapper", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "MainWrapper", "->", "setName", "(", "\"main\"", ")", ";", "MainWrapper", "->", "setLinkage", "(", "Main", "->", "getLinkage", "(", ")", ")", ";", "MainWrapper", "->", "setVisibility", "(", "Main", "->", "getVisibility", "(", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "WebAssembly", "\"********** Fix Function Bitcasts **********\\n\"", "0", "\"main\"", "0", "\"Found `main` function with incorrect type: \"", "\"\\n\"", "0", "1", "0", "\"call_main\"", "\"__original_main\"", "\"main\"" ]

[]

[ "<s>", "static", "int", "vfp_emit_fstmx", "(", "int", "base_reg", ",", "int", "count", ")", "{", "rtx", "par", ";", "rtx", "dwarf", ";", "rtx", "tmp", ",", "reg", ";", "int", "i", ";", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "{", "if", "(", "base_reg", "==", "LAST_VFP_REGNUM", "-", "3", ")", "base_reg", "-=", "2", ";", "count", "++", ";", "}", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "1", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_DEC", "(", "BLKmode", ",", "stack_pointer_rtx", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "(", "count", "*", "8", "+", "4", ")", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "DFmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", "=", "tmp", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", ";", "i", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "DFmode", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "i", "*", "8", ")", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "i", "+", "1", ")", "=", "tmp", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ",", "REG_NOTES", "(", "par", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "return", "count", "*", "8", "+", "4", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "save", "block", "of", "VFP", "register", "pairs", "to", "the", "stack", ".", "Returns", "the", "number", "of", "bytes", "pushed", "." ]

[ "arm", "2", "3", "2", "1", "2", "0", "0", "1", "8", "4", "1", "0", "0", "1", "0", "1", "1", "2", "0", "8", "1", "0", "1", "1", "8", "4" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "LB", ":", "case", "RISCV", "::", "LBU", ":", "case", "RISCV", "::", "LH", ":", "case", "RISCV", "::", "LHU", ":", "case", "RISCV", "::", "LW", ":", "case", "RISCV", "::", "FLW", ":", "case", "RISCV", "::", "LWU", ":", "case", "RISCV", "::", "LD", ":", "case", "RISCV", "::", "FLD", ":", "case", "RISCV", "::", "VLE_V_um", ":", "break", ";", "}", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "VLE_V_um", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "else", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "RISCV", "RISCV", "0", "RISCV::LB", "RISCV::LBU", "RISCV::LH", "RISCV::LHU", "RISCV::LW", "RISCV::FLW", "RISCV::LWU", "RISCV::LD", "RISCV::FLD", "RISCV::VLE_V_um", "RISCV::VLE_V_um", "1", "1", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_RegMask", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_PPC64_Altivec_RegMask", ":", "CSR_PPC64_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_AIX32_Altivec_RegMask", ":", "CSR_AIX32_RegMask", ")", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR32_ColdCC_SPE_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_PPC64_Altivec_RegMask", ":", "CSR_PPC64_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR432_SPE_RegMask", ":", "CSR_SVR432_RegMask", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "sparc_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"floatAbi\"", ",", "sparc_d_handle_target_float_abi", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_CPU_TARGET_INFO", "." ]

[ "sparc", "\"floatAbi\"" ]

[]

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

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

[ "TriCore", "TriCore" ]

[]

[ "<s>", "static", "rtx", "mips_prepare_builtin_target", "(", "enum", "insn_code", "icode", ",", "unsigned", "int", "op", ",", "rtx", "target", ")", "{", "enum", "machine_mode", "mode", ";", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "op", "]", ".", "mode", ";", "if", "(", "target", "==", "0", "||", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "op", "]", ".", "predicate", "(", "target", ",", "mode", ")", ")", "target", "=", "gen_reg_rtx", "(", "mode", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Return", "an", "rtx", "suitable", "for", "output", "operand", "OP", "of", "instruction", "ICODE", ".", "If", "TARGET", "is", "non-null", ",", "try", "to", "use", "it", "where", "possible", "." ]

[ "mips", "0" ]

[]

[ "<s>", "const", "AVRRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "AVR", "AVR" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI_end", "=", "MBB", ".", "end", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "EH_RETURN_JMPR", ")", "{", "assert", "(", "MBBI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"Offset should be in register!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "L2_deallocframe", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "A2_add", ")", ",", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R28", ")", ";", "return", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "JMPret", "&&", "!", "DisableDeallocRet", ")", "{", "MachineBasicBlock", "::", "iterator", "BeforeJMPR", "=", "MBB", ".", "begin", "(", ")", "==", "MBBI", "?", "MBBI", ":", "std", "::", "prev", "(", "MBBI", ")", ";", "if", "(", "BeforeJMPR", "!=", "MBBI", "&&", "BeforeJMPR", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_RET_JMP_V4", ")", "{", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI_end", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "L4_return", ")", ")", ";", "MIB", "->", "copyImplicitOps", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "&", "*", "MBBI", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "Term", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "Term", "==", "MBB", ".", "begin", "(", ")", "?", "MBB", ".", "end", "(", ")", ":", "std", "::", "prev", "(", "Term", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_BEFORE_TAILCALL_V4", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "L2_deallocframe", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::EH_RETURN_JMPR", "0", "\"Offset should be in register!\"", "Hexagon::L2_deallocframe", "Hexagon::A2_add", "Hexagon::R29", "Hexagon::R29", "Hexagon::R28", "Hexagon::JMPret", "Hexagon::RESTORE_DEALLOC_RET_JMP_V4", "Hexagon::L4_return", "Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4", "Hexagon::L2_deallocframe" ]

[]

[ "<s>", "const", "NVPTXTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "int", "M68kRegisterInfo", "::", "getSpillRegisterOrder", "(", "unsigned", "Reg", ")", "const", "{", "int", "Result", "=", "getRegisterOrder", "(", "Reg", ",", "*", "getRegClass", "(", "M68k", "::", "SPILLRegClassID", ")", ")", ";", "assert", "(", "Result", ">=", "0", "&&", "\"Can not determine spill order\"", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "spill", "order", "index", "of", "a", "register", ",", "if", "there", "is", "none", "then", "trap", "." ]

[ "M68k", "M68k", "M68k::SPILLRegClassID", "0", "\"Can not determine spill order\"" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "}", "if", "(", "getPPCTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", "{", "addPass", "(", "&", "LiveVariablesID", ")", ";", "addPass", "(", "createPPCTLSDynamicCallPass", "(", ")", ")", ";", "}", "if", "(", "EnableExtraTOCRegDeps", ")", "addPass", "(", "createPPCTOCRegDepsPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "MachinePipelinerID", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "unsigned", "getOffsetReg", "(", ")", "const", "{", "assert", "(", "isRegBase", "(", ")", "&&", "\"Invalid offset register access!\"", ")", ";", "return", "OffsetReg", ";", "}", "</s>" ]

[ "Get", "the", "offset", "register", "of", "the", "pointer", "value", "." ]

[ "AArch64", "\"Invalid offset register access!\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "OR1KTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "OR1K", "OR1K" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowsMemoryAccess", "(", "LLVMContext", "&", "Context", ",", "const", "DataLayout", "&", "DL", ",", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "Align", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Subtarget", ".", "isHVXVectorType", "(", "SVT", ",", "true", ")", ")", "return", "allowsHvxMemoryAccess", "(", "SVT", ",", "Flags", ",", "Fast", ")", ";", "return", "TargetLoweringBase", "::", "allowsMemoryAccess", "(", "Context", ",", "DL", ",", "VT", ",", "AddrSpace", ",", "Alignment", ",", "Flags", ",", "Fast", ")", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "the", "memory", "access", "is", "aligned", "or", "if", "the", "target", "allows", "this", "specific", "unaligned", "memory", "access", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "TLCS900", "TLCS900" ]

[]

[ "<s>", "static", "int", "function_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "(", "mode", "==", "BLKmode", "||", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_COMPLEX_FLOAT", ")", "&&", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", ")", "{", "int", "words", ";", "if", "(", "mode", "==", "BLKmode", ")", "words", "=", "(", "(", "int_size_in_bytes", "(", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "else", "words", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "words", "+", "cum", "->", "arg_words", "<=", "MAX_ARGS_IN_REGISTERS", ")", "return", "0", ";", "return", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "arg_words", ")", "*", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "mode", "==", "DImode", "&&", "cum", "->", "arg_words", "==", "MAX_ARGS_IN_REGISTERS", "-", "1", ")", "return", "UNITS_PER_WORD", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "number", "of", "bytes", "of", "argument", "to", "put", "in", "registers", "." ]

[ "microblaze", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "arc_text_label", "(", "rtx_insn", "*", "label", ")", "{", "rtx_insn", "*", "next", ";", "gcc_assert", "(", "GET_CODE", "(", "label", ")", "==", "CODE_LABEL", "||", "(", "GET_CODE", "(", "label", ")", "==", "NOTE", "&&", "NOTE_KIND", "(", "label", ")", "==", "NOTE_INSN_DELETED_LABEL", ")", ")", ";", "next", "=", "next_nonnote_insn", "(", "label", ")", ";", "if", "(", "next", ")", "return", "(", "!", "JUMP_TABLE_DATA_P", "(", "next", ")", "||", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "!=", "ADDR_VEC", ")", ";", "else", "if", "(", "!", "PREV_INSN", "(", "label", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "LABEL", "is", "in", "executable", "code", "." ]

[ "arc" ]

[]

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

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

[ "CSKY" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasStoreToStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "RegisterBankInfo", "::", "InstructionMappings", "M88kRegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "{", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "assert", "(", "NumOperands", "<=", "3", "&&", "\"This code is for instructions with 3 or less operands\"", ")", ";", "InstructionMappings", "AltMappings", ";", "AltMappings", ".", "push_back", "(", "&", "getInstructionMapping", "(", "1", ",", "1", ",", "getValueMapping", "(", "PMI_XR32", ")", ",", "NumOperands", ")", ")", ";", "AltMappings", ".", "push_back", "(", "&", "getInstructionMapping", "(", "2", ",", "1", ",", "getValueMapping", "(", "PMI_XR80", ")", ",", "NumOperands", ")", ")", ";", "return", "AltMappings", ";", "}", "default", ":", "break", ";", "}", "return", "RegisterBankInfo", "::", "getInstrAlternativeMappings", "(", "MI", ")", ";", "}", "</s>" ]

[ "Get", "the", "alternative", "mappings", "for", "MI", "." ]

[ "M88k", "M88k", "3", "\"This code is for instructions with 3 or less operands\"", "1", "1", "2", "1" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "isConditionalBranch", "(", "Inst", ")", ")", "{", "int64_t", "Imm", ";", "if", "(", "Size", "==", "2", ")", "Imm", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "else", "Imm", "=", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_JAL", "||", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "C_J", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "JAL", ")", "{", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "RISCV", "2", "1", "2", "RISCV::C_JAL", "RISCV::C_J", "0", "RISCV::JAL", "1" ]

[]

[ "<s>", "void", "VideoCore4FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "determineFrameLayout", "(", "MF", ")", ";", "const", "VideoCore4InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "VideoCore4InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "VideoCore4RegisterInfo", "&", "RI", "=", "*", "static_cast", "<", "const", "VideoCore4RegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "stacksize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "stacksize", "+=", "4", ";", "TII", ".", "adjustStackPtr", "(", "-", "stacksize", ",", "MBB", ",", "MI", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "unsigned", "FP", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "VideoCore4", "4" ]

[]

[ "<s>", "static", "void", "loongarch_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "loongarch_arg_info", "info", ";", "loongarch_get_arg_info", "(", "&", "info", ",", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ")", ";", "cum", "->", "num_fprs", "=", "info", ".", "fpr_offset", "+", "info", ".", "num_fprs", ";", "cum", "->", "num_gprs", "=", "info", ".", "gpr_offset", "+", "info", ".", "num_gprs", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "loongarch" ]

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "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", ":", "report_fatal_error", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "break", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "getHasAlu32", "(", ")", "?", "CC_BPF32", ":", "CC_BPF64", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "MVT", "::", "SimpleValueType", "SimpleTy", "=", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ";", "switch", "(", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "'\\n'", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "SimpleTy", "==", "MVT", "::", "i64", "?", "&", "BPF", "::", "GPRRegClass", ":", "&", "BPF", "::", "GPR32RegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VReg", ",", "RegVT", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "RegVT", ",", "ArgValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "break", ";", "}", "}", "else", "{", "fail", "(", "DL", ",", "DAG", ",", "\"defined with too many args\"", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "if", "(", "IsVarArg", "||", "MF", ".", "getFunction", "(", ")", ".", "hasStructRetAttr", "(", ")", ")", "{", "fail", "(", "DL", ",", "DAG", ",", "\"functions with VarArgs or StructRet are not supported\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::InputArg", "\"Unsupported calling convention\"", "16", "BPF", "BPF", "MVT::SimpleValueType", "\"LowerFormalArguments Unhandled argument type: \"", "0", "MVT::i32", "MVT::i64", "MVT::i64", "BPF::GPRRegClass", "BPF::GPR32RegClass", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE", "\"defined with too many args\"", "0", "\"functions with VarArgs or StructRet are not supported\"" ]

[]

[ "<s>", "void", "MipsSEInstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MipsSubtarget", "&", "STI", "=", "Subtarget", ";", "DebugLoc", "DL", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "unsigned", "ADDiu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDiu", ":", "Mips", "::", "ADDiu", ";", "if", "(", "Amount", "==", "0", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDiu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "else", "{", "unsigned", "Reg", "=", "loadImmediate", "(", "Amount", ",", "MBB", ",", "I", ",", "DL", ",", "nullptr", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "Mips", "Mips::DADDu", "Mips::ADDu", "Mips::DADDiu", "Mips::ADDiu", "0", "16" ]

[]

[ "<s>", "const", "uint32_t", "*", "RISCVRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "if", "(", "Subtarget", ".", "hasD", "(", ")", ")", "return", "CSR_RV64D_RegMask", ";", "else", "if", "(", "Subtarget", ".", "hasF", "(", ")", ")", "return", "CSR_RV64F_RegMask", ";", "else", "return", "CSR_RV64_RegMask", ";", "else", "if", "(", "Subtarget", ".", "hasD", "(", ")", ")", "return", "CSR_RV32D_RegMask", ";", "else", "if", "(", "Subtarget", ".", "hasF", "(", ")", ")", "return", "CSR_RV32F_RegMask", ";", "else", "return", "CSR_RV32_RegMask", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "Idx", "==", "getVGPRPressureSet", "(", ")", ")", "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>", "bool", "HexagonTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", "{", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "PowerPC" ]

[]

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

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

[ "AArch64", "\"AArch64 Condition Optimizer\"" ]

[]

[ "<s>", "static", "bool", "currently_supported_simd_type", "(", "tree", "t", ",", "tree", "b", ")", "{", "if", "(", "COMPLEX_FLOAT_TYPE_P", "(", "t", ")", ")", "return", "false", ";", "if", "(", "TYPE_SIZE", "(", "t", ")", "!=", "TYPE_SIZE", "(", "b", ")", ")", "return", "false", ";", "return", "supported_simd_type", "(", "t", ")", ";", "}", "</s>" ]

[ "Return", "true", "for", "types", "that", "currently", "are", "supported", "as", "SIMD", "return", "or", "argument", "types", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "addPreRegAlloc", "(", ")", "override", "{", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::STri", "0", "SP::FPRegsRegisterClass", "SP::STFri", "0", "SP::DFPRegsRegisterClass", "SP::STDFri", "0", "\"Can't store this register to stack slot\"" ]

[]

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

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

[ "AVR", "AVR" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "X86GenInstrInfo", "::", "MachineOutlinerInstrType", "X86InstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MIT", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MIT", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "isTailCall", "(", "MI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isReturn", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RSP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RSP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "readsRegister", "(", "X86", "::", "RIP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RIP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RIP", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "X86", "X86", "X86", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RIP", "X86::RIP", "X86::RIP" ]

[]

[ "<s>", "XCoreTargetMachine", "::", "XCoreTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "DataLayout", "(", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameInfo", "(", "Subtarget", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "XCore", "XCore", "XCore", "\"e-p:32:32:32-a0:0:32-f32:32:32-f64:32:32-i1:8:32-i8:8:32-\"", "\"i16:16:32-i32:32:32-i64:32:32-n32\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isExtFreeImpl", "(", "const", "Instruction", "*", "Ext", ")", "const", "{", "if", "(", "isa", "<", "FPExtInst", ">", "(", "Ext", ")", ")", "return", "false", ";", "if", "(", "Ext", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "for", "(", "const", "Use", "&", "U", ":", "Ext", "->", "uses", "(", ")", ")", "{", "const", "Instruction", "*", "Instr", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "switch", "(", "Instr", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Shl", ":", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "Instr", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "Instruction", "::", "GetElementPtr", ":", "{", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "Instr", ")", ";", "auto", "&", "DL", "=", "Ext", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "std", "::", "advance", "(", "GTI", ",", "U", ".", "getOperandNo", "(", ")", ")", ";", "Type", "*", "IdxTy", "=", "*", "GTI", ";", "uint64_t", "ShiftAmt", "=", "countTrailingZeros", "(", "DL", ".", "getTypeStoreSizeInBits", "(", "IdxTy", ")", ")", "-", "3", ";", "if", "(", "ShiftAmt", "==", "0", "||", "ShiftAmt", ">", "4", ")", "return", "false", ";", "break", ";", "}", "case", "Instruction", "::", "Trunc", ":", "if", "(", "Instr", "->", "getType", "(", ")", "==", "Ext", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", "continue", ";", "default", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "extension", "represented", "by", "I", "is", "free", "." ]

[ "AArch64", "AArch64", "1", "3", "0", "4", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "TL45RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CC_Save_SaveList", ";", "}", "</s>" ]

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

[ "TL45", "TL45" ]

[]

[ "<s>", "static", "void", "rs6000_density_test", "(", "rs6000_cost_data", "*", "data", ")", "{", "const", "int", "DENSITY_PCT_THRESHOLD", "=", "85", ";", "const", "int", "DENSITY_SIZE_THRESHOLD", "=", "70", ";", "const", "int", "DENSITY_PENALTY", "=", "10", ";", "struct", "loop", "*", "loop", "=", "data", "->", "loop_info", ";", "basic_block", "*", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "int", "nbbs", "=", "loop", "->", "num_nodes", ";", "loop_vec_info", "loop_vinfo", "=", "loop_vec_info_for_loop", "(", "data", "->", "loop_info", ")", ";", "int", "vec_cost", "=", "data", "->", "cost", "[", "vect_body", "]", ",", "not_vec_cost", "=", "0", ";", "int", "i", ",", "density_pct", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nbbs", ";", "i", "++", ")", "{", "basic_block", "bb", "=", "bbs", "[", "i", "]", ";", "gimple_stmt_iterator", "gsi", ";", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "gimple", "*", "stmt", "=", "gsi_stmt", "(", "gsi", ")", ";", "stmt_vec_info", "stmt_info", "=", "loop_vinfo", "->", "lookup_stmt", "(", "stmt", ")", ";", "if", "(", "!", "STMT_VINFO_RELEVANT_P", "(", "stmt_info", ")", "&&", "!", "STMT_VINFO_IN_PATTERN_P", "(", "stmt_info", ")", ")", "not_vec_cost", "++", ";", "}", "}", "free", "(", "bbs", ")", ";", "density_pct", "=", "(", "vec_cost", "*", "100", ")", "/", "(", "vec_cost", "+", "not_vec_cost", ")", ";", "if", "(", "density_pct", ">", "DENSITY_PCT_THRESHOLD", "&&", "vec_cost", "+", "not_vec_cost", ">", "DENSITY_SIZE_THRESHOLD", ")", "{", "data", "->", "cost", "[", "vect_body", "]", "=", "vec_cost", "*", "(", "100", "+", "DENSITY_PENALTY", ")", "/", "100", ";", "if", "(", "dump_enabled_p", "(", ")", ")", "dump_printf_loc", "(", "MSG_NOTE", ",", "vect_location", ",", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"", ",", "density_pct", ",", "vec_cost", "+", "not_vec_cost", ",", "DENSITY_PENALTY", ")", ";", "}", "}", "</s>" ]

[ "Test", "for", "likely", "overcommitment", "of", "vector", "hardware", "resources", ".", "If", "a", "loop", "iteration", "is", "relatively", "large", ",", "and", "too", "large", "a", "percentage", "of", "instructions", "in", "the", "loop", "are", "vectorized", ",", "the", "cost", "model", "may", "not", "adequately", "reflect", "delays", "from", "unavailable", "vector", "resources", ".", "Penalize", "the", "loop", "body", "cost", "for", "this", "case", "." ]

[ "rs6000", "85", "70", "10", "0", "0", "100", "100", "100", "\"density %d%%, cost %d exceeds threshold, penalizing \"", "\"loop body cost by %d%%\"" ]

[]

[ "<s>", "void", "ARM64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "ARM64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "DL", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM64", "::", "ADJCALLSTACKDOWN", ")", "{", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "ARM64", "::", "SP", ",", "ARM64", "::", "SP", ",", "-", "Amount", ",", "TII", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM64", "::", "ADJCALLSTACKUP", "&&", "\"expected ADJCALLSTACKUP\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "ARM64", "::", "SP", ",", "ARM64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "ARM64", "ARM64", "ARM64", "ARM64", "0", "0", "1", "ARM64::ADJCALLSTACKDOWN", "ARM64::SP", "ARM64::SP", "ARM64::ADJCALLSTACKUP", "\"expected ADJCALLSTACKUP\"", "ARM64::SP", "ARM64::SP" ]

[]

[ "<s>", "static", "int", "arc_register_move_cost", "(", "machine_mode", ",", "reg_class_t", "from_class", ",", "reg_class_t", "to_class", ")", "{", "if", "(", "(", "TARGET_ARC700", "||", "TARGET_EM", ")", "&&", "TARGET_DPFP", "&&", "from_class", "==", "DOUBLE_REGS", "&&", "to_class", "==", "DOUBLE_REGS", ")", "return", "100", ";", "return", "2", ";", "}", "</s>" ]

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

[ "arc", "100", "2" ]

[]

[ "<s>", "void", "erasingInstr", "(", "MachineInstr", "&", "MI", ")", "override", "{", "}", "</s>" ]

[ "An", "instruction", "is", "about", "to", "be", "erased", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ",", "bool", "ForCodeSize", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", "||", "!", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "ppcf128", ":", "return", "Imm", ".", "isPosZero", "(", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "MVT::f32", "MVT::f64", "MVT::ppcf128" ]

[]

[ "<s>", "static", "void", "mmix_target_asm_function_epilogue", "(", "FILE", "*", "stream", ")", "{", "fputc", "(", "'\\n'", ",", "stream", ")", ";", "}", "</s>" ]

[ "TARGET_ASM_FUNCTION_EPILOGUE", "." ]

[ "mmix" ]

[]

[ "<s>", "TargetIRAnalysis", "ARMBaseTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "ARMTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "static", "HOST_WIDE_INT", "s390_constant_alignment", "(", "const_tree", ",", "HOST_WIDE_INT", "align", ")", "{", "return", "MAX", "(", "align", ",", "16", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", ".", "Alignment", "on", "even", "addresses", "for", "LARL", "instruction", "." ]

[ "s390", "16" ]

[]

[ "<s>", "void", "J2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MI", "!=", "MBB", ".", "end", "(", ")", "?", "MI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "J2", "::", "MOV32rm", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "J2", "J2", "J2::MOV32rm" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isBasicBlockPrologue", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "!", "MI", ".", "isTerminator", "(", ")", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "COPY", "&&", "MI", ".", "modifiesRegister", "(", "AMDGPU", "::", "EXEC", ",", "&", "RI", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "instruction", "is", "bound", "to", "the", "top", "of", "its", "basic", "block", "and", "no", "other", "instructions", "shall", "be", "inserted", "before", "it", "." ]

[ "AMDGPU", "SI", "AMDGPU::COPY", "AMDGPU::EXEC" ]

[]

[ "<s>", "bool", "ARMFastISel", "::", "fastLowerArguments", "(", ")", "{", "if", "(", "!", "FuncInfo", ".", "CanLowerReturn", ")", "return", "false", ";", "const", "Function", "*", "F", "=", "FuncInfo", ".", "Fn", ";", "if", "(", "F", "->", "isVarArg", "(", ")", ")", "return", "false", ";", "CallingConv", "::", "ID", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "return", "false", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "ARM_AAPCS_VFP", ":", "case", "CallingConv", "::", "ARM_AAPCS", ":", "case", "CallingConv", "::", "ARM_APCS", ":", "break", ";", "}", "unsigned", "Idx", "=", "1", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->", "arg_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "Idx", ")", "{", "if", "(", "Idx", ">", "4", ")", "return", "false", ";", "if", "(", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "InReg", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "StructRet", ")", "||", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "ByVal", ")", ")", "return", "false", ";", "Type", "*", "ArgTy", "=", "I", "->", "getType", "(", ")", ";", "if", "(", "ArgTy", "->", "isStructTy", "(", ")", "||", "ArgTy", "->", "isArrayTy", "(", ")", "||", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "EVT", "ArgVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "ArgTy", ")", ";", "if", "(", "!", "ArgVT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "ArgVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "break", ";", "default", ":", "return", "false", ";", "}", "}", "static", "const", "uint16_t", "GPRArgRegs", "[", "]", "=", "{", "ARM", "::", "R0", ",", "ARM", "::", "R1", ",", "ARM", "::", "R2", ",", "ARM", "::", "R3", "}", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "rGPRRegClass", ";", "Idx", "=", "0", ";", "for", "(", "Function", "::", "const_arg_iterator", "I", "=", "F", "->", "arg_begin", "(", ")", ",", "E", "=", "F", "->", "arg_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "Idx", ")", "{", "unsigned", "SrcReg", "=", "GPRArgRegs", "[", "Idx", "]", ";", "unsigned", "DstReg", "=", "FuncInfo", ".", "MF", "->", "addLiveIn", "(", "SrcReg", ",", "RC", ")", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "DstReg", ",", "getKillRegState", "(", "true", ")", ")", ";", "updateValueMap", "(", "I", ",", "ResultReg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "argument", "lowering", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "1", "4", "MVT::i8", "MVT::i16", "MVT::i32", "ARM::R0", "ARM::R1", "ARM::R2", "ARM::R3", "ARM::rGPRRegClass", "0" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isThroughputPattern", "(", "MachineCombinerPattern", "Pattern", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "default", ":", "break", ";", "case", "MachineCombinerPattern", "::", "FMULADDS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f32_OP2", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "code", "sequence", "can", "improve", "throughput", "." ]

[ "AArch64", "AArch64" ]

[]

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

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

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "AMDGPUAAResult", "::", "pointsToConstantMemory", "(", "const", "MemoryLocation", "&", "Loc", ",", "bool", "OrLocal", ")", "{", "const", "Value", "*", "Base", "=", "GetUnderlyingObject", "(", "Loc", ".", "Ptr", ",", "DL", ")", ";", "if", "(", "Base", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "AS", ".", "CONSTANT_ADDRESS", "||", "Base", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", "==", "AS", ".", "CONSTANT_ADDRESS_32BIT", ")", "{", "return", "true", ";", "}", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Base", ")", ")", "{", "if", "(", "GV", "->", "isConstant", "(", ")", ")", "return", "true", ";", "}", "else", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "Base", ")", ")", "{", "const", "Function", "*", "F", "=", "Arg", "->", "getParent", "(", ")", ";", "switch", "(", "F", "->", "getCallingConv", "(", ")", ")", "{", "default", ":", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "OrLocal", ")", ";", "case", "CallingConv", "::", "AMDGPU_LS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "break", ";", "}", "unsigned", "ArgNo", "=", "Arg", "->", "getArgNo", "(", ")", ";", "if", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "NoAlias", ")", "&&", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadNone", ")", "||", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadOnly", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "OrLocal", ")", ";", "}", "</s>" ]

[ "A", "convenience", "wrapper", "around", "the", "primary", "pointsToConstantMemory", "interface", "." ]

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

[]

[ "<s>", "SDValue", "MandarinTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", ".", "dump", "(", ")", ";", "DAG", ".", "dump", "(", ")", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerAddress", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Mandarin", "\"Should not custom lower this!\"", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::EXTRACT_VECTOR_ELT", "ISD::GlobalAddress", "ISD::ConstantPool" ]

[]

[ "<s>", "rtx", "ix86_libcall_value", "(", "machine_mode", "mode", ")", "{", "return", "ix86_function_value_1", "(", "NULL", ",", "NULL", ",", "mode", ",", "mode", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", "assuming", "the", "value", "has", "mode", "MODE", "." ]

[ "i386" ]

[]

[ "<s>", "static", "bool", "exact_dependency_1", "(", "rtx", "addr", ",", "rtx", "insn", ")", "{", "enum", "rtx_code", "code", ";", "const", "char", "*", "format_ptr", ";", "int", "i", ",", "j", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "switch", "(", "code", ")", "{", "case", "MEM", ":", "if", "(", "rtx_equal_p", "(", "addr", ",", "insn", ")", ")", "return", "true", ";", "break", ";", "case", "REG", ":", "CASE_CONST_ANY", ":", "case", "SYMBOL_REF", ":", "case", "CODE_LABEL", ":", "case", "PC", ":", "case", "EXPR_LIST", ":", "return", "false", ";", "default", ":", "break", ";", "}", "format_ptr", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_RTX_LENGTH", "(", "code", ")", ";", "i", "++", ")", "{", "switch", "(", "*", "format_ptr", "++", ")", "{", "case", "'e'", ":", "if", "(", "exact_dependency_1", "(", "addr", ",", "XEXP", "(", "insn", ",", "i", ")", ")", ")", "return", "true", ";", "break", ";", "case", "'E'", ":", "for", "(", "j", "=", "0", ";", "j", "<", "XVECLEN", "(", "insn", ",", "i", ")", ";", "j", "++", ")", "if", "(", "exact_dependency_1", "(", "addr", ",", "XVECEXP", "(", "insn", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "break", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "for", "exact_store_load_dependency", ".", "Return", "true", "if", "addr", "is", "found", "in", "insn", "." ]

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

[]

[ "<s>", "Value", "*", "AArch64TargetLowering", "::", "getSSPStackGuardCheck", "(", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", ")", "return", "M", ".", "getFunction", "(", "\"__security_check_cookie\"", ")", ";", "return", "TargetLowering", "::", "getSSPStackGuardCheck", "(", "M", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "stack", "protection", "check", "function", "that", "performs", "validation", "and", "error", "handling", ",", "returns", "the", "function", "." ]

[ "AArch64", "AArch64", "\"__security_check_cookie\"" ]

[]

[ "<s>", "bool", "isImm", "(", "int64_t", "MinValue", ",", "int64_t", "MaxValue", ")", "const", "{", "return", "Kind", "==", "OpKind_Imm", "&&", "inRange", "(", "Imm", ",", "MinValue", ",", "MaxValue", ")", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "M88k" ]

[]

[ "<s>", "void", "Mips16TargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "char", "*", "Mips16HelperFunction", "=", "0", ";", "bool", "NeedMips16Helper", "=", "false", ";", "if", "(", "getTargetMachine", "(", ")", ".", "Options", ".", "UseSoftFloat", "&&", "Mips16HardFloat", ")", "{", "bool", "LookupHelper", "=", "true", ";", "if", "(", "ExternalSymbolSDNode", "*", "S", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "if", "(", "NoHelperNeeded", ".", "find", "(", "S", "->", "getSymbol", "(", ")", ")", "!=", "NoHelperNeeded", ".", "end", "(", ")", ")", "{", "LookupHelper", "=", "false", ";", "}", "}", "if", "(", "LookupHelper", ")", "Mips16HelperFunction", "=", "getMips16HelperFunction", "(", "CLI", ".", "RetTy", ",", "CLI", ".", "Args", ",", "NeedMips16Helper", ")", ";", "}", "SDValue", "JumpTarget", "=", "Callee", ";", "if", "(", "IsPICCall", "||", "!", "GlobalOrExternal", ")", "{", "unsigned", "V0Reg", "=", "Mips", "::", "V0", ";", "if", "(", "NeedMips16Helper", ")", "{", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "V0Reg", ",", "Callee", ")", ")", ";", "JumpTarget", "=", "DAG", ".", "getExternalSymbol", "(", "Mips16HelperFunction", ",", "getPointerTy", "(", ")", ")", ";", "JumpTarget", "=", "getAddrGlobal", "(", "JumpTarget", ",", "DAG", ",", "MipsII", "::", "MO_GOT", ")", ";", "}", "else", "RegsToPass", ".", "push_front", "(", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Mips", "::", "T9", ",", "Callee", ")", ")", ";", "}", "Ops", ".", "push_back", "(", "JumpTarget", ")", ";", "MipsTargetLowering", "::", "getOpndList", "(", "Ops", ",", "RegsToPass", ",", "IsPICCall", ",", "GlobalOrExternal", ",", "InternalLinkage", ",", "CLI", ",", "Callee", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips", "0", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::V0", "Mips", "Mips", "MipsII::MO_GOT", "Mips::T9", "Mips" ]

[]