Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "bool", "mips_expand_vselect", "(", "rtx", "target", ",", "rtx", "op0", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ")", "{", "rtx", "rperm", "[", "MAX_VECT_LEN", "]", ",", "x", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "rperm", "[", "i", "]", "=", "GEN_INT", "(", "perm", "[", "i", "]", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "nelt", ",", "rperm", ")", ")", ";", "x", "=", "gen_rtx_VEC_SELECT", "(", "GET_MODE", "(", "target", ")", ",", "op0", ",", "x", ")", ";", "x", "=", "gen_rtx_SET", "(", "target", ",", "x", ")", ";", "insn", "=", "emit_insn", "(", "x", ")", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "{", "remove_insn", "(", "insn", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Construct", "(", "set", "target", "(", "vec_select", "op0", "(", "parallel", "perm", ")", ")", ")", "and", "return", "true", "if", "that", "'s", "a", "valid", "instruction", "in", "the", "active", "ISA", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "bool", "ix86_secondary_memory_needed", "(", "enum", "reg_class", "class1", ",", "enum", "reg_class", "class2", ",", "machine_mode", "mode", ",", "int", "strict", ")", "{", "return", "inline_secondary_memory_needed", "(", "class1", ",", "class2", ",", "mode", ",", "strict", ")", ";", "}", "</s>" ]

[ "If", "we", "are", "copying", "between", "general", "and", "FP", "registers", ",", "we", "need", "a", "memory", "location", ".", "The", "same", "is", "true", "for", "SSE", "and", "MMX", "registers", ".", "The", "macro", "ca", "n't", "work", "reliably", "when", "one", "of", "the", "CLASSES", "is", "class", "containing", "registers", "from", "multiple", "units", "(", "SSE", ",", "MMX", ",", "integer", ")", ".", "We", "avoid", "this", "by", "never", "combining", "those", "units", "in", "single", "alternative", "in", "the", "machine", "description", ".", "Ensure", "that", "this", "constraint", "holds", "to", "avoid", "unexpected", "surprises", ".", "When", "STRICT", "is", "false", ",", "we", "are", "being", "called", "from", "REGISTER_MOVE_COST", ",", "so", "do", "not", "enforce", "these", "sanity", "checks", "." ]

[ "i386" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "OS", "<<", "\"\\tlock\\n\"", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86II::LOCK", "\"\\tlock\\n\"", "X86" ]

[]

[ "<s>", "const", "std", "::", "string", "&", "THMToTHMStub", "::", "name", "(", ")", "const", "{", "return", "m_Name", ";", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "bool", "xtensa_can_use_doloop_p", "(", "const", "widest_int", "&", ",", "const", "widest_int", "&", ",", "unsigned", "int", "loop_depth", ",", "bool", "entered_at_top", ")", "{", "if", "(", "loop_depth", ">", "1", "||", "!", "entered_at_top", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_USE_DOLOOP_P", "." ]

[ "xtensa", "1" ]

[]

[ "<s>", "rtx", "mips_function_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "valtype", ")", "{", "tree", "fields", "[", "2", "]", ";", "int", "unsignedp", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsignedp", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_mode", "(", "valtype", ",", "mode", ",", "&", "unsignedp", ",", "1", ")", ";", "switch", "(", "mips_fpr_return_fields", "(", "valtype", ",", "fields", ")", ")", "{", "case", "1", ":", "return", "gen_rtx_REG", "(", "mode", ",", "FP_RETURN", ")", ";", "case", "2", ":", "return", "mips_return_fpr_pair", "(", "mode", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "0", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "0", "]", ")", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "fields", "[", "1", "]", ")", ")", ",", "int_byte_position", "(", "fields", "[", "1", "]", ")", ")", ";", "}", "if", "(", "mips_return_in_msb", "(", "valtype", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "}", "}", "if", "(", "mips_abi", "!=", "ABI_EABI", "&&", "!", "FLOAT_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "if", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP_RETURN", ")", ";", "if", "(", "mode", "==", "TFmode", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "DImode", ",", "0", ",", "DImode", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", "return", "mips_return_fpr_pair", "(", "mode", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "0", ",", "GET_MODE_INNER", "(", "mode", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", "/", "2", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "GP_RETURN", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE", "and", "LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

[ "mips", "2", "1", "1", "2", "0", "0", "1", "1", "0", "0", "0", "2", "2", "0", "2" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "WebAssemblyRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "assert", "(", "Kind", "==", "0", "&&", "\"Only one kind of pointer on WebAssembly\"", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "hasAddr64", "(", ")", ")", "return", "&", "WebAssembly", "::", "I64RegClass", ";", "return", "&", "WebAssembly", "::", "I32RegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "WebAssembly", "WebAssembly", "0", "\"Only one kind of pointer on WebAssembly\"", "WebAssembly", "WebAssembly::I64RegClass", "WebAssembly::I32RegClass" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "void", "avr_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", "&&", "!", "call_used_or_fixed_reg_p", "(", "cum", "->", "regno", ")", ")", "{", "cfun", "->", "machine", "->", "sibcall_fails", "=", "1", ";", "}", "if", "(", "cum", "->", "regno", ">=", "8", "&&", "cum", "->", "nregs", ">=", "0", ")", "{", "for", "(", "int", "regno", "=", "cum", "->", "regno", ";", "regno", "<", "cum", "->", "regno", "+", "bytes", ";", "regno", "++", ")", "if", "(", "fixed_regs", "[", "regno", "]", ")", "warning", "(", "0", ",", "\"fixed register %s used to pass parameter to function\"", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>" ]

[ "Update", "the", "summarizer", "variable", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", "." ]

[ "avr", "8", "0", "1", "8", "0", "0", "\"fixed register %s used to pass parameter to function\"", "0", "0" ]

[]

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

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

[ "LC2200" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "IndirectTlsSegRefs", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"indirect-tls-seg-refs\"", ")", ";", "OptForMinSize", "=", "MF", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"indirect-tls-seg-refs\"", "\"OptForMinSize implies OptForSize\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "AArch64FI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "STI", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "MF", ".", "getFunction", "(", ")", ".", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "emitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "emitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "emitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Instruction", "*", "RISCVTargetLowering", "::", "emitLeadingFence", "(", "IRBuilderBase", "&", "Builder", ",", "Instruction", "*", "Inst", ",", "AtomicOrdering", "Ord", ")", "const", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "Inst", ")", "&&", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "Builder", ".", "CreateFence", "(", "Ord", ")", ";", "if", "(", "isa", "<", "StoreInst", ">", "(", "Inst", ")", "&&", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "Builder", ".", "CreateFence", "(", "AtomicOrdering", "::", "Release", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

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

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

[ "UPT" ]

[]

[ "<s>", "bool", "BPFInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "MEMCPY", ")", "{", "expandMEMCPY", "(", "MI", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::MEMCPY" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "XCoreDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "XCoreDisassembler", "*", ">", "(", "D", ")", ";", "return", "*", "(", "Dis", "->", "getRegInfo", "(", ")", "->", "getRegClass", "(", "RC", ")", ".", "begin", "(", ")", "+", "RegNo", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "XCore", "XCore", "XCore" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldConvertPhiType", "(", "Type", "*", "From", ",", "Type", "*", "To", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "return", "TargetLowering", "::", "shouldConvertPhiType", "(", "From", ",", "To", ")", ";", "}", "</s>" ]

[ "Given", "a", "set", "in", "interconnected", "phis", "of", "type", "'From", "'", "that", "are", "loaded/stored", "or", "bitcast", "to", "type", "'To", "'", ",", "return", "true", "if", "the", "set", "should", "be", "converted", "to", "'To", "'", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "fr30_function_arg_advance", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "*", "get_cumulative_args", "(", "cum", ")", "+=", "named", "*", "fr30_num_arg_regs", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "to", "update", "the", "summarizer", "variable", "CUM", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", ".", "The", "values", "MODE", ",", "TYPE", "and", "NAMED", "describe", "that", "argument", ".", "Once", "this", "is", "done", ",", "the", "variable", "CUM", "is", "suitable", "for", "analyzing", "the", "*", "following", "*", "argument", "with", "`", "FUNCTION_ARG", "'", ",", "etc", ".", "This", "macro", "need", "not", "do", "anything", "if", "the", "argument", "in", "question", "was", "passed", "on", "the", "stack", ".", "The", "compiler", "knows", "how", "to", "track", "the", "amount", "of", "stack", "space", "used", "for", "arguments", "without", "any", "special", "help", "." ]

[ "fr30" ]

[]

[ "<s>", "static", "void", "m68k_coff_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "char", "flagchar", ";", "if", "(", "flags", "&", "SECTION_WRITE", ")", "flagchar", "=", "'d'", ";", "else", "flagchar", "=", "'x'", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"%c\\\"\\n\"", ",", "name", ",", "flagchar", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "to", "switch", "to", "section", "NAME", "with", "attribute", "FLAGS", "." ]

[ "m68k", "\"\\t.section\\t%s,\\\"%c\\\"\\n\"" ]

[]

[ "<s>", "static", "bool", "csky_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK801", ")", ")", "return", "ck802_ck801_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ",", "total", ",", "speed", ")", ";", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK803", ")", ")", "return", "ck803_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ",", "total", ",", "speed", ")", ";", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK807", ")", "||", "CSKY_TARGET_ARCH", "(", "CK810", ")", ")", "return", "ck807_ck810_rtx_costs", "(", "x", ",", "code", ",", "outer_code", ",", "total", ",", "speed", ")", ";", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK860", ")", ")", "return", "ck860_rtx_costs", "(", "x", ",", "code", ",", "mode", ",", "outer_code", ",", "total", ",", "speed", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RTX_COSTS", ",", "to", "compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "csky" ]

[]

[ "<s>", "bool", "legitimate_constant_p", "(", "rtx", "x", ")", "{", "rtx", "inner", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "break", ";", "case", "CONST", ":", "inner", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "inner", ")", "==", "PLUS", "&&", "SPARC_SYMBOL_REF_TLS_P", "(", "XEXP", "(", "inner", ",", "0", ")", ")", ")", "return", "false", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "true", ";", "if", "(", "TARGET_VIS", "&&", "SCALAR_FLOAT_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", "&&", "const_zero_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "CONST_VECTOR", ":", "if", "(", "TARGET_VIS", "&&", "const_zero_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "return", "true", ";", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", ".", "It", "is", "given", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "ARCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_ARC_RegMask", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC" ]

[]

[ "<s>", "void", "riscv_run_selftests", "(", "void", ")", "{", "run_poly_int_selftests", "(", ")", ";", "run_const_vector_selftests", "(", ")", ";", "run_broadcast_selftests", "(", ")", ";", "}", "</s>" ]

[ "Run", "all", "target-specific", "selftests", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "ix86_expand_convert_uns_didf_sse", "(", "rtx", "target", ",", "rtx", "input", ")", "{", "REAL_VALUE_TYPE", "bias_lo_rvt", ",", "bias_hi_rvt", ";", "rtx", "int_xmm", ",", "fp_xmm", ";", "rtx", "biases", ",", "exponents", ";", "rtx", "x", ";", "int_xmm", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "if", "(", "TARGET_INTER_UNIT_MOVES_TO_VEC", ")", "emit_insn", "(", "gen_movdi_to_sse", "(", "int_xmm", ",", "input", ")", ")", ";", "else", "if", "(", "TARGET_SSE_SPLIT_REGS", ")", "{", "emit_clobber", "(", "int_xmm", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "DImode", ",", "int_xmm", ")", ",", "input", ")", ";", "}", "else", "{", "x", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "ix86_expand_vector_init_one_nonzero", "(", "false", ",", "V2DImode", ",", "x", ",", "input", ",", "0", ")", ";", "emit_move_insn", "(", "int_xmm", ",", "gen_lowpart", "(", "V4SImode", ",", "x", ")", ")", ";", "}", "x", "=", "gen_rtx_CONST_VECTOR", "(", "V4SImode", ",", "gen_rtvec", "(", "4", ",", "GEN_INT", "(", "0x43300000UL", ")", ",", "GEN_INT", "(", "0x45300000UL", ")", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "exponents", "=", "validize_mem", "(", "force_const_mem", "(", "V4SImode", ",", "x", ")", ")", ";", "emit_insn", "(", "gen_vec_interleave_lowv4si", "(", "int_xmm", ",", "int_xmm", ",", "exponents", ")", ")", ";", "fp_xmm", "=", "copy_to_mode_reg", "(", "V2DFmode", ",", "gen_lowpart", "(", "V2DFmode", ",", "int_xmm", ")", ")", ";", "real_ldexp", "(", "&", "bias_lo_rvt", ",", "&", "dconst1", ",", "52", ")", ";", "real_ldexp", "(", "&", "bias_hi_rvt", ",", "&", "dconst1", ",", "84", ")", ";", "biases", "=", "const_double_from_real_value", "(", "bias_lo_rvt", ",", "DFmode", ")", ";", "x", "=", "const_double_from_real_value", "(", "bias_hi_rvt", ",", "DFmode", ")", ";", "biases", "=", "gen_rtx_CONST_VECTOR", "(", "V2DFmode", ",", "gen_rtvec", "(", "2", ",", "biases", ",", "x", ")", ")", ";", "biases", "=", "validize_mem", "(", "force_const_mem", "(", "V2DFmode", ",", "biases", ")", ")", ";", "emit_insn", "(", "gen_subv2df3", "(", "fp_xmm", ",", "fp_xmm", ",", "biases", ")", ")", ";", "if", "(", "TARGET_SSE3", ")", "emit_insn", "(", "gen_sse3_haddv2df3", "(", "fp_xmm", ",", "fp_xmm", ",", "fp_xmm", ")", ")", ";", "else", "{", "x", "=", "copy_to_mode_reg", "(", "V2DFmode", ",", "fp_xmm", ")", ";", "emit_insn", "(", "gen_vec_interleave_highv2df", "(", "fp_xmm", ",", "fp_xmm", ",", "fp_xmm", ")", ")", ";", "emit_insn", "(", "gen_addv2df3", "(", "fp_xmm", ",", "fp_xmm", ",", "x", ")", ")", ";", "}", "ix86_expand_vector_extract", "(", "false", ",", "target", ",", "fp_xmm", ",", "0", ")", ";", "}", "</s>" ]

[ "Convert", "an", "unsigned", "DImode", "value", "into", "a", "DFmode", ",", "using", "only", "SSE", ".", "Expects", "the", "64-bit", "DImode", "to", "be", "supplied", "in", "a", "pair", "of", "integral", "registers", ".", "Requires", "SSE2", ";", "will", "use", "SSE3", "if", "available", ".", "For", "x86_32", ",", "-mfpmath=sse", ",", "!", "optimize_size", "only", "." ]

[ "i386", "0", "4", "0x43300000UL", "0x45300000UL", "52", "84", "2", "0" ]

[]

[ "<s>", "SDValue", "ARCTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "return", "{", "}", ";", "}", "</s>" ]

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

[ "ARC", "ARC" ]

[]

[ "<s>", "int", "fpuv3_const_double_rtx", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "m", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", "||", "r", ".", "cl", "==", "rvc_zero", ")", "return", "0", ";", "int", "exponent", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "bool", "fail", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mant_hi", ";", "unsigned", "HOST_WIDE_INT", "mask", ";", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "mantissa", "=", "w", ".", "elt", "(", "0", ")", ";", "mant_hi", "=", "w", ".", "elt", "(", "1", ")", ";", "exponent", "-=", "1", ";", "if", "(", "!", "IN_RANGE", "(", "exponent", ",", "-", "4", ",", "11", ")", ")", "return", "0", ";", "if", "(", "mantissa", "!=", "0", ")", "return", "0", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mantissa", "=", "mant_hi", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "9", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Check", "if", "a", "const_double", "can", "be", "used", "by", "a", "VFP", "fmovi", "instruction", "." ]

[ "csky", "0", "2", "1", "2", "0", "1", "1", "4", "11", "0", "0", "0", "1", "9", "1", "0", "0", "1" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_SystemZ", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "RetValue", ")", ";", "InVals", ".", "push_back", "(", "RetValue", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::InputArg", "16", "SystemZ", "0", "1", "0", "2", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "KindTy", "::", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"<register x\"", ";", "OS", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "KindTy", "::", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "KindTy", "::", "SystemRegister", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "RISCV", "\"<register x\"", "\">\"", "\"'\"", "\"'\"", "\"<sysreg: \"" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "G8RC", ":", "GPRC", ";", "unsigned", "Reg", "=", "findScratchRegister", "(", "II", ",", "RS", ",", "RC", ",", "SPAdj", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "Reg", ")", ";", "else", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "Reg", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitKill", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "PPC", "0", "PPC::MFCR", "PPC::MFCR", "0", "0", "PPC::CR0", "PPC::RLWINM", "PPC", "4", "0", "31", "PPC::STW", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_discover_homogeneous_aggregate", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "elt_mode", ",", "int", "*", "n_elts", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "machine_mode", "field_mode", "=", "VOIDmode", ";", "int", "field_count", "=", "rs6000_aggregate_candidate", "(", "type", ",", "&", "field_mode", ")", ";", "if", "(", "field_count", ">", "0", ")", "{", "int", "n_regs", "=", "(", "SCALAR_FLOAT_MODE_P", "(", "field_mode", ")", "?", "(", "GET_MODE_SIZE", "(", "field_mode", ")", "+", "7", ")", ">>", "3", ":", "1", ")", ";", "if", "(", "field_count", "*", "n_regs", "<=", "AGGR_ARG_NUM_REG", ")", "{", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "field_mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "field_count", ";", "return", "true", ";", "}", "}", "}", "if", "(", "elt_mode", ")", "*", "elt_mode", "=", "mode", ";", "if", "(", "n_elts", ")", "*", "n_elts", "=", "1", ";", "return", "false", ";", "}", "</s>" ]

[ "If", "an", "argument", ",", "whose", "type", "is", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "homogeneous", "float", "or", "vector", "aggregate", "that", "shall", "be", "passed", "in", "FP/vector", "registers", "according", "to", "the", "ELFv2", "ABI", ",", "return", "the", "homogeneous", "element", "mode", "in", "*", "ELT_MODE", "and", "the", "number", "of", "elements", "in", "*", "N_ELTS", ",", "and", "return", "TRUE", ".", "Otherwise", ",", "set", "*", "ELT_MODE", "to", "MODE", "and", "*", "N_ELTS", "to", "1", ",", "and", "return", "FALSE", "." ]

[ "powerpcspe", "0", "7", "3", "1", "1" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'r'", ":", "break", ";", "default", ":", "return", "true", ";", "}", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "AMDGPUInstPrinter", "::", "printRegOperand", "(", "MO", ".", "getReg", "(", ")", ",", "O", ",", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "AMDGPU", "AMDGPU", "0", "1", "0", "0", "AMDGPU" ]

[]

[ "<s>", "static", "int", "get_element_number", "(", "tree", "vec_type", ",", "tree", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "elt", ",", "max", "=", "TYPE_VECTOR_SUBPARTS", "(", "vec_type", ")", "-", "1", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "(", "elt", "=", "tree_to_uhwi", "(", "arg", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "\"selector must be an integer constant in the range 0..%wi\"", ",", "max", ")", ";", "return", "0", ";", "}", "return", "elt", ";", "}", "</s>" ]

[ "Return", "the", "integer", "constant", "in", "ARG", ".", "Constrain", "it", "to", "be", "in", "the", "range", "of", "the", "subparts", "of", "VEC_TYPE", ";", "issue", "an", "error", "if", "not", "." ]

[ "i386", "1", "\"selector must be an integer constant in the range 0..%wi\"", "0" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "canUseAsEpilogue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TmpMBB", "=", "const_cast", "<", "MachineBasicBlock", "*", ">", "(", "&", "MBB", ")", ";", "const", "auto", "*", "RVFI", "=", "MF", "->", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RVFI", "->", "useSaveRestoreLibCalls", "(", "*", "MF", ")", ")", "return", "true", ";", "if", "(", "MBB", ".", "succ_size", "(", ")", ">", "1", ")", "return", "false", ";", "MachineBasicBlock", "*", "SuccMBB", "=", "MBB", ".", "succ_empty", "(", ")", "?", "TmpMBB", "->", "getFallThrough", "(", ")", ":", "*", "MBB", ".", "succ_begin", "(", ")", ";", "if", "(", "!", "SuccMBB", ")", "return", "true", ";", "return", "SuccMBB", "->", "isReturnBlock", "(", ")", "&&", "SuccMBB", "->", "size", "(", ")", "==", "1", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "epilogue", "for", "the", "target", "." ]

[ "RI5CY", "RISCV", "RISCV", "1", "1" ]

[]

[ "<s>", "SDValue", "AGCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operation\"", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIV", ":", "return", "LowerSDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SREM", ":", "return", "LowerSREM", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "AGC", "AGC", "\"unimplemented operation\"", "ISD::MUL", "ISD::SDIV", "ISD::SREM" ]

[]

[ "<s>", "static", "bool", "alg_usable_p", "(", "enum", "stringop_alg", "alg", ",", "bool", "memset", ")", "{", "if", "(", "alg", "==", "no_stringop", ")", "return", "false", ";", "if", "(", "alg", "==", "vector_loop", ")", "return", "TARGET_SSE", "||", "TARGET_AVX", ";", "if", "(", "alg", "==", "rep_prefix_1_byte", "||", "alg", "==", "rep_prefix_4_byte", "||", "alg", "==", "rep_prefix_8_byte", ")", "return", "!", "(", "fixed_regs", "[", "CX_REG", "]", "||", "fixed_regs", "[", "DI_REG", "]", "||", "(", "memset", "?", "fixed_regs", "[", "AX_REG", "]", ":", "fixed_regs", "[", "SI_REG", "]", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ALG", "can", "be", "used", "in", "current", "context", ".", "Assume", "we", "expand", "memset", "if", "MEMSET", "is", "true", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "arc_ccfsm_cond_exec_p", "(", "void", ")", "{", "return", "(", "cfun", "->", "machine", "->", "prescan_initialized", "&&", "ARC_CCFSM_COND_EXEC_P", "(", "&", "arc_ccfsm_current", ")", ")", ";", "}", "</s>" ]

[ "During", "insn", "output", ",", "indicate", "if", "the", "current", "insn", "is", "predicated", "." ]

[ "arc" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Occupancy", "=", "ST", ".", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "AMDGPUGenRegisterInfo", "::", "getRegPressureLimit", "(", "RC", ",", "MF", ")", ";", "case", "AMDGPU", "::", "VGPR_32RegClassID", ":", "case", "AMDGPU", "::", "VGPR_LO16RegClassID", ":", "case", "AMDGPU", "::", "VGPR_HI16RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumVGPRs", "(", "Occupancy", ")", ",", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ")", ";", "case", "AMDGPU", "::", "SGPR_32RegClassID", ":", "case", "AMDGPU", "::", "SGPR_LO16RegClassID", ":", "return", "std", "::", "min", "(", "ST", ".", "getMaxNumSGPRs", "(", "Occupancy", ",", "true", ")", ",", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU::VGPR_32RegClassID", "AMDGPU::VGPR_LO16RegClassID", "AMDGPU::VGPR_HI16RegClassID", "AMDGPU::SGPR_32RegClassID", "AMDGPU::SGPR_LO16RegClassID" ]

[]

[ "<s>", "static", "void", "add_to_reg", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "value", ",", "int", "frame", ",", "int", "epilogue_p", ")", "{", "if", "(", "value", "==", "0", ")", "return", ";", "if", "(", "value", ">", "120", "||", "value", "<", "-", "120", ")", "{", "rtx", "tmpreg", ";", "rtx", "tmpreg2", ";", "rtx_insn", "*", "insn", ";", "tmpreg2", "=", "NULL_RTX", ";", "if", "(", "epilogue_p", ">=", "0", ")", "tmpreg", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_P1", ")", ";", "else", "{", "int", "i", ";", "for", "(", "i", "=", "REG_P0", ";", "i", "<=", "REG_P5", ";", "i", "++", ")", "if", "(", "(", "df_regs_ever_live_p", "(", "i", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "i", ")", ")", "||", "(", "!", "TARGET_FDPIC", "&&", "i", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "(", "crtl", "->", "uses_pic_offset_table", "||", "(", "TARGET_ID_SHARED_LIBRARY", "&&", "!", "crtl", "->", "is_leaf", ")", ")", ")", ")", "break", ";", "if", "(", "i", "<=", "REG_P5", ")", "tmpreg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "else", "{", "tmpreg", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_P1", ")", ";", "tmpreg2", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_I0", ")", ";", "emit_move_insn", "(", "tmpreg2", ",", "tmpreg", ")", ";", "}", "}", "if", "(", "frame", ")", "frame_related_constant_load", "(", "tmpreg", ",", "value", ",", "TRUE", ")", ";", "else", "insn", "=", "emit_move_insn", "(", "tmpreg", ",", "GEN_INT", "(", "value", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "tmpreg", ")", ")", ";", "if", "(", "frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "tmpreg2", "!=", "NULL_RTX", ")", "emit_move_insn", "(", "tmpreg", ",", "tmpreg2", ")", ";", "}", "else", "do", "{", "int", "size", "=", "value", ";", "rtx_insn", "*", "insn", ";", "if", "(", "size", ">", "60", ")", "size", "=", "60", ";", "else", "if", "(", "size", "<", "-", "60", ")", "size", "=", "-", "60", ";", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "if", "(", "frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "value", "-=", "size", ";", "}", "while", "(", "value", "!=", "0", ")", ";", "}", "</s>" ]

[ "Generate", "efficient", "code", "to", "add", "a", "value", "to", "a", "P", "register", ".", "Set", "RTX_FRAME_RELATED_P", "on", "the", "generated", "insns", "if", "FRAME", "is", "nonzero", ".", "EPILOGUE_P", "is", "zero", "if", "this", "function", "is", "called", "for", "prologue", ",", "otherwise", "it", "'s", "nonzero", ".", "And", "it", "'s", "less", "than", "zero", "if", "this", "is", "for", "sibcall", "epilogue", "." ]

[ "bfin", "0", "120", "120", "0", "1", "60", "60", "60", "60", "1", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_32BIT", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "else", "if", "(", "TARGET_FLOAT128", "&&", "(", "mode", "==", "KFmode", "||", "mode", "==", "IFmode", ")", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "scalar_mode_supported_p", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "isCopyInstr", "(", "const", "MachineInstr", "&", "MI", ",", "MachineOperand", "&", "Src", ",", "MachineOperand", "&", "Dest", ")", "const", "{", "bool", "isDSPControlWrite", "=", "false", ";", "if", "(", "isReadOrWritToDSPReg", "(", "MI", ",", "isDSPControlWrite", ")", ")", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "||", "!", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "(", "1", "<<", "4", ")", ")", ")", "return", "false", ";", "else", "if", "(", "isDSPControlWrite", ")", "{", "Src", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Dest", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "}", "else", "{", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "}", "return", "true", ";", "}", "else", "if", "(", "MI", ".", "isMoveReg", "(", ")", "||", "isORCopyInst", "(", "MI", ")", ")", "{", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "Mips", "Mips", "1", "1", "1", "4", "0", "2", "0", "2", "0", "1" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "poly_int64", "xstormy16_push_rounding", "(", "poly_int64", "bytes", ")", "{", "return", "(", "bytes", "+", "1", ")", "&", "~", "1", ";", "}", "</s>" ]

[ "Implement", "PUSH_ROUNDING", "." ]

[ "stormy16", "1", "1" ]

[]

[ "<s>", "static", "reg_class_t", "mips_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "mips_dangerous_for_la25_p", "(", "x", ")", "&&", "reg_class_subset_p", "(", "LEA_REGS", ",", "rclass", ")", ")", "return", "LEA_REGS", ";", "if", "(", "reg_class_subset_p", "(", "FP_REGS", ",", "rclass", ")", "&&", "mips_mode_ok_for_mov_fmt_p", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "FP_REGS", ";", "if", "(", "reg_class_subset_p", "(", "GR_REGS", ",", "rclass", ")", ")", "rclass", "=", "GR_REGS", ";", "if", "(", "TARGET_MIPS16", "&&", "reg_class_subset_p", "(", "M16_REGS", ",", "rclass", ")", ")", "rclass", "=", "M16_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "PREFERRED_RELOAD_CLASS", "." ]

[ "mips" ]

[]

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

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

[ "StackPU2", "\"StackPU2 Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "ARM", "1", "2", "4", "\"Unsupported size\"", "32" ]

[]

[ "<s>", "static", "bool", "arm_sched_can_speculate_insn", "(", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_SDIV", ":", "case", "TYPE_UDIV", ":", "case", "TYPE_FDIVS", ":", "case", "TYPE_FDIVD", ":", "case", "TYPE_FSQRTS", ":", "case", "TYPE_FSQRTD", ":", "case", "TYPE_NEON_FP_SQRT_S", ":", "case", "TYPE_NEON_FP_SQRT_D", ":", "case", "TYPE_NEON_FP_SQRT_S_Q", ":", "case", "TYPE_NEON_FP_SQRT_D_Q", ":", "case", "TYPE_NEON_FP_DIV_S", ":", "case", "TYPE_NEON_FP_DIV_D", ":", "case", "TYPE_NEON_FP_DIV_S_Q", ":", "case", "TYPE_NEON_FP_DIV_D_Q", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_CAN_SPECULATE_INSN", ".", "Return", "true", "if", "INSN", "can", "be", "scheduled", "for", "speculative", "execution", ".", "Reject", "the", "long-running", "division", "and", "square-root", "instructions", "." ]

[ "arm" ]

[]

[ "<s>", "void", "RISCVInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Res", "=", "false", ";", "const", "MCInst", "*", "NewMI", "=", "MI", ";", "MCInst", "UncompressedMI", ";", "if", "(", "PrintAliases", "&&", "!", "NoAliases", ")", "Res", "=", "uncompressInst", "(", "UncompressedMI", ",", "*", "MI", ",", "MRI", ",", "STI", ")", ";", "if", "(", "Res", ")", "NewMI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "&", "UncompressedMI", ")", ";", "if", "(", "!", "PrintAliases", "||", "NoAliases", "||", "!", "printAliasInstr", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "NewMI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "LM32RegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "LM32", "::", "RRA", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "LM32", "LM32", "LM32::RRA" ]

[]

[ "<s>", "static", "bool", "mcore_reg_ok_for_base_p", "(", "const_rtx", "reg", ",", "bool", "strict_p", ")", "{", "if", "(", "strict_p", ")", "return", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "reg", ")", ")", ";", "else", "return", "(", "REGNO", "(", "reg", ")", "<=", "16", "||", "!", "HARD_REGISTER_P", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "`", "mcore_legitimate_address_p", "'", "." ]

[ "mcore", "16" ]

[]

[ "<s>", "Register", "(", "llvm", "::", "Register", "R", ",", "unsigned", "S", ")", ":", "Reg", "(", "R", ")", ",", "Sub", "(", "S", ")", "{", "}", "</s>" ]

[ "Base", "register", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "ix86_expand_int_addcc", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "flags", ";", "rtx", "(", "*", "insn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "compare_op", ";", "rtx", "val", "=", "const0_rtx", ";", "bool", "fpcmp", "=", "false", ";", "machine_mode", "mode", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "if", "(", "operands", "[", "3", "]", "!=", "const1_rtx", "&&", "operands", "[", "3", "]", "!=", "constm1_rtx", ")", "return", "false", ";", "if", "(", "!", "ix86_expand_carry_flag_compare", "(", "code", ",", "op0", ",", "op1", ",", "&", "compare_op", ")", ")", "return", "false", ";", "code", "=", "GET_CODE", "(", "compare_op", ")", ";", "flags", "=", "XEXP", "(", "compare_op", ",", "0", ")", ";", "if", "(", "GET_MODE", "(", "flags", ")", "==", "CCFPmode", ")", "{", "fpcmp", "=", "true", ";", "code", "=", "ix86_fp_compare_code_to_integer", "(", "code", ")", ";", "}", "if", "(", "code", "!=", "LTU", ")", "{", "val", "=", "constm1_rtx", ";", "if", "(", "fpcmp", ")", "PUT_CODE", "(", "compare_op", ",", "reverse_condition_maybe_unordered", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "else", "PUT_CODE", "(", "compare_op", ",", "reverse_condition", "(", "GET_CODE", "(", "compare_op", ")", ")", ")", ";", "}", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "(", "code", "==", "LTU", ")", "==", "(", "operands", "[", "3", "]", "==", "constm1_rtx", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "insn", "=", "gen_subqi3_carry", ";", "break", ";", "case", "E_HImode", ":", "insn", "=", "gen_subhi3_carry", ";", "break", ";", "case", "E_SImode", ":", "insn", "=", "gen_subsi3_carry", ";", "break", ";", "case", "E_DImode", ":", "insn", "=", "gen_subdi3_carry", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "{", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "insn", "=", "gen_addqi3_carry", ";", "break", ";", "case", "E_HImode", ":", "insn", "=", "gen_addhi3_carry", ";", "break", ";", "case", "E_SImode", ":", "insn", "=", "gen_addsi3_carry", ";", "break", ";", "case", "E_DImode", ":", "insn", "=", "gen_adddi3_carry", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "emit_insn", "(", "insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ",", "val", ",", "flags", ",", "compare_op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "conditional", "increment", "or", "decrement", "using", "adb/sbb", "instructions", ".", "The", "default", "case", "using", "setcc", "followed", "by", "the", "conditional", "move", "can", "be", "done", "by", "generic", "code", "." ]

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

[]

[ "<s>", "void", "BT", "::", "run", "(", ")", "{", "reset", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "typedef", "GraphTraits", "<", "const", "MachineFunction", "*", ">", "MachineFlowGraphTraits", ";", "const", "MachineBasicBlock", "*", "Entry", "=", "MachineFlowGraphTraits", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "assert", "(", "I", "->", "getNumber", "(", ")", ">=", "0", "&&", "\"Disconnected block\"", ")", ";", "unsigned", "BN", "=", "I", "->", "getNumber", "(", ")", ";", "if", "(", "BN", ">", "MaxBN", ")", "MaxBN", "=", "BN", ";", "}", "BitVector", "BlockScanned", "(", "MaxBN", "+", "1", ")", ";", "int", "EntryN", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "-", "1", ",", "EntryN", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", ")", "{", "CFGEdge", "Edge", "=", "FlowQ", ".", "front", "(", ")", ";", "FlowQ", ".", "pop", "(", ")", ";", "if", "(", "EdgeExec", ".", "count", "(", "Edge", ")", ")", "continue", ";", "EdgeExec", ".", "insert", "(", "Edge", ")", ";", "const", "MachineBasicBlock", "&", "B", "=", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ";", "MachineBasicBlock", "::", "const_iterator", "It", "=", "B", ".", "begin", "(", ")", ",", "End", "=", "B", ".", "end", "(", ")", ";", "while", "(", "It", "!=", "End", "&&", "It", "->", "isPHI", "(", ")", ")", "{", "const", "MachineInstr", "&", "PI", "=", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "&", "PI", ")", ";", "visitPHI", "(", "PI", ")", ";", "}", "if", "(", "BlockScanned", "[", "Edge", ".", "second", "]", ")", "continue", ";", "BlockScanned", "[", "Edge", ".", "second", "]", "=", "true", ";", "while", "(", "It", "!=", "End", "&&", "!", "It", "->", "isBranch", "(", ")", ")", "{", "const", "MachineInstr", "&", "MI", "=", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "&", "MI", ")", ";", "visitNonBranch", "(", "MI", ")", ";", "}", "if", "(", "It", "==", "End", ")", "{", "MachineFunction", "::", "const_iterator", "BIt", "=", "B", ".", "getIterator", "(", ")", ";", "MachineFunction", "::", "const_iterator", "Next", "=", "std", "::", "next", "(", "BIt", ")", ";", "if", "(", "Next", "!=", "MF", ".", "end", "(", ")", "&&", "B", ".", "isSuccessor", "(", "&", "*", "Next", ")", ")", "{", "int", "ThisN", "=", "B", ".", "getNumber", "(", ")", ";", "int", "NextN", "=", "Next", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "ThisN", ",", "NextN", ")", ")", ";", "}", "}", "else", "{", "visitBranchesFrom", "(", "*", "It", ")", ";", "}", "}", "if", "(", "Trace", ")", "print_cells", "(", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "0", "0", "\"Disconnected block\"", "1", "1", "\"Cells after propagation:\\n\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "AMDGPUSubtarget", "::", "getWavesPerEU", "(", "const", "Function", "&", "F", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Default", "(", "1", ",", "getMaxWavesPerEU", "(", ")", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "FlatWorkGroupSizes", "=", "getFlatWorkGroupSizes", "(", "F", ")", ";", "unsigned", "MinImpliedByFlatWorkGroupSize", "=", "getMaxWavesPerEU", "(", "FlatWorkGroupSizes", ".", "second", ")", ";", "bool", "RequestedFlatWorkGroupSize", "=", "false", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-max-work-group-size\"", ")", "||", "F", ".", "hasFnAttribute", "(", "\"amdgpu-flat-work-group-size\"", ")", ")", "{", "Default", ".", "first", "=", "MinImpliedByFlatWorkGroupSize", ";", "RequestedFlatWorkGroupSize", "=", "true", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Requested", "=", "AMDGPU", "::", "getIntegerPairAttribute", "(", "F", ",", "\"amdgpu-waves-per-eu\"", ",", "Default", ",", "true", ")", ";", "if", "(", "Requested", ".", "second", "&&", "Requested", ".", "first", ">", "Requested", ".", "second", ")", "return", "Default", ";", "if", "(", "Requested", ".", "first", "<", "getMinWavesPerEU", "(", ")", "||", "Requested", ".", "first", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "Requested", ".", "second", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "RequestedFlatWorkGroupSize", "&&", "Requested", ".", "first", "<", "MinImpliedByFlatWorkGroupSize", ")", "return", "Default", ";", "return", "Requested", ";", "}", "</s>" ]

[ "Overload", "which", "uses", "the", "specified", "values", "for", "the", "flat", "work", "group", "sizes", ",", "rather", "than", "querying", "the", "function", "itself", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"amdgpu-max-work-group-size\"", "\"amdgpu-flat-work-group-size\"", "AMDGPU::getIntegerPairAttribute", "\"amdgpu-waves-per-eu\"" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unable to lower Operation\"", ")", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "ISD::BR_CC", "ISD::LOAD", "\"Unable to lower Operation\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineMemOperand", "*", "&", "MMO", ",", "int", "&", "FrameIndex", ")", "const", "{", "for", "(", "MachineInstr", "::", "mmo_iterator", "o", "=", "MI", "->", "memoperands_begin", "(", ")", ",", "oe", "=", "MI", "->", "memoperands_end", "(", ")", ";", "o", "!=", "oe", ";", "++", "o", ")", "{", "if", "(", "(", "*", "o", ")", "->", "isStore", "(", ")", "&&", "(", "*", "o", ")", "->", "getValue", "(", ")", ")", "if", "(", "const", "FixedStackPseudoSourceValue", "*", "Value", "=", "dyn_cast", "<", "const", "FixedStackPseudoSourceValue", ">", "(", "(", "*", "o", ")", "->", "getValue", "(", ")", ")", ")", "{", "FrameIndex", "=", "Value", "->", "getFrameIndex", "(", ")", ";", "MMO", "=", "*", "o", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "machine", "instruction", "has", "a", "store", "to", "a", "stack", "slot", ",", "return", "true", "along", "with", "the", "FrameIndices", "of", "the", "loaded", "stack", "slot", "and", "the", "machine", "mem", "operands", "containing", "the", "reference", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "arc_asm_output_aligned_decl_local", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "HOST_WIDE_INT", "align", ",", "unsigned", "HOST_WIDE_INT", "globalize_p", ")", "{", "int", "in_small_data", "=", "arc_in_small_data_p", "(", "decl", ")", ";", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "SYMBOL_REF_P", "(", "XEXP", "(", "mem", ",", "0", ")", ")", "&&", "arc_is_aux_reg_p", "(", "mem", ")", ")", "return", ";", "if", "(", "in_small_data", ")", "switch_to_section", "(", "get_named_section", "(", "NULL", ",", "\".sbss\"", ",", "0", ")", ")", ";", "else", "switch_to_section", "(", "bss_section", ")", ";", "if", "(", "globalize_p", ")", "(", "*", "targetm", ".", "asm_out", ".", "globalize_label", ")", "(", "stream", ",", "name", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "floor_log2", "(", "(", "align", ")", "/", "BITS_PER_UNIT", ")", ")", ";", "ASM_OUTPUT_TYPE_DIRECTIVE", "(", "stream", ",", "name", ",", "\"object\"", ")", ";", "ASM_OUTPUT_SIZE_DIRECTIVE", "(", "stream", ",", "name", ",", "size", ")", ";", "ASM_OUTPUT_LABEL", "(", "stream", ",", "name", ")", ";", "if", "(", "size", "!=", "0", ")", "ASM_OUTPUT_SKIP", "(", "stream", ",", "size", ")", ";", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_ALIGNED_DECL_LOCAL", "." ]

[ "arc", "0", "\".sbss\"", "0", "\"object\"", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "arm_expand_neon_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "!", "TARGET_NEON", ")", "{", "fatal_error", "(", "input_location", ",", "\"You must enable NEON instructions (e.g. -mfloat-abi=softfp -mfpu=neon) to use these intrinsics.\"", ")", ";", "return", "const0_rtx", ";", "}", "if", "(", "fcode", "==", "ARM_BUILTIN_NEON_LANE_CHECK", ")", "{", "tree", "nlanes", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "gcc_assert", "(", "TREE_CODE", "(", "nlanes", ")", "==", "INTEGER_CST", ")", ";", "rtx", "lane_idx", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "lane_idx", ")", ")", "neon_lane_bounds", "(", "lane_idx", ",", "0", ",", "TREE_INT_CST_LOW", "(", "nlanes", ")", ",", "exp", ")", ";", "else", "error", "(", "\"%Klane index must be a constant immediate\"", ",", "exp", ")", ";", "return", "const0_rtx", ";", "}", "neon_builtin_datum", "*", "d", "=", "&", "neon_builtin_data", "[", "fcode", "-", "ARM_BUILTIN_NEON_PATTERN_START", "]", ";", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "NEON_ARG_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "NEON_ARG_STRUCT_LOAD_STORE_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "NEON_ARG_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "NEON_ARG_CONSTANT", ":", "NEON_ARG_COPY_TO_REG", ";", "}", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_pointer", ")", "args", "[", "k", "]", "=", "NEON_ARG_MEMORY", ";", "else", "args", "[", "k", "]", "=", "NEON_ARG_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "NEON_ARG_STOP", ";", "return", "arm_expand_neon_args", "(", "target", ",", "d", "->", "mode", ",", "fcode", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Expand", "a", "Neon", "builtin", ",", "i.e", ".", "those", "registered", "only", "if", "TARGET_NEON", "holds", ".", "Most", "of", "these", "are", "``", "special", "''", "because", "they", "do", "n't", "have", "symbolic", "constants", "defined", "per-instruction", "or", "per", "instruction-variant", ".", "Instead", ",", "the", "required", "info", "is", "looked", "up", "in", "the", "table", "neon_builtin_data", "." ]

[ "arm", "\"You must enable NEON instructions (e.g. -mfloat-abi=softfp -mfpu=neon) to use these intrinsics.\"", "0", "1", "0", "\"%Klane index must be a constant immediate\"", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "hasVInstructions", "(", ")", "&&", "isa", "<", "VectorType", ">", "(", "Ty", ")", ")", "return", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "!", "AM", ".", "BaseOffs", ";", "if", "(", "!", "isInt", "<", "12", ">", "(", "AM", ".", "BaseOffs", ")", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "RISCV", "RISCV", "0", "12", "0", "1" ]

[]

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

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

[ "R600", "1" ]

[]

[ "<s>", "bool", "ARMConstantPoolMBB", "::", "hasSameValue", "(", "ARMConstantPoolValue", "*", "ACPV", ")", "{", "const", "ARMConstantPoolMBB", "*", "ACPMBB", "=", "dyn_cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", ";", "return", "ACPMBB", "&&", "ACPMBB", "->", "MBB", "==", "MBB", "&&", "ARMConstantPoolValue", "::", "hasSameValue", "(", "ACPV", ")", ";", "}", "</s>" ]

[ "hasSameValue", "-", "Return", "true", "if", "this", "ARM", "constpool", "value", "can", "share", "the", "same", "constantpool", "entry", "as", "another", "ARM", "constpool", "value", "." ]

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

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitInlineAsmEnd", "(", "const", "MCSubtargetInfo", "&", "StartInfo", ",", "const", "MCSubtargetInfo", "*", "EndInfo", ")", "const", "{", "const", "bool", "WasThumb", "=", "isThumb", "(", "StartInfo", ")", ";", "if", "(", "!", "EndInfo", "||", "WasThumb", "!=", "isThumb", "(", "*", "EndInfo", ")", ")", "{", "OutStreamer", ".", "EmitAssemblerFlag", "(", "WasThumb", "?", "MCAF_Code16", ":", "MCAF_Code32", ")", ";", "}", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "after", "emitting", "inlineasm", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "get_jump_cond", "(", "int", "n", ")", "{", "if", "(", "n", ">=", "12", ")", "return", "NULL_RTX", ";", "n", "+=", "ss", ".", "jump_cycle_index", ";", "if", "(", "n", ">=", "12", ")", "n", "-=", "12", ";", "return", "ss", ".", "jump_cond", "[", "n", "]", ";", "}", "</s>" ]

[ "Look", "up", "the", "jump", "condition", "with", "index", "N", "." ]

[ "c6x", "12", "12", "12" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "NumOps", "=", "Inst", ".", "getNumOperands", "(", ")", ";", "if", "(", "NumOps", "==", "0", ")", "return", "false", ";", "switch", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "NumOps", "-", "1", "]", ".", "OperandType", ")", "{", "case", "MCOI", "::", "OPERAND_UNKNOWN", ":", "case", "MCOI", "::", "OPERAND_IMMEDIATE", ":", "Target", "=", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "MCOI", "::", "OPERAND_PCREL", ":", "Target", "=", "Addr", "+", "Inst", ".", "getOperand", "(", "NumOps", "-", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "0", "1", "1", "1" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "const", "MachineOperand", "&", "Offset", "=", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ";", "if", "(", "Base", ".", "isReg", "(", ")", ")", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "else", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "if", "(", "Offset", ".", "isImm", "(", ")", ")", "{", "if", "(", "Offset", ".", "getImm", "(", ")", ")", "O", "<<", "\"+#\"", "<<", "Offset", ".", "getImm", "(", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Hexagon", "Hexagon", "0", "1", "\"Unimplemented\"", "\"+#\"", "\"Unimplemented\"" ]

[]

[ "<s>", "void", "arc_ccfsm_record_condition", "(", "rtx", "cond", ",", "bool", "reverse", ",", "rtx_insn", "*", "jump", ",", "struct", "arc_ccfsm", "*", "state", ")", "{", "rtx_insn", "*", "seq_insn", "=", "NEXT_INSN", "(", "PREV_INSN", "(", "jump", ")", ")", ";", "if", "(", "!", "state", ")", "state", "=", "&", "arc_ccfsm_current", ";", "gcc_assert", "(", "state", "->", "state", "==", "0", ")", ";", "if", "(", "seq_insn", "!=", "jump", ")", "{", "rtx", "insn", "=", "XVECEXP", "(", "PATTERN", "(", "seq_insn", ")", ",", "0", ",", "1", ")", ";", "if", "(", "!", "as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", "->", "deleted", "(", ")", "&&", "INSN_ANNULLED_BRANCH_P", "(", "jump", ")", "&&", "(", "TARGET_AT_DBR_CONDEXEC", "||", "INSN_FROM_TARGET_P", "(", "insn", ")", ")", ")", "{", "state", "->", "cond", "=", "cond", ";", "state", "->", "cc", "=", "get_arc_condition_code", "(", "cond", ")", ";", "if", "(", "!", "reverse", ")", "arc_ccfsm_current", ".", "cc", "=", "ARC_INVERSE_CONDITION_CODE", "(", "state", "->", "cc", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "gcc_assert", "(", "(", "INSN_FROM_TARGET_P", "(", "insn", ")", "?", "ARC_INVERSE_CONDITION_CODE", "(", "state", "->", "cc", ")", ":", "state", "->", "cc", ")", "==", "get_arc_condition_code", "(", "XEXP", "(", "pat", ",", "0", ")", ")", ")", ";", "else", "state", "->", "state", "=", "5", ";", "}", "}", "}", "</s>" ]

[ "We", "are", "considering", "a", "conditional", "branch", "with", "the", "condition", "COND", ".", "Check", "if", "we", "want", "to", "conditionalize", "a", "delay", "slot", "insn", ",", "and", "if", "so", "modify", "the", "ccfsm", "state", "accordingly", ".", "REVERSE", "says", "branch", "will", "branch", "when", "the", "condition", "is", "false", "." ]

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

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "ARM64" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "VE", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "mayBeEmittedAsTailCall", "(", "CallInst", "*", "CI", ")", "const", "{", "auto", "Attr", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "CallSite", "CS", "(", "CI", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "CS", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "IsTailCallConvention", "(", "CalleeCC", ")", "&&", "!", "IsCCallConvention", "(", "CalleeCC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "X86", "X86", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "bool", "LoongArchAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch" ]

[]

[ "<s>", "void", "BlackfinFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "BlackfinRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "BlackfinRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "BlackfinInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "BlackfinInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FrameSize", "%", "4", ")", "{", "FrameSize", "=", "(", "FrameSize", "+", "3", ")", "&", "~", "3", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "RegInfo", "->", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "return", ";", "}", "if", "(", "FrameSize", "<=", "0x3ffff", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "LINK", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "RETS", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "MOVE", ")", ",", "BF", "::", "FP", ")", ".", "addReg", "(", "BF", "::", "SP", ")", ";", "RegInfo", "->", "loadConstant", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "ADDpp", ")", ",", "BF", "::", "SP", ")", ".", "addReg", "(", "BF", "::", "SP", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "BF", "::", "P1", ",", "RegState", "::", "Kill", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "3", "3", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "0x3ffff", "BF::LINK", "BF::PUSH", "BF::RETS", "BF::PUSH", "BF::FP", "BF::MOVE", "BF::FP", "BF::SP", "BF::P1", "BF::ADDpp", "BF::SP", "BF::SP", "BF::P1" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "ArrayRef", "<", "SMRange", ">", "Ranges", "=", "ArrayRef", "<", "SMRange", ">", "(", ")", ",", "bool", "MatchingInlineAsm", "=", "false", ")", "{", "if", "(", "MatchingInlineAsm", ")", "return", "true", ";", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ",", "Ranges", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "F", ".", "hasAvailableExternallyLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "Type", "*", "Int8PtrType", "=", "Type", "::", "getInt8PtrTy", "(", "TheModule", "->", "getContext", "(", ")", ")", ";", "SetJmp3", "=", "TheModule", "->", "getOrInsertFunction", "(", "\"_setjmp3\"", ",", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", ",", "{", "Int8PtrType", ",", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", "}", ",", "true", ")", ")", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "WinEHFuncInfo", "FuncInfo", ";", "addStateStores", "(", "F", ",", "FuncInfo", ")", ";", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "UseStackGuard", "=", "false", ";", "RegNode", "=", "nullptr", ";", "EHGuardNode", "=", "nullptr", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"_setjmp3\"", "\"no-frame-pointer-elim\"", "\"true\"" ]

[]

[ "<s>", "static", "const", "struct", "mips_cpu_info", "*", "mips_cpu_info_from_isa", "(", "int", "isa", ")", "{", "const", "struct", "mips_cpu_info", "*", "p", ";", "for", "(", "p", "=", "mips_cpu_info_table", ";", "p", "->", "name", "!=", "0", ";", "p", "++", ")", "if", "(", "p", "->", "isa", "==", "isa", ")", "return", "p", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "processor", "associated", "with", "the", "given", "ISA", "level", ",", "or", "null", "if", "the", "ISA", "is", "n't", "valid", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "static", "M680x0RelType", "getType", "(", "unsigned", "Kind", ",", "MCSymbolRefExpr", "::", "VariantKind", "&", "Modifier", ",", "bool", "&", "IsPCRel", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "case", "FK_Data_4", ":", "case", "FK_PCRel_4", ":", "return", "RT_32", ";", "case", "FK_PCRel_2", ":", "case", "FK_Data_2", ":", "return", "RT_16", ";", "case", "FK_PCRel_1", ":", "case", "FK_Data_1", ":", "return", "RT_8", ";", "}", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "M680x0", "M680x0", "\"Unimplemented\"" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "WDC65816" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "M68kRegisterInfo", "::", "intRegClass", "(", "unsigned", "size", ")", "const", "{", "return", "&", "M68k", "::", "DR32RegClass", ";", "}", "</s>" ]

[ "Return", "GPR", "register", "class", "." ]

[ "M68k", "M68k", "M68k::DR32RegClass" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "WorkList", ".", "clear", "(", ")", ";", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "ValueReplacer", "Replacer", ";", "DIBuilder", "DIB", "(", "M", ",", "false", ")", ";", "for", "(", "auto", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "{", "const", "PointerType", "*", "T", "=", "AI", "->", "getType", "(", ")", ";", "unsigned", "AS", "=", "llvm", "::", "isTpcVectorType", "(", "T", "->", "getElementType", "(", ")", ")", "?", "2", ":", "1", ";", "Constant", "*", "Init", "=", "UndefValue", "::", "get", "(", "T", "->", "getElementType", "(", ")", ")", ";", "StringRef", "ainame", "=", "AI", "->", "getName", "(", ")", ";", "StringRef", "cutname", "=", "ainame", ";", "std", "::", "string", "ss", "=", "ainame", ".", "str", "(", ")", ";", "size_t", "posa", "=", "ss", ".", "find", "(", "\".\"", ")", ";", "if", "(", "posa", "!=", "std", "::", "string", "::", "npos", ")", "{", "ss", "=", "ss", ".", "substr", "(", "0", ",", "posa", ")", ";", "cutname", "=", "StringRef", "(", "ss", ")", ";", "}", "auto", "*", "GV", "=", "new", "GlobalVariable", "(", "M", ",", "T", "->", "getElementType", "(", ")", ",", "false", ",", "GlobalValue", "::", "PrivateLinkage", ",", "Init", ",", "ainame", ",", "nullptr", ",", "GlobalValue", "::", "NotThreadLocal", ",", "AS", ")", ";", "Replacer", ".", "replace", "(", "AI", ",", "GV", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC", "2", "1", "\".\"", "0" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "expandMLx", "(", ")", ")", "return", "false", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "UPTInstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "UPT", "UPT" ]

[]

[ "<s>", "void", "MOSPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createMOSNoRecursePass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "return", "false", ";", "bool", "HasRet", "=", "false", ";", "for", "(", "SDNode", "::", "use_iterator", "UI", "=", "Copy", "->", "use_begin", "(", ")", ",", "UE", "=", "Copy", "->", "use_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "if", "(", "UI", "->", "getOpcode", "(", ")", "!=", "X86ISD", "::", "RET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "X86", "X86", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ISD::FP_EXTEND", "X86ISD::RET_FLAG" ]

[]

[ "<s>", "const", "char", "*", "WebAssemblyAsmPrinter", "::", "toString", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "break", ";", "case", "MVT", "::", "f32", ":", "return", "\"f32\"", ";", "case", "MVT", "::", "f64", ":", "return", "\"f64\"", ";", "case", "MVT", "::", "i32", ":", "return", "\"i32\"", ";", "case", "MVT", "::", "i64", ":", "return", "\"i64\"", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Invalid type \"", "<<", "EVT", "(", "VT", ")", ".", "getEVTString", "(", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"invalid type\"", ")", ";", "return", "\"<invalid>\"", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "WebAssembly", "MVT::f32", "\"f32\"", "MVT::f64", "\"f64\"", "MVT::i32", "\"i32\"", "MVT::i64", "\"i64\"", "\"Invalid type \"", "\"invalid type\"", "\"<invalid>\"" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "bool", "NeedShadowCallStackProlog", "=", "false", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ",", "NeedShadowCallStackProlog", ")", ";", "auto", "EmitMI", "=", "[", "&", "]", "(", "const", "RegPairInfo", "&", "RPI", ")", "{", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "LdrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXi", ":", "AArch64", "::", "LDRXui", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDi", ":", "AArch64", "::", "LDRDui", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "printReg", "(", "Reg1", ",", "TRI", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "printReg", "(", "Reg2", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", ";", "if", "(", "ReverseCSRRestoreSeq", ")", "for", "(", "const", "RegPairInfo", "&", "RPI", ":", "reverse", "(", "RegPairs", ")", ")", "EmitMI", "(", "RPI", ")", ";", "else", "for", "(", "const", "RegPairInfo", "&", "RPI", ":", "RegPairs", ")", "EmitMI", "(", "RPI", ")", ";", "if", "(", "NeedShadowCallStackProlog", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AArch64", "::", "LDRXpre", ")", ")", ".", "addReg", "(", "AArch64", "::", "X18", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "X18", ")", ".", "addImm", "(", "-", "8", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::LDPXi", "AArch64::LDRXui", "AArch64::LDPDi", "AArch64::LDRDui", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8", "AArch64::LDRXpre", "AArch64::X18", "AArch64::LR", "AArch64::X18", "8" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "getAddressSpaceForPseudoSourceKind", "(", "unsigned", "Kind", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "PseudoSourceValue", "::", "Stack", ":", "case", "PseudoSourceValue", "::", "FixedStack", ":", "return", "ST", ".", "getAMDGPUAS", "(", ")", ".", "PRIVATE_ADDRESS", ";", "case", "PseudoSourceValue", "::", "ConstantPool", ":", "case", "PseudoSourceValue", "::", "GOT", ":", "case", "PseudoSourceValue", "::", "JumpTable", ":", "case", "PseudoSourceValue", "::", "GlobalValueCallEntry", ":", "case", "PseudoSourceValue", "::", "ExternalSymbolCallEntry", ":", "case", "PseudoSourceValue", "::", "TargetCustom", ":", "return", "ST", ".", "getAMDGPUAS", "(", ")", ".", "CONSTANT_ADDRESS", ";", "}", "return", "ST", ".", "getAMDGPUAS", "(", ")", ".", "FLAT_ADDRESS", ";", "}", "</s>" ]

[ "getAddressSpaceForPseudoSourceKind", "-", "Given", "the", "kind", "of", "memory", "(", "e.g", "." ]

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

[]

[ "<s>", "inline", "tree", "function_instance", "::", "displacement_vector_type", "(", ")", "const", "{", "return", "acle_vector_types", "[", "0", "]", "[", "mode_suffix", "(", ")", ".", "displacement_vector_type", "]", ";", "}", "</s>" ]

[ "Return", "the", "type", "of", "the", "function", "'s", "vector", "index", "or", "offset", "argument", ",", "or", "null", "if", "does", "n't", "have", "a", "vector", "index", "or", "offset", "argument", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "const", "unsigned", "DefaultSafety", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "PPC", "::", "G8RC_NOX0RegClassID", ":", "case", "PPC", "::", "GPRC_NOR0RegClassID", ":", "case", "PPC", "::", "SPERCRegClassID", ":", "case", "PPC", "::", "G8RCRegClassID", ":", "case", "PPC", "::", "GPRCRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "32", "-", "FP", "-", "DefaultSafety", ";", "}", "case", "PPC", "::", "F8RCRegClassID", ":", "case", "PPC", "::", "F4RCRegClassID", ":", "case", "PPC", "::", "VRRCRegClassID", ":", "case", "PPC", "::", "VFRCRegClassID", ":", "case", "PPC", "::", "VSLRCRegClassID", ":", "return", "32", "-", "DefaultSafety", ";", "case", "PPC", "::", "VSRCRegClassID", ":", "case", "PPC", "::", "VSFRCRegClassID", ":", "case", "PPC", "::", "VSSRCRegClassID", ":", "return", "64", "-", "DefaultSafety", ";", "case", "PPC", "::", "CRRCRegClassID", ":", "return", "8", "-", "DefaultSafety", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "PowerPC", "PPC", "PPC", "1", "0", "PPC::G8RC_NOX0RegClassID", "PPC::GPRC_NOR0RegClassID", "PPC::SPERCRegClassID", "PPC::G8RCRegClassID", "PPC::GPRCRegClassID", "1", "0", "32", "PPC::F8RCRegClassID", "PPC::F4RCRegClassID", "PPC::VRRCRegClassID", "PPC::VFRCRegClassID", "PPC::VSLRCRegClassID", "32", "PPC::VSRCRegClassID", "PPC::VSFRCRegClassID", "PPC::VSSRCRegClassID", "64", "PPC::CRRCRegClassID", "8" ]

[]

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

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

[ "LEG" ]

[]

[ "<s>", "void", "mt_expand_eh_return", "(", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "REG", "||", "REGNO", "(", "operands", "[", "0", "]", ")", "!=", "EH_RETURN_STACKADJ_REGNO", ")", "{", "rtx", "sp", "=", "EH_RETURN_STACKADJ_RTX", ";", "emit_move_insn", "(", "sp", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "sp", ";", "}", "emit_insn", "(", "gen_eh_epilogue", "(", "operands", "[", "0", "]", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "the", "``", "eh_return", "''", "pattern", "." ]

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

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getAddr", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AArch64TargetLowering::getAddr\\n\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Hi", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_PAGE", "|", "Flags", ")", ";", "SDValue", "Lo", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_PAGEOFF", "|", "AArch64II", "::", "MO_NC", "|", "Flags", ")", ";", "SDValue", "ADRP", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "ADRP", ",", "DL", ",", "Ty", ",", "Hi", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "ADDlow", ",", "DL", ",", "Ty", ",", "ADRP", ",", "Lo", ")", ";", "}", "</s>" ]

[ "Return", "the", "address", "accessed", "by", "this", "recipe", "." ]

[ "AArch64", "AArch64", "\"AArch64TargetLowering::getAddr\\n\"", "AArch64II::MO_PAGE", "AArch64II::MO_PAGEOFF", "AArch64II::MO_NC", "AArch64ISD::ADRP", "AArch64ISD::ADDlow" ]

[]

[ "<s>", "unsigned", "TPCSchedStrategy", "::", "getRegPressure", "(", "SUnit", "*", "SU", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "unsigned", "res", "=", "0", ";", "const", "llvm", "::", "MachineFunction", "&", "MF", "=", "*", "SU", "->", "getInstr", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "RegPressureTracker", "&", "TopRPTracker", "=", "DAG", "->", "getTopRPTracker", "(", ")", ";", "RegPressureTracker", "&", "RPTracker", "=", "const_cast", "<", "RegPressureTracker", "&", ">", "(", "TopRPTracker", ")", ";", "const", "int", "*", "rcps", "=", "TRI", ".", "getRegClassPressureSets", "(", "RC", ")", ";", "std", "::", "vector", "<", "unsigned", ">", "pressure", ";", "std", "::", "vector", "<", "unsigned", ">", "MaxPressure", ";", "RPTracker", ".", "getDownwardPressure", "(", "SU", "->", "getInstr", "(", ")", ",", "pressure", ",", "MaxPressure", ")", ";", "int", "j", "=", "0", ";", "while", "(", "rcps", "[", "j", "]", ">=", "0", ")", "{", "if", "(", "res", "<", "pressure", "[", "rcps", "[", "j", "]", "]", ")", "res", "=", "pressure", "[", "rcps", "[", "j", "]", "]", ";", "j", "++", ";", "}", "if", "(", "RC", "==", "&", "TPC", "::", "ADRFRegClass", ")", "{", "res", "+=", "liveInsADRF", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Get", "register", "pressure", "for", "the", "entire", "scheduling", "region", "before", "scheduling", "." ]

[ "TPC", "TPC", "0", "0", "0", "TPC::ADRFRegClass" ]

[]

[ "<s>", "int", "mmix_local_regno", "(", "int", "regno", ")", "{", "return", "regno", "<=", "MMIX_LAST_STACK_REGISTER_REGNUM", "&&", "!", "call_used_regs", "[", "regno", "]", ";", "}", "</s>" ]

[ "LOCAL_REGNO", ".", "All", "registers", "that", "are", "part", "of", "the", "register", "stack", "and", "that", "will", "be", "saved", "are", "local", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "Cpu0InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", "=", "0", ",", "ZeroReg", "=", "0", ";", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opc", "=", "Cpu0", "::", "ADD", ",", "ZeroReg", "=", "Cpu0", "::", "ZERO", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MFHI", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MFLO", ",", "SrcReg", "=", "0", ";", "else", "if", "(", "SrcReg", "==", "Cpu0", "::", "SW", ")", "Opc", "=", "Cpu0", "::", "ADD", ",", "ZeroReg", "=", "Cpu0", "::", "ZERO", ";", "}", "else", "if", "(", "Cpu0", "::", "CPURegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "DestReg", "==", "Cpu0", "::", "HI", ")", "Opc", "=", "Cpu0", "::", "MTHI", ",", "DestReg", "=", "0", ";", "else", "if", "(", "DestReg", "==", "Cpu0", "::", "LO", ")", "Opc", "=", "Cpu0", "::", "MTLO", ",", "DestReg", "=", "0", ";", "else", "if", "(", "DestReg", "==", "Cpu0", "::", "SW", ")", "Opc", "=", "Cpu0", "::", "CMP", ",", "ZeroReg", "=", "Cpu0", "::", "ZERO", ";", "}", "assert", "(", "Opc", "&&", "\"Cannot copy registers\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "DestReg", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ";", "if", "(", "ZeroReg", ")", "MIB", ".", "addReg", "(", "ZeroReg", ")", ";", "if", "(", "SrcReg", ")", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Cpu0", "Cpu0", "0", "0", "Cpu0::CPURegsRegClass", "Cpu0::CPURegsRegClass", "Cpu0::ADD", "Cpu0::ZERO", "Cpu0::HI", "Cpu0::MFHI", "0", "Cpu0::LO", "Cpu0::MFLO", "0", "Cpu0::SW", "Cpu0::ADD", "Cpu0::ZERO", "Cpu0::CPURegsRegClass", "Cpu0::HI", "Cpu0::MTHI", "0", "Cpu0::LO", "Cpu0::MTLO", "0", "Cpu0::SW", "Cpu0::CMP", "Cpu0::ZERO", "\"Cannot copy registers\"" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "NVPTX" ]

[]

[ "<s>", "static", "void", "riscv_conditional_register_usage", "(", "void", ")", "{", "if", "(", "TARGET_RVE", ")", "{", "for", "(", "int", "r", "=", "16", ";", "r", "<=", "31", ";", "r", "++", ")", "fixed_regs", "[", "r", "]", "=", "1", ";", "}", "if", "(", "riscv_abi", "==", "ABI_ILP32E", ")", "{", "for", "(", "int", "r", "=", "16", ";", "r", "<=", "31", ";", "r", "++", ")", "call_used_regs", "[", "r", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "for", "(", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "UNITS_PER_FP_ARG", "==", "0", ")", "{", "for", "(", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "call_used_regs", "[", "regno", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_VECTOR", ")", "{", "for", "(", "int", "regno", "=", "V_REG_FIRST", ";", "regno", "<=", "V_REG_LAST", ";", "regno", "++", ")", "fixed_regs", "[", "regno", "]", "=", "call_used_regs", "[", "regno", "]", "=", "1", ";", "fixed_regs", "[", "VTYPE_REGNUM", "]", "=", "call_used_regs", "[", "VTYPE_REGNUM", "]", "=", "1", ";", "fixed_regs", "[", "VL_REGNUM", "]", "=", "call_used_regs", "[", "VL_REGNUM", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_CONDITIONAL_REGISTER_USAGE", "." ]

[ "riscv", "16", "31", "1", "16", "31", "1", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "BB", "->", "getParent", "(", ")", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "PPCLowering", ".", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "PPC", "::", "GPRCRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ",", "PPC", "::", "LR", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "PPC", "::", "G8RCRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ",", "PPC", "::", "LR8", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "MVT::i32", "PPC::GPRCRegisterClass", "PPC::MovePCtoLR", "PPC::LR", "PPC::MFLR", "PPC::G8RCRegisterClass", "PPC::MovePCtoLR8", "PPC::LR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "static", "void", "symbian_add_attribute_to_class_vtable_and_rtti", "(", "tree", "ctype", ",", "const", "char", "*", "attr_name", ")", "{", "symbian_add_attribute", "(", "ctype", ",", "attr_name", ")", ";", "if", "(", "CLASSTYPE_VTABLES", "(", "ctype", ")", ")", "symbian_add_attribute", "(", "CLASSTYPE_VTABLES", "(", "ctype", ")", ",", "attr_name", ")", ";", "if", "(", "TYPE_MAIN_VARIANT", "(", "ctype", ")", "&&", "CLASSTYPE_TYPEINFO_VAR", "(", "TYPE_MAIN_VARIANT", "(", "ctype", ")", ")", ")", "symbian_add_attribute", "(", "CLASSTYPE_TYPEINFO_VAR", "(", "TYPE_MAIN_VARIANT", "(", "ctype", ")", ")", ",", "attr_name", ")", ";", "}", "</s>" ]

[ "Add", "the", "named", "attribute", "to", "a", "class", "and", "its", "vtable", "and", "rtti", "." ]

[ "sh" ]

[]

[ "<s>", "unsigned", "SparcInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "LDri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "LDXri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "LDFri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "LDDFri", "||", "MI", "->", "getOpcode", "(", ")", "==", "SP", "::", "LDQFri", ")", "{", "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", "." ]

[ "Sparc", "Sparc", "SP::LDri", "SP::LDXri", "SP::LDFri", "SP::LDDFri", "SP::LDQFri", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "Clone", "(", "FeatureBitset", "FeatureMask", ",", "Function", "*", "OrigF", ",", "Function", "*", "NewF", ")", ":", "FeatureMask", "(", "FeatureMask", ")", ",", "OrigF", "(", "OrigF", ")", ",", "NewF", "(", "NewF", ")", "{", "}", "</s>" ]

[ "Clone", "-", "Creates", "a", "clone", "of", "the", "specified", "SUnit", "." ]

[ "AMDGPU" ]

[]