Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerQuadwordSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "IsKilled", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ";", "Register", "Reg", "=", "PPC", "::", "X0", "+", "(", "SrcReg", "-", "PPC", "::", "G8p0", ")", "*", "2", ";", "bool", "IsLittleEndian", "=", "Subtarget", ".", "isLittleEndian", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STD", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsKilled", ")", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "8", ":", "0", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STD", ")", ")", ".", "addReg", "(", "Reg", "+", "1", ",", "getKillRegState", "(", "IsKilled", ")", ")", ",", "FrameIndex", ",", "IsLittleEndian", "?", "0", ":", "8", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerQuadwordSpilling", "-", "Generate", "code", "to", "spill", "paired", "general", "register", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "0", "PPC::X0", "PPC::G8p0", "2", "PPC::STD", "8", "0", "PPC::STD", "1", "0", "8" ]

[]

[ "<s>", "bool", "AArch64Subtarget", "::", "enableEarlyIfConversion", "(", ")", "const", "{", "return", "EnableEarlyIfConvert", ";", "}", "</s>" ]

[ "Enable", "the", "use", "of", "the", "early", "if", "conversion", "pass", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "TargetPassConfig", "*", "MBlazeTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "MBlazePassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "bool", "pdp11_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "aligned_p", ")", "switch", "(", "size", ")", "{", "case", "1", ":", "fprintf", "(", "asm_out_file", ",", "\"\\t.byte\\t\"", ")", ";", "output_addr_const_pdp11", "(", "asm_out_file", ",", "GEN_INT", "(", "INTVAL", "(", "x", ")", "&", "0xff", ")", ")", ";", ";", "fprintf", "(", "asm_out_file", ",", "\" /* char */\\n\"", ")", ";", "return", "true", ";", "case", "2", ":", "fprintf", "(", "asm_out_file", ",", "TARGET_UNIX_ASM", "?", "\"\\t\"", ":", "\"\\t.word\\t\"", ")", ";", "output_addr_const_pdp11", "(", "asm_out_file", ",", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "\" /* short */\\n\"", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "to", "assemble", "integer", "objects", ".", "We", "need", "to", "use", "the", "pdp-specific", "version", "of", "output_addr_const", "." ]

[ "pdp11", "1", "\"\\t.byte\\t\"", "0xff", "\" /* char */\\n\"", "2", "\"\\t\"", "\"\\t.word\\t\"", "\" /* short */\\n\"" ]

[]

[ "<s>", "static", "rtx", "safe_vector_operand", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "x", "==", "const0_rtx", ")", "x", "=", "CONST0_RTX", "(", "mode", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Errors", "in", "the", "source", "file", "can", "cause", "expand_expr", "to", "return", "const0_rtx", "where", "we", "expect", "a", "vector", ".", "To", "avoid", "crashing", ",", "use", "one", "of", "the", "vector", "clear", "instructions", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "TPCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createTPCISelDag", "(", "getTPCTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createTPCMemorySize", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "void", "arm_poke_function_name", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "unsigned", "long", "alignlength", ";", "unsigned", "long", "length", ";", "rtx", "x", ";", "length", "=", "strlen", "(", "name", ")", "+", "1", ";", "alignlength", "=", "ROUND_UP_WORD", "(", "length", ")", ";", "ASM_OUTPUT_ASCII", "(", "stream", ",", "name", ",", "length", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "2", ")", ";", "x", "=", "GEN_INT", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "0xff000000", "+", "alignlength", ")", ";", "assemble_aligned_integer", "(", "UNITS_PER_WORD", ",", "x", ")", ";", "}", "</s>" ]

[ "Write", "the", "function", "name", "into", "the", "code", "section", ",", "directly", "preceding", "the", "function", "prologue", ".", "Code", "will", "be", "output", "similar", "to", "this", ":", "t0", ".ascii", "``", "arm_poke_function_name", "''", ",", "0", ".align", "t1", ".word", "0xff000000", "+", "(", "t1", "-", "t0", ")", "arm_poke_function_name", "mov", "ip", ",", "sp", "stmfd", "sp", "!", ",", "{", "fp", ",", "ip", ",", "lr", ",", "pc", "}", "sub", "fp", ",", "ip", ",", "#", "4", "When", "performing", "a", "stack", "backtrace", ",", "code", "can", "inspect", "the", "value", "of", "'pc", "'", "stored", "at", "'fp", "'", "+", "0", ".", "If", "the", "trace", "function", "then", "looks", "at", "location", "pc", "-", "12", "and", "the", "top", "8", "bits", "are", "set", ",", "then", "we", "know", "that", "there", "is", "a", "function", "name", "embedded", "immediately", "preceding", "this", "location", "and", "has", "length", "(", "(", "pc", "[", "-3", "]", ")", "&", "0xff000000", ")", ".", "We", "assume", "that", "pc", "is", "declared", "as", "a", "pointer", "to", "an", "unsigned", "long", ".", "It", "is", "of", "no", "benefit", "to", "output", "the", "function", "name", "if", "we", "are", "assembling", "a", "leaf", "function", ".", "These", "function", "types", "will", "not", "contain", "a", "stack", "backtrace", "structure", ",", "therefore", "it", "is", "not", "possible", "to", "determine", "the", "function", "name", "." ]

[ "arm", "1", "2", "0xff000000" ]

[]

[ "<s>", "bool", "NVPTXDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "SelectDirectAddr", "(", "Op", ",", "Op0", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "return", "false", ";", "}", "if", "(", "SelectADDRri", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "NVPTX", "NVPTX", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "mips_const_vector_bitimm_set_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "op", "!=", "CONST0_RTX", "(", "mode", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "val", "=", "UINTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", ";", "int", "vlog2", "=", "exact_log2", "(", "val", "&", "GET_MODE_MASK", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ")", ";", "if", "(", "vlog2", "!=", "-", "1", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", ";", "gcc_assert", "(", "vlog2", ">=", "0", "&&", "vlog2", "<=", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", "-", "1", ")", ";", "return", "mips_const_vector_same_val_p", "(", "op", ",", "mode", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "the", "number", "of", "units", "in", "MODE", ",", "and", "each", "unit", "has", "the", "same", "bit", "set", "." ]

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

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "StoreOpcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'c'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "OS", "<<", "\"i\"", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "1", "0", "0", "1", "1", "\"i\"" ]

[]

[ "<s>", "static", "bool", "arm_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "result", ";", "if", "(", "TARGET_OLD_RTX_COSTS", "||", "(", "!", "current_tune", "->", "insn_extra_cost", "&&", "!", "TARGET_NEW_GENERIC_COSTS", ")", ")", "{", "if", "(", "!", "speed", ")", "result", "=", "arm_size_rtx_costs", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "total", ")", ";", "else", "result", "=", "current_tune", "->", "rtx_costs", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "total", ",", "speed", ")", ";", "}", "else", "{", "if", "(", "current_tune", "->", "insn_extra_cost", ")", "result", "=", "arm_new_rtx_costs", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "current_tune", "->", "insn_extra_cost", ",", "total", ",", "speed", ")", ";", "else", "result", "=", "arm_new_rtx_costs", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "&", "generic_extra_costs", ",", "total", ",", "speed", ")", ";", "}", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "total", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "RTX", "costs", "when", "optimizing", "for", "size", "." ]

[ "arm", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

[ "<s>", "static", "bool", "aarch64_takes_arguments_in_sve_regs_p", "(", "const_tree", "fntype", ")", "{", "CUMULATIVE_ARGS", "args_so_far_v", ";", "aarch64_init_cumulative_args", "(", "&", "args_so_far_v", ",", "NULL_TREE", ",", "NULL_RTX", ",", "NULL_TREE", ",", "0", ",", "true", ")", ";", "cumulative_args_t", "args_so_far", "=", "pack_cumulative_args", "(", "&", "args_so_far_v", ")", ";", "for", "(", "tree", "chain", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "chain", "&&", "chain", "!=", "void_list_node", ";", "chain", "=", "TREE_CHAIN", "(", "chain", ")", ")", "{", "tree", "arg_type", "=", "TREE_VALUE", "(", "chain", ")", ";", "if", "(", "arg_type", "==", "error_mark_node", ")", "return", "false", ";", "function_arg_info", "arg", "(", "arg_type", ",", "true", ")", ";", "apply_pass_by_reference_rules", "(", "&", "args_so_far_v", ",", "arg", ")", ";", "pure_scalable_type_info", "pst_info", ";", "if", "(", "pst_info", ".", "analyze_registers", "(", "arg", ".", "type", ")", ")", "{", "unsigned", "int", "end_zr", "=", "args_so_far_v", ".", "aapcs_nvrn", "+", "pst_info", ".", "num_zr", "(", ")", ";", "unsigned", "int", "end_pr", "=", "args_so_far_v", ".", "aapcs_nprn", "+", "pst_info", ".", "num_pr", "(", ")", ";", "gcc_assert", "(", "end_zr", "<=", "NUM_FP_ARG_REGS", "&&", "end_pr", "<=", "NUM_PR_ARG_REGS", ")", ";", "return", "true", ";", "}", "targetm", ".", "calls", ".", "function_arg_advance", "(", "args_so_far", ",", "arg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "function", "with", "type", "FNTYPE", "takes", "arguments", "in", "SVE", "vector", "or", "predicate", "registers", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "TargetPassConfig", "*", "WebAssemblyTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "WebAssemblyPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

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

[]

[ "<s>", "void", "OR1KAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "auto", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "auto", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "customEmitInstruction", "(", "&", "*", "I", "++", ")", ";", "}", "while", "(", "(", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "mmix_init_machine_status", "(", "void", ")", "{", "return", "ggc_alloc_cleared", "(", "sizeof", "(", "struct", "machine_function", ")", ")", ";", "}", "</s>" ]

[ "Set", "the", "per-function", "data", "." ]

[ "mmix" ]

[]

[ "<s>", "void", "P2AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "P2", "P2" ]

[]

[ "<s>", "void", "Cpu0MCInstLower", "::", "Initialize", "(", "MCContext", "*", "C", ")", "{", "Ctx", "=", "C", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "void", "verify_neutering_labels", "(", "basic_block", "to", ",", "rtx_insn", "*", "vector_label", ",", "rtx_insn", "*", "worker_label", ")", "{", "basic_block", "bb", "=", "to", ";", "rtx_insn", "*", "insn", "=", "BB_END", "(", "bb", ")", ";", "bool", "seen_worker_label", "=", "false", ";", "bool", "seen_vector_label", "=", "false", ";", "while", "(", "true", ")", "{", "if", "(", "insn", "==", "worker_label", ")", "{", "seen_worker_label", "=", "true", ";", "gcc_assert", "(", "!", "seen_vector_label", ")", ";", "}", "else", "if", "(", "insn", "==", "vector_label", ")", "seen_vector_label", "=", "true", ";", "else", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_nvptx_barsync", ":", "gcc_assert", "(", "!", "seen_vector_label", "&&", "!", "seen_worker_label", ")", ";", "break", ";", "}", "if", "(", "insn", "!=", "BB_HEAD", "(", "bb", ")", ")", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "else", "break", ";", "}", "gcc_assert", "(", "!", "(", "vector_label", "&&", "!", "seen_vector_label", ")", ")", ";", "gcc_assert", "(", "!", "(", "worker_label", "&&", "!", "seen_worker_label", ")", ")", ";", "}", "</s>" ]

[ "Verify", "position", "of", "VECTOR_LABEL", "and", "WORKER_LABEL", "in", "TO", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAArch64ISelDag", "(", "getAArch64TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64CleanupLocalDynamicTLSPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "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>", "bool", "LanaiTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "(", "isGlobalInSmallSectionImpl", "(", "GV", ",", "TM", ")", "&&", "(", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "optForSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "12" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "bool", "is64Bit", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "bool", "isWin64", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetWin64", "(", ")", ";", "unsigned", "SlotSize", "=", "is64Bit", "?", "8", ":", "4", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "FPReg", "=", "RI", ".", "getFrameRegister", "(", "MF", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeFrameSize", "=", "0", ";", "unsigned", "Opc", "=", "is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RegClass", "=", "CSI", "[", "i", "-", "1", "]", ".", "getRegClass", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "Reg", "==", "FPReg", ")", "continue", ";", "if", "(", "RegClass", "!=", "&", "X86", "::", "VR128RegClass", "&&", "!", "isWin64", ")", "{", "CalleeFrameSize", "+=", "SlotSize", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "else", "{", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RegClass", ")", ";", "}", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "8", "4", "X86", "X86", "X86", "0", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "1", "X86::VR128RegClass", "1", "X86" ]

[]

[ "<s>", "static", "void", "mcore_mark_dllexport", "(", "tree", "decl", ")", "{", "const", "char", "*", "oldname", ";", "char", "*", "newname", ";", "rtx", "rtlname", ";", "tree", "idp", ";", "rtlname", "=", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "rtlname", ")", "==", "MEM", ")", "rtlname", "=", "XEXP", "(", "rtlname", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rtlname", ")", "==", "SYMBOL_REF", ")", ";", "oldname", "=", "XSTR", "(", "rtlname", ",", "0", ")", ";", "if", "(", "mcore_dllexport_name_p", "(", "oldname", ")", ")", "return", ";", "newname", "=", "XALLOCAVEC", "(", "char", ",", "strlen", "(", "oldname", ")", "+", "4", ")", ";", "sprintf", "(", "newname", ",", "\"@e.%s\"", ",", "oldname", ")", ";", "idp", "=", "get_identifier", "(", "newname", ")", ";", "XEXP", "(", "DECL_RTL", "(", "decl", ")", ",", "0", ")", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "IDENTIFIER_POINTER", "(", "idp", ")", ")", ";", "}", "</s>" ]

[ "Mark", "a", "DECL", "as", "being", "dllexport", "'d", "." ]

[ "mcore", "0", "0", "0", "4", "\"@e.%s\"", "0" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "SDWADstPreserveOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "OS", "<<", "\"SDWA preserve dst: \"", "<<", "*", "getTargetOperand", "(", ")", "<<", "\" dst_sel:\"", "<<", "getDstSel", "(", ")", "<<", "\" preserve:\"", "<<", "*", "getPreservedOperand", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SDWA preserve dst: \"", "\" dst_sel:\"", "\" preserve:\"" ]

[]

[ "<s>", "const", "Nios2MCExpr", "*", "Nios2MCExpr", "::", "create", "(", "const", "MCSymbol", "*", "Symbol", ",", "Nios2MCExpr", "::", "Nios2ExprKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "const", "MCSymbolRefExpr", "*", "MCSym", "=", "MCSymbolRefExpr", "::", "create", "(", "Symbol", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "Ctx", ")", ";", "return", "new", "(", "Ctx", ")", "Nios2MCExpr", "(", "Kind", ",", "MCSym", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "Nios2", "Nios2", "Nios2", "Nios2" ]

[]

[ "<s>", "void", "XCorePassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createXCoreFrameToArgsOffsetEliminationPass", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "getHashValue", "(", "const", "MemOpKey", "&", "Val", ")", "{", "assert", "(", "Val", ".", "Disp", "!=", "PtrInfo", "::", "getEmptyKey", "(", ")", "&&", "\"Cannot hash the empty key\"", ")", ";", "assert", "(", "Val", ".", "Disp", "!=", "PtrInfo", "::", "getTombstoneKey", "(", ")", "&&", "\"Cannot hash the tombstone key\"", ")", ";", "hash_code", "Hash", "=", "hash_combine", "(", "*", "Val", ".", "Operands", "[", "0", "]", ",", "*", "Val", ".", "Operands", "[", "1", "]", ",", "*", "Val", ".", "Operands", "[", "2", "]", ",", "*", "Val", ".", "Operands", "[", "3", "]", ")", ";", "switch", "(", "Val", ".", "Disp", "->", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "Hash", "=", "hash_combine", "(", "Hash", ",", "Val", ".", "Disp", "->", "getIndex", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "Hash", "=", "hash_combine", "(", "Hash", ",", "Val", ".", "Disp", "->", "getSymbolName", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "Hash", "=", "hash_combine", "(", "Hash", ",", "Val", ".", "Disp", "->", "getGlobal", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "Hash", "=", "hash_combine", "(", "Hash", ",", "Val", ".", "Disp", "->", "getBlockAddress", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "Hash", "=", "hash_combine", "(", "Hash", ",", "Val", ".", "Disp", "->", "getMCSymbol", "(", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid address displacement operand\"", ")", ";", "}", "return", "(", "unsigned", ")", "Hash", ";", "}", "</s>" ]

[ "Using", "name", "and", "line", "to", "get", "hash", "value", ".", "It", "should", "already", "be", "mostly", "unique", "." ]

[ "X86", "\"Cannot hash the empty key\"", "\"Cannot hash the tombstone key\"", "0", "1", "2", "3", "\"Invalid address displacement operand\"" ]

[]

[ "<s>", "MachineInstr", "*", "HexagonInstrInfo", "::", "findLoopInstr", "(", "MachineBasicBlock", "*", "BB", ",", "unsigned", "EndLoopOp", ",", "MachineBasicBlock", "*", "TargetBB", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "&", "Visited", ")", "const", "{", "unsigned", "LOOPi", ";", "unsigned", "LOOPr", ";", "if", "(", "EndLoopOp", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop0i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop0r", ";", "}", "else", "{", "LOOPi", "=", "Hexagon", "::", "J2_loop1i", ";", "LOOPr", "=", "Hexagon", "::", "J2_loop1r", ";", "}", "for", "(", "MachineBasicBlock", "*", "PB", ":", "BB", "->", "predecessors", "(", ")", ")", "{", "if", "(", "!", "Visited", ".", "insert", "(", "PB", ")", ".", "second", ")", "continue", ";", "if", "(", "PB", "==", "BB", ")", "continue", ";", "for", "(", "auto", "I", "=", "PB", "->", "instr_rbegin", "(", ")", ",", "E", "=", "PB", "->", "instr_rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "LOOPi", "||", "Opc", "==", "LOOPr", ")", "return", "&", "*", "I", ";", "if", "(", "Opc", "==", "EndLoopOp", "&&", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", "!=", "TargetBB", ")", "return", "nullptr", ";", "}", "if", "(", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "PB", ",", "EndLoopOp", ",", "TargetBB", ",", "Visited", ")", ")", "return", "Loop", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Find", "the", "hardware", "loop", "instruction", "used", "to", "set-up", "the", "specified", "loop", "." ]

[ "Hexagon", "Hexagon", "8", "Hexagon::ENDLOOP0", "Hexagon::J2_loop0i", "Hexagon::J2_loop0r", "Hexagon::J2_loop1i", "Hexagon::J2_loop1r", "0" ]

[]

[ "<s>", "static", "void", "mips_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "rtx", "this_rtx", ",", "temp1", ",", "temp2", ",", "fnaddr", ";", "rtx_insn", "*", "insn", ";", "bool", "use_sibcall_p", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "use_sibcall_p", "=", "(", "mips_function_ok_for_sibcall", "(", "function", ",", "NULL", ")", "&&", "const_call_insn_operand", "(", "fnaddr", ",", "Pmode", ")", ")", ";", "if", "(", "!", "use_sibcall_p", "&&", "(", "mips_got_symbol_type_p", "(", "mips_classify_symbol", "(", "fnaddr", ",", "SYMBOL_CONTEXT_LEA", ")", ")", ")", ")", "{", "cfun", "->", "machine", "->", "global_pointer", "=", "TARGET_CALL_SAVED_GP", "?", "15", ":", "GLOBAL_POINTER_REGNUM", ";", "cfun", "->", "machine", "->", "must_initialize_gp_p", "=", "true", ";", "SET_REGNO", "(", "pic_offset_table_rtx", ",", "cfun", "->", "machine", "->", "global_pointer", ")", ";", "mips_emit_loadgp", "(", ")", ";", "}", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "temp2", "=", "gen_rtx_REG", "(", "Pmode", ",", "3", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", "+", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "delta", "!=", "0", ")", "{", "rtx", "offset", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "delta", ")", ")", "{", "mips_emit_move", "(", "temp1", ",", "offset", ")", ";", "offset", "=", "temp1", ";", "}", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "offset", ")", ")", ";", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "rtx", "addr", ";", "mips_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "addr", "=", "mips_add_offset", "(", "temp2", ",", "temp1", ",", "vcall_offset", ")", ";", "mips_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "use_sibcall_p", ")", "{", "insn", "=", "emit_call_insn", "(", "gen_sibcall_internal", "(", "fnaddr", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "if", "(", "TARGET_USE_PIC_FN_ADDR_REG", "&&", "!", "TARGET_MIPS16", "&&", "!", "mips_dangerous_for_la25_p", "(", "fnaddr", ")", ")", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "mips_load_call_address", "(", "MIPS_CALL_SIBCALL", ",", "temp1", ",", "fnaddr", ")", ";", "if", "(", "TARGET_USE_PIC_FN_ADDR_REG", "&&", "REGNO", "(", "temp1", ")", "!=", "PIC_FUNCTION_ADDR_REGNUM", ")", "mips_emit_move", "(", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ",", "temp1", ")", ";", "emit_jump_insn", "(", "gen_indirect_jump", "(", "temp1", ")", ")", ";", "}", "insn", "=", "get_insns", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "mips16_lay_out_constants", "(", "true", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Generate", "rtl", "rather", "than", "asm", "text", "in", "order", "to", "avoid", "duplicating", "too", "much", "logic", "from", "elsewhere", "." ]

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

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "getMipsRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULW", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "USW", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULH", "||", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "ULHu", ")", "emitGlobalAddressUnaligned", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "4", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "USH", ")", "emitGlobalAddressUnaligned", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "8", ")", ";", "else", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "true", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Mips", "Mips", "Mips", "Mips::ULW", "Mips::USW", "Mips::ULH", "Mips::ULHu", "4", "Mips::USH", "8", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "bool", "ARM64FrameLowering", "::", "canUseRedZone", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "EnableRedZone", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "ARM64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARM64FunctionInfo", ">", "(", ")", ";", "unsigned", "NumBytes", "=", "AFI", "->", "getLocalStackSize", "(", ")", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", "||", "hasFP", "(", "MF", ")", "||", "NumBytes", ">", "128", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Can", "this", "function", "use", "the", "red", "zone", "for", "local", "allocations", "." ]

[ "ARM64", "ARM64", "ARM64", "ARM64", "128" ]

[]

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

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

[ "Lanai" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedScatter", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "ST", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "return", "isLegalMaskedGather", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "scatter", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "TLCS900FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "TLCS900", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "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", "(", ")", "." ]

[ "TLCS900", "TLCS900", "0", "TLCS900::POP16r" ]

[]

[ "<s>", "void", "loongarch_split_move_insn", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "insn", ")", "{", "loongarch_split_move", "(", "dest", ",", "src", ",", "insn", ")", ";", "}", "</s>" ]

[ "Split", "a", "move", "from", "SRC", "to", "DEST", "in", "INSN", ",", "given", "that", "loongarch_split_move_insn_p", "holds", "." ]

[ "loongarch" ]

[]

[ "<s>", "int", "mips_split_const_insns", "(", "rtx", "x", ")", "{", "unsigned", "int", "low", ",", "high", ";", "low", "=", "mips_const_insns", "(", "mips_subword", "(", "x", ",", "false", ")", ")", ";", "high", "=", "mips_const_insns", "(", "mips_subword", "(", "x", ",", "true", ")", ")", ";", "gcc_assert", "(", "low", ">", "0", "&&", "high", ">", "0", ")", ";", "return", "low", "+", "high", ";", "}", "</s>" ]

[ "X", "is", "a", "doubleword", "constant", "that", "can", "be", "handled", "by", "splitting", "it", "into", "two", "words", "and", "loading", "each", "word", "separately", ".", "Return", "the", "number", "of", "instructions", "required", "to", "do", "this", ",", "assuming", "that", "BASE_INSN_LENGTH", "is", "the", "length", "of", "one", "instruction", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_simd_decl_p", "(", "tree", "fndecl", ")", "{", "tree", "fntype", ";", "if", "(", "fndecl", "==", "NULL", ")", "return", "false", ";", "fntype", "=", "TREE_TYPE", "(", "fndecl", ")", ";", "if", "(", "fntype", "==", "NULL", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"aarch64_vector_pcs\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", "!=", "NULL", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "definition", "of", "a", "vectorized", "simd", "function", "." ]

[ "aarch64", "\"aarch64_vector_pcs\"" ]

[]

[ "<s>", "static", "void", "block_move_sequence", "(", "rtx", "dst_mem", ",", "rtx", "src_mem", ",", "int", "size", ",", "int", "align", ")", "{", "rtx", "temp", "[", "2", "]", ";", "enum", "machine_mode", "mode", "[", "2", "]", ";", "int", "amount", "[", "2", "]", ";", "bool", "active", "[", "2", "]", ";", "int", "phase", "=", "0", ";", "int", "next", ";", "int", "offset_ld", "=", "0", ";", "int", "offset_st", "=", "0", ";", "rtx", "x", ";", "x", "=", "XEXP", "(", "dst_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "dst_mem", "=", "replace_equiv_address", "(", "dst_mem", ",", "x", ")", ";", "}", "x", "=", "XEXP", "(", "src_mem", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "{", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "src_mem", "=", "replace_equiv_address", "(", "src_mem", ",", "x", ")", ";", "}", "active", "[", "0", "]", "=", "active", "[", "1", "]", "=", "false", ";", "do", "{", "next", "=", "phase", ";", "phase", "^=", "1", ";", "if", "(", "size", ">", "0", ")", "{", "int", "next_amount", ";", "next_amount", "=", "(", "size", ">=", "4", "?", "4", ":", "(", "size", ">=", "2", "?", "2", ":", "1", ")", ")", ";", "next_amount", "=", "MIN", "(", "next_amount", ",", "align", ")", ";", "amount", "[", "next", "]", "=", "next_amount", ";", "mode", "[", "next", "]", "=", "mode_from_align", "[", "next_amount", "]", ";", "temp", "[", "next", "]", "=", "gen_reg_rtx", "(", "mode", "[", "next", "]", ")", ";", "x", "=", "adjust_address", "(", "src_mem", ",", "mode", "[", "next", "]", ",", "offset_ld", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", "[", "next", "]", ",", "x", ")", ")", ";", "offset_ld", "+=", "next_amount", ";", "size", "-=", "next_amount", ";", "active", "[", "next", "]", "=", "true", ";", "}", "if", "(", "active", "[", "phase", "]", ")", "{", "active", "[", "phase", "]", "=", "false", ";", "x", "=", "adjust_address", "(", "dst_mem", ",", "mode", "[", "phase", "]", ",", "offset_st", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "temp", "[", "phase", "]", ")", ")", ";", "offset_st", "+=", "amount", "[", "phase", "]", ";", "}", "}", "while", "(", "active", "[", "next", "]", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "perform", "a", "block", "move", "with", "an", "offset", "sequence", "of", "ld/st", "instructions", "(", "...", ",", "ld", "0", ",", "st", "1", ",", "ld", "1", ",", "st", "0", ",", "...", ")", ".", "SIZE", "and", "ALIGN", "are", "known", "constants", ".", "DEST", "and", "SRC", "are", "registers", ".", "OFFSET", "is", "the", "known", "starting", "point", "for", "the", "output", "pattern", "." ]

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

[]

[ "<s>", "static", "bool", "riscv_slow_unaligned_access", "(", "machine_mode", ",", "unsigned", "int", ")", "{", "return", "riscv_slow_unaligned_access_p", ";", "}", "</s>" ]

[ "Implement", "TARGET_SLOW_UNALIGNED_ACCESS", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"X86 branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "bool", "FallThru", "=", "FBB", "==", "nullptr", ";", "unsigned", "Count", "=", "0", ";", "X86", "::", "CondCode", "CC", "=", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "X86", "::", "COND_NE_OR_P", ":", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "X86", "::", "COND_NE", ")", ";", "++", "Count", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "X86", "::", "COND_P", ")", ";", "++", "Count", ";", "break", ";", "case", "X86", "::", "COND_E_AND_NP", ":", "if", "(", "FBB", "==", "nullptr", ")", "{", "FBB", "=", "getFallThroughMBB", "(", "&", "MBB", ",", "TBB", ")", ";", "assert", "(", "FBB", "&&", "\"MBB cannot be the last block in function when the false \"", "\"body is a fall-through.\"", ")", ";", "}", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "FBB", ")", ".", "addImm", "(", "X86", "::", "COND_NE", ")", ";", "++", "Count", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "X86", "::", "COND_NP", ")", ";", "++", "Count", ";", "break", ";", "default", ":", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JCC_1", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "CC", ")", ";", "++", "Count", ";", "}", "}", "if", "(", "!", "FallThru", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "X86", "::", "JMP_1", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "X86", "X86", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"X86 branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "X86::JMP_1", "1", "0", "X86::CondCode", "X86::CondCode", "0", "X86::COND_NE_OR_P", "X86::JCC_1", "X86::COND_NE", "X86::JCC_1", "X86::COND_P", "X86::COND_E_AND_NP", "\"MBB cannot be the last block in function when the false \"", "\"body is a fall-through.\"", "X86::JCC_1", "X86::COND_NE", "X86::JCC_1", "X86::COND_NP", "X86::JCC_1", "X86::JMP_1" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_Immediate", ":", "OS", "<<", "\"Imm<\"", ";", "Imm", ".", "Val", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_Memory", ":", "OS", "<<", "\"Mem<\"", ";", "Mem", ".", "Base", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", \"", ";", "Mem", ".", "Off", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\">\"", ";", "break", ";", "case", "k_PhysRegister", ":", "OS", "<<", "\"PhysReg<\"", "<<", "PhysReg", ".", "Num", "<<", "\">\"", ";", "break", ";", "case", "k_RegisterIndex", ":", "OS", "<<", "\"RegIdx<\"", "<<", "RegIdx", ".", "Index", "<<", "\":\"", "<<", "RegIdx", ".", "Kind", "<<", "\">\"", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "Tok", ".", "Data", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Mips", "\"Imm<\"", "\">\"", "\"Mem<\"", "\", \"", "\">\"", "\"PhysReg<\"", "\">\"", "\"RegIdx<\"", "\":\"", "\">\"" ]

[]

[ "<s>", "CUMULATIVE_ARGS", "xstormy16_function_arg_advance", "(", "CUMULATIVE_ARGS", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "cum", "<", "NUM_ARGUMENT_REGISTERS", "&&", "cum", "+", "XSTORMY16_WORD_SIZE", "(", "type", ",", "mode", ")", ">", "NUM_ARGUMENT_REGISTERS", ")", "cum", "=", "NUM_ARGUMENT_REGISTERS", ";", "cum", "+=", "XSTORMY16_WORD_SIZE", "(", "type", ",", "mode", ")", ";", "return", "cum", ";", "}", "</s>" ]

[ "Update", "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", "`", "TARGET_FUNCTION_ARG", "'", ",", "etc", ".", "This", "function", "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", ".", "However", ",", "it", "makes", "life", "easier", "for", "xstormy16_build_va_list", "if", "it", "does", "update", "the", "word", "count", "." ]

[ "stormy16" ]

[]

[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "XCoreGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32-f64:32-a:0:32-n32\"", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "DL", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "nds32_expand_prologue_v3push", "(", "void", ")", "{", "int", "fp_adjust", ";", "int", "sp_adjust", ";", "int", "fpr_space", "=", "0", ";", "unsigned", "Rb", ",", "Re", ";", "nds32_compute_stack_frame", "(", ")", ";", "if", "(", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", ">", "0", ")", "df_set_regs_ever_live", "(", "FP_REGNUM", ",", "1", ")", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", ")", "return", ";", "Rb", "=", "cfun", "->", "machine", "->", "callee_saved_first_gpr_regno", ";", "Re", "=", "cfun", "->", "machine", "->", "callee_saved_last_gpr_regno", ";", "sp_adjust", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "if", "(", "satisfies_constraint_Iu08", "(", "GEN_INT", "(", "sp_adjust", ")", ")", "&&", "NDS32_DOUBLE_WORD_ALIGN_P", "(", "sp_adjust", ")", ")", "{", "nds32_emit_stack_v3push", "(", "Rb", ",", "Re", ",", "sp_adjust", ")", ";", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "int", "fpr_position", "=", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", ";", "nds32_emit_push_fpr_callee_saved", "(", "fpr_position", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "fp_adjust", "=", "cfun", "->", "machine", "->", "fp_size", "+", "cfun", "->", "machine", "->", "gp_size", "+", "cfun", "->", "machine", "->", "lp_size", "+", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", "+", "sp_adjust", ";", "nds32_emit_adjust_frame", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "fp_adjust", ")", ";", "}", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "fpr_space", "=", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", ";", "nds32_emit_stack_v3push", "(", "Rb", ",", "Re", ",", "fpr_space", ")", ";", "nds32_emit_push_fpr_callee_saved", "(", "0", ")", ";", "}", "else", "{", "nds32_emit_stack_v3push", "(", "Rb", ",", "Re", ",", "0", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "fp_adjust", "=", "cfun", "->", "machine", "->", "fp_size", "+", "cfun", "->", "machine", "->", "gp_size", "+", "cfun", "->", "machine", "->", "lp_size", "+", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", ";", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "fp_adjust", "=", "fp_adjust", "+", "fpr_space", ";", "}", "nds32_emit_adjust_frame", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "fp_adjust", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "callee_saved_first_fpr_regno", "!=", "SP_REGNUM", ")", "{", "sp_adjust", "=", "sp_adjust", "-", "fpr_space", ";", "}", "nds32_emit_adjust_frame", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "-", "1", "*", "sp_adjust", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Function", "for", "v3push", "prologue", "." ]

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

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "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>", "int", "TL45FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", "+", "MFI", ".", "getOffsetAdjustment", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "0", ";", "else", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "return", "Offset", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "0" ]

[]

[ "<s>", "static", "int", "mcore_ior_cost", "(", "rtx", "x", ")", "{", "HOST_WIDE_INT", "val", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "2", ";", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "CONST_OK_FOR_M", "(", "val", ")", ")", "return", "2", ";", "else", "if", "(", "const_ok_for_mcore", "(", "val", ")", ")", "return", "3", ";", "else", "if", "(", "TARGET_HARDLIT", "&&", "mcore_const_ok_for_inline", "(", "val", ")", ")", "return", "4", ";", "return", "5", ";", "}", "</s>" ]

[ "What", "does", "an", "or", "cost", "-", "see", "and_cost", "(", ")", "." ]

[ "mcore", "1", "2", "1", "2", "3", "4", "5" ]

[]

[ "<s>", "static", "int", "ck801_legitimate_index_p", "(", "machine_mode", "mode", ",", "rtx", "index", ",", "int", "strict_p", "ATTRIBUTE_UNUSED", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "index", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "8", ")", "return", "(", "code", "==", "CONST_INT", "&&", "INTVAL", "(", "index", ")", "<", "CSKY_LD16_MAX_OFFSET", "(", "SImode", ")", "&&", "INTVAL", "(", "index", ")", ">=", "0", "&&", "(", "INTVAL", "(", "index", ")", "&", "3", ")", "==", "0", ")", ";", "if", "(", "code", "==", "CONST_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "0", "&&", "INTVAL", "(", "index", ")", "<=", "CSKY_LD16_MAX_OFFSET", "(", "mode", ")", "&&", "INTVAL", "(", "index", ")", ">=", "0", ")", "return", "(", "(", "INTVAL", "(", "index", ")", "%", "GET_MODE_SIZE", "(", "mode", ")", ")", "==", "0", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "INDEX", "is", "valid", "for", "an", "address", "index", "operand", ".", "ck801", "use", "16", "bits", "ld", "ck802", "use", "16", "and", "32", "bits", "ld", "others", "use", "ld", "and", "ldr", "." ]

[ "csky", "8", "0", "3", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "int", "pass_vsetvl", "::", "execute", "(", "function", "*", ")", "{", "if", "(", "n_basic_blocks_for_fn", "(", "cfun", ")", "<=", "0", ")", "return", "0", ";", "split_all_insns", "(", ")", ";", "if", "(", "!", "has_vector_insn", "(", "cfun", ")", ")", "return", "0", ";", "init", "(", ")", ";", "if", "(", "!", "optimize", ")", "simple_vsetvl", "(", ")", ";", "else", "lazy_vsetvl", "(", ")", ";", "done", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "riscv", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "ix86_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "SUBTARGET_RETURN_IN_MEMORY", "(", "type", ",", "fntype", ")", ";", "const", "machine_mode", "mode", "=", "type_natural_mode", "(", "type", ",", "NULL", ",", "true", ")", ";", "HOST_WIDE_INT", "size", ";", "if", "(", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "return", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "ix86_function_type_abi", "(", "fntype", ")", "==", "MS_ABI", ")", "{", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "(", "!", "type", "||", "VECTOR_INTEGER_TYPE_P", "(", "type", ")", "||", "INTEGRAL_TYPE_P", "(", "type", ")", "||", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", "&&", "(", "SCALAR_INT_MODE_P", "(", "mode", ")", "||", "VECTOR_MODE_P", "(", "mode", ")", ")", "&&", "!", "COMPLEX_MODE_P", "(", "mode", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", "||", "size", "==", "16", ")", ")", "return", "false", ";", "return", "size", "!=", "1", "&&", "size", "!=", "2", "&&", "size", "!=", "4", "&&", "size", "!=", "8", ";", "}", "else", "{", "int", "needed_intregs", ",", "needed_sseregs", ";", "return", "examine_argument", "(", "mode", ",", "type", ",", "1", ",", "&", "needed_intregs", ",", "&", "needed_sseregs", ")", ";", "}", "}", "else", "{", "if", "(", "mode", "==", "BLKmode", ")", "return", "true", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "MS_AGGREGATE_RETURN", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "size", "<=", "8", ")", "return", "false", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "||", "mode", "==", "TImode", ")", "{", "if", "(", "size", "<", "8", ")", "return", "false", ";", "if", "(", "size", "==", "8", ")", "return", "TARGET_VECT8_RETURNS", "||", "!", "TARGET_MMX", ";", "if", "(", "size", "==", "16", ")", "return", "!", "TARGET_SSE", ";", "if", "(", "size", "==", "32", ")", "return", "!", "TARGET_AVX", ";", "if", "(", "size", "==", "64", ")", "return", "!", "TARGET_AVX512F", ";", "}", "if", "(", "mode", "==", "XFmode", ")", "return", "false", ";", "if", "(", "size", ">", "12", ")", "return", "true", ";", "gcc_assert", "(", "mode", "!=", "OImode", ")", ";", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "false", "iff", "type", "is", "returned", "in", "memory", "." ]

[ "i386", "16", "16", "1", "2", "4", "8", "1", "8", "8", "8", "16", "32", "64", "12" ]

[]

[ "<s>", "static", "bool", "ix86_ifunc_ref_local_ok", "(", "void", ")", "{", "return", "!", "flag_pic", "||", "(", "TARGET_64BIT", "&&", "ix86_cmodel", "!=", "CM_LARGE_PIC", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_IFUNC_REF_LOCAL_OK", ".", "If", "this", "hook", "returns", "true", ",", "the", "PLT", "entry", "will", "be", "used", "as", "the", "function", "address", "for", "local", "IFUNC", "functions", ".", "When", "the", "PIC", "register", "is", "needed", "for", "PLT", "call", ",", "indirect", "call", "via", "the", "PLT", "entry", "will", "fail", "since", "the", "PIC", "register", "may", "not", "be", "set", "up", "properly", "for", "indirect", "call", ".", "In", "this", "case", ",", "we", "should", "return", "false", "." ]

[ "i386" ]

[]

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

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

[ "Sparc" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "XZR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "{", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "}", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isX18Reserved", "(", ")", ")", "{", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "X18", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W18", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "X19", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "}", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::SP", "AArch64::XZR", "AArch64::WSP", "AArch64::WZR", "AArch64::FP", "AArch64::W29", "AArch64", "AArch64::X18", "AArch64::W18", "AArch64::X19", "AArch64::W19" ]

[]

[ "<s>", "void", "m32c_expand_neg_mulpsi3", "(", "rtx", "*", "operands", ")", "{", "rtx", "temp1", ";", "rtx", "scale", ";", "rtx", "temp2", ";", "temp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "temp2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "scale", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_zero_extendpsisi2", "(", "scale", ",", "operands", "[", "2", "]", ")", ")", ";", "}", "else", "scale", "=", "copy_to_mode_reg", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "emit_insn", "(", "gen_zero_extendpsisi2", "(", "temp1", ",", "operands", "[", "1", "]", ")", ")", ";", "temp2", "=", "expand_simple_binop", "(", "SImode", ",", "MULT", ",", "temp1", ",", "scale", ",", "temp2", ",", "1", ",", "OPTAB_LIB", ")", ";", "emit_insn", "(", "gen_truncsipsi2", "(", "operands", "[", "0", "]", ",", "temp2", ")", ")", ";", "}", "</s>" ]

[ "The", "m32c", "has", "a", "limited", "range", "of", "operations", "that", "work", "on", "PSImode", "values", ";", "we", "have", "to", "expand", "to", "SI", ",", "do", "the", "math", ",", "and", "truncate", "back", "to", "PSI", ".", "Yes", ",", "this", "is", "expensive", ",", "but", "hopefully", "gcc", "will", "learn", "to", "avoid", "those", "cases", "." ]

[ "m32c", "2", "2", "2", "1", "1", "0" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "MachineOperand", "&", "Callee", ",", "const", "ArgInfo", "&", "OrigRet", ",", "ArrayRef", "<", "ArgInfo", ">", "OrigArgs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "auto", "&", "OrigArg", ":", "OrigArgs", ")", "{", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildExtract", "(", "Regs", ",", "Offsets", ",", "OrigArg", ".", "Reg", ")", ";", "}", ")", ";", "}", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "CallAssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Callee", ".", "isReg", "(", ")", "?", "AArch64", "::", "BLR", ":", "AArch64", "::", "BL", ")", ";", "MIB", ".", "addOperand", "(", "Callee", ")", ";", "auto", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "F", ".", "getCallingConv", "(", ")", ")", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "PhysRegs", ";", "OutgoingArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "CallAssignFn", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "if", "(", "Callee", ".", "isReg", "(", ")", ")", "MIB", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "constrainOperandRegClass", "(", "MF", ",", "*", "TRI", ",", "MRI", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegBankInfo", "(", ")", ",", "*", "MIB", ",", "MIB", "->", "getDesc", "(", ")", ",", "Callee", ".", "getReg", "(", ")", ",", "0", ")", ")", ";", "CCAssignFn", "*", "RetAssignFn", "=", "TLI", ".", "CCAssignFnForReturn", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "if", "(", "OrigRet", ".", "Reg", ")", "{", "SplitArgs", ".", "clear", "(", ")", ";", "SmallVector", "<", "uint64_t", ",", "8", ">", "RegOffsets", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "SplitRegs", ";", "splitToValueTypes", "(", "OrigRet", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "std", "::", "copy", "(", "Offsets", ".", "begin", "(", ")", ",", "Offsets", ".", "end", "(", ")", ",", "std", "::", "back_inserter", "(", "RegOffsets", ")", ")", ";", "std", "::", "copy", "(", "Regs", ".", "begin", "(", ")", ",", "Regs", ".", "end", "(", ")", ",", "std", "::", "back_inserter", "(", "SplitRegs", ")", ")", ";", "}", ")", ";", "CallReturnHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "RetAssignFn", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "if", "(", "!", "RegOffsets", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "buildSequence", "(", "OrigRet", ".", "Reg", ",", "SplitRegs", ",", "RegOffsets", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "AArch64", "AArch64", "8", "AArch64", "AArch64", "AArch64::BLR", "AArch64::BL", "8", "0", "0", "8", "8" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "dag", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "Available", "[", "IDAlu", "]", "->", "clear", "(", ")", ";", "Available", "[", "IDFetch", "]", "->", "clear", "(", ")", ";", "Available", "[", "IDOther", "]", "->", "clear", "(", ")", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupedSlotsMask", "=", "15", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", "<=", "AMDGPUDeviceInfo", "::", "HD5XXX", ")", "{", "InstKindLimit", "[", "IDFetch", "]", "=", "7", ";", "}", "else", "{", "InstKindLimit", "[", "IDFetch", "]", "=", "15", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "R600", "0", "15", "AMDGPUDeviceInfo::HD5XXX", "7", "15" ]

[]

[ "<s>", "MCSection", "*", "X86ELFMCAsmInfo", "::", "getNonexecutableStackSection", "(", "MCContext", "&", "Ctx", ")", "const", "{", "return", "MCSectionELF", "::", "Create", "(", "\".note.GNU-stack\"", ",", "MCSectionELF", "::", "SHT_PROGBITS", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ",", "false", ",", "Ctx", ")", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "X86", "X86", "\".note.GNU-stack\"", "0" ]

[]

[ "<s>", "static", "rtx", "sh_delegitimize_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", ",", "y", ";", "orig_x", "=", "delegitimize_mem_from_attrs", "(", "orig_x", ")", ";", "x", "=", "orig_x", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "{", "y", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "y", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_GOTOFF", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_SYMOFF", ")", "return", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ";", "else", "if", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_PCREL_SYMOFF", ")", "{", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ")", "==", "CONST", ")", "{", "rtx", "symplt", "=", "XEXP", "(", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symplt", ")", "==", "UNSPEC", "&&", "XINT", "(", "symplt", ",", "1", ")", "==", "UNSPEC_PLT", ")", "return", "XVECEXP", "(", "symplt", ",", "0", ",", "0", ")", ";", "}", "}", "else", "if", "(", "TARGET_SHMEDIA", "&&", "(", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_EXTRACT_S16", "||", "XINT", "(", "y", ",", "1", ")", "==", "UNSPEC_EXTRACT_U16", ")", ")", "{", "rtx", "offset", "=", "XVECEXP", "(", "y", ",", "0", ",", "1", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XVECEXP", "(", "y", ",", "0", ",", "0", ")", ",", "offset", ")", ";", "if", "(", "MEM_P", "(", "orig_x", ")", ")", "x", "=", "replace_equiv_address_nv", "(", "orig_x", ",", "x", ")", ";", "return", "x", ";", "}", "}", "}", "return", "orig_x", ";", "}", "</s>" ]

[ "In", "the", "name", "of", "slightly", "smaller", "debug", "output", ",", "and", "to", "cater", "to", "general", "assembler", "lossage", ",", "recognize", "various", "UNSPEC", "sequences", "and", "turn", "them", "back", "into", "a", "direct", "symbol", "reference", "." ]

[ "sh", "0", "0", "1", "1", "1", "0", "0", "1", "0", "0", "0", "0", "0", "1", "0", "0", "1", "1", "0", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "M68kInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "M68kMachineFunctionInfo", "*", "MxFI", "=", "MF", "->", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "M68k", "::", "AR32_NOSPRegClass", ")", ";", "MxFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k", "0", "M68k::AR32_NOSPRegClass" ]

[]

[ "<s>", "static", "rtx", "tilepro_emit_cc_test", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "machine_mode", "cmp_mode", ",", "bool", "eq_ne_only", ")", "{", "enum", "rtx_code", "branch_code", ";", "rtx", "temp", ";", "if", "(", "cmp_mode", "!=", "DImode", "&&", "op1", "==", "const0_rtx", "&&", "(", "code", "==", "EQ", "||", "code", "==", "NE", "||", "(", "!", "eq_ne_only", "&&", "signed_compare_p", "(", "code", ")", ")", ")", ")", "{", "op0", "=", "force_reg", "(", "SImode", ",", "op0", ")", ";", "return", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "op0", ",", "const0_rtx", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LE", ":", "case", "LT", ":", "case", "LEU", ":", "case", "LTU", ":", "branch_code", "=", "NE", ";", "break", ";", "case", "NE", ":", "case", "GE", ":", "case", "GT", ":", "case", "GEU", ":", "case", "GTU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "branch_code", "=", "EQ", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "cmp_mode", "!=", "DImode", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "(", "!", "satisfies_constraint_I", "(", "op1", ")", "||", "code", "==", "LEU", ")", ")", "{", "HOST_WIDE_INT", "n", "=", "trunc_int_for_mode", "(", "INTVAL", "(", "op1", ")", ",", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "if", "(", "!", "(", "symbolic_operand", "(", "op0", ",", "VOIDmode", ")", "||", "(", "REG_P", "(", "op0", ")", "&&", "REG_POINTER", "(", "op0", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "add", ";", "if", "(", "n", "!=", "-", "2147483647", "-", "1", ")", "add", "=", "-", "n", ";", "else", "add", "=", "n", ";", "op0", "=", "force_reg", "(", "SImode", ",", "op0", ")", ";", "temp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "temp", ",", "op0", ",", "gen_int_si", "(", "add", ")", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "reverse_condition", "(", "branch_code", ")", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "break", ";", "case", "LEU", ":", "if", "(", "n", "==", "-", "1", ")", "break", ";", "case", "LTU", ":", "{", "int", "first", "=", "exact_log2", "(", "code", "==", "LTU", "?", "n", ":", "n", "+", "1", ")", ";", "if", "(", "first", "!=", "-", "1", ")", "{", "op0", "=", "force_reg", "(", "SImode", ",", "op0", ")", ";", "temp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "temp", ",", "gen_rtx_LSHIFTRT", "(", "SImode", ",", "op0", ",", "gen_int_si", "(", "first", ")", ")", ")", ";", "return", "gen_rtx_fmt_ee", "(", "reverse_condition", "(", "branch_code", ")", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "}", "break", ";", "default", ":", "break", ";", "}", "}", "temp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "tilepro_emit_setcc_internal", "(", "temp", ",", "code", ",", "op0", ",", "op1", ",", "cmp_mode", ")", ";", "return", "gen_rtx_fmt_ee", "(", "branch_code", ",", "VOIDmode", ",", "temp", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "comparison", "for", "an", "SImode", "conditional", "branch", "." ]

[ "tilepro", "2147483647", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "output_call", "(", "rtx", "*", "operands", ")", "{", "gcc_assert", "(", "!", "arm_arch5", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "LR_REGNUM", ")", "{", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %|lr\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "if", "(", "TARGET_INTERWORK", "||", "arm_arch4t", ")", "output_asm_insn", "(", "\"bx%?\\t%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov%?\\t%|pc, %0\"", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "arm", "0", "0", "\"mov%?\\t%0, %|lr\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%0\"", "\"mov%?\\t%|pc, %0\"", "\"\"" ]

[]

[ "<s>", "bool", "AArch64BranchTargets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "branchTargetEnforcement", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Branch Targets **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "JumpTableTargets", ";", "if", "(", "auto", "*", "JTI", "=", "MF", ".", "getJumpTableInfo", "(", ")", ")", "for", "(", "auto", "&", "JTE", ":", "JTI", "->", "getJumpTables", "(", ")", ")", "for", "(", "auto", "*", "MBB", ":", "JTE", ".", "MBBs", ")", "JumpTableTargets", ".", "insert", "(", "MBB", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "CouldCall", "=", "false", ",", "CouldJump", "=", "false", ";", "if", "(", "&", "MBB", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", "CouldCall", "=", "true", ";", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", "||", "JumpTableTargets", ".", "count", "(", "&", "MBB", ")", ")", "CouldJump", "=", "true", ";", "if", "(", "CouldCall", "||", "CouldJump", ")", "{", "addBTI", "(", "MBB", ",", "CouldCall", ",", "CouldJump", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"********** AArch64 Branch Targets **********\\n\"", "\"********** Function: \"", "8" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented __builtin_return_address\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "\"WebAssembly hasn't implemented __builtin_return_address\"", "ISD::FRAMEADDR", "ISD::CopyToReg" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameLowering", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr128", ":", "SPU", "::", "LQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr64", ":", "SPU", "::", "LQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr32", ":", "SPU", "::", "LQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr16", ":", "SPU", "::", "LQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "LQDr8", ":", "SPU", "::", "LQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "LQDv16i8", ":", "SPU", "::", "LQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass in loadRegFromStackSlot!\"", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::LQDr128", "SPU::LQXr128", "SPU::R64CRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R64FPRegisterClass", "SPU::LQDr64", "SPU::LQXr64", "SPU::R32CRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R32FPRegisterClass", "SPU::LQDr32", "SPU::LQXr32", "SPU::R16CRegisterClass", "SPU::LQDr16", "SPU::LQXr16", "SPU::R8CRegisterClass", "SPU::LQDr8", "SPU::LQXr8", "SPU::VECREGRegisterClass", "SPU::LQDv16i8", "SPU::LQXv16i8", "\"Unknown regclass in loadRegFromStackSlot!\"" ]

[]

[ "<s>", "const", "char", "*", "output_adjust_stack_and_probe", "(", "rtx", "reg", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "end_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "end_lab", ",", "\"LPSRE\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "stack_pointer_rtx", ";", "xops", "[", "1", "]", "=", "reg", ";", "output_asm_insn", "(", "\"cmp%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tje\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "end_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"sub%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "const0_rtx", ";", "output_asm_insn", "(", "\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"", ",", "xops", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t\"", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "end_lab", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Adjust", "the", "stack", "pointer", "up", "to", "REG", "while", "probing", "it", "." ]

[ "i386", "0", "32", "32", "2", "\"LPSRL\"", "\"LPSRE\"", "0", "1", "\"cmp%z0\\t{%1, %0|%0, %1}\"", "\"\\tje\\t\"", "1", "\"sub%z0\\t{%1, %0|%0, %1}\"", "1", "\"or%z0\\t{%1, (%0)|DWORD PTR [%0], %1}\"", "\"\\tjmp\\t\"", "\"\"" ]

[]

[ "<s>", "void", "VideoCore4InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "VideoCore4", "::", "FR32RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "MOV_F", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "VideoCore4", "::", "GR32RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "VideoCore4", "::", "MOV_R", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Cannot emit physreg copy instruction\"", ")", ";", "}", "</s>" ]

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

[ "VideoCore4", "VideoCore4", "VideoCore4::FR32RegClass", "VideoCore4::MOV_F", "VideoCore4::GR32RegClass", "VideoCore4::MOV_R", "\"Cannot emit physreg copy instruction\"" ]

[]

[ "<s>", "static", "rtx", "generate_set_vrsave", "(", "rtx", "reg", ",", "rs6000_stack_t", "*", "info", ",", "int", "epiloguep", ")", "{", "int", "nclobs", ",", "i", ";", "rtx", "insn", ",", "clobs", "[", "TOTAL_ALTIVEC_REGS", "+", "1", "]", ";", "rtx", "vrsave", "=", "gen_rtx_REG", "(", "SImode", ",", "VRSAVE_REGNO", ")", ";", "clobs", "[", "0", "]", "=", "gen_rtx_SET", "(", "vrsave", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "SImode", ",", "gen_rtvec", "(", "2", ",", "reg", ",", "vrsave", ")", ",", "UNSPECV_SET_VRSAVE", ")", ")", ";", "nclobs", "=", "1", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "info", "->", "vrsave_mask", "&", "ALTIVEC_REG_BIT", "(", "i", ")", ")", "{", "if", "(", "!", "epiloguep", "||", "call_used_regs", "[", "i", "]", ")", "clobs", "[", "nclobs", "++", "]", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "V4SImode", ",", "i", ")", ")", ";", "else", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SImode", ",", "i", ")", ";", "clobs", "[", "nclobs", "++", "]", "=", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_UNSPEC", "(", "V4SImode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "27", ")", ")", ";", "}", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nclobs", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nclobs", ";", "++", "i", ")", "XVECEXP", "(", "insn", ",", "0", ",", "i", ")", "=", "clobs", "[", "i", "]", ";", "return", "insn", ";", "}", "</s>" ]

[ "Returns", "an", "insn", "that", "has", "a", "vrsave", "set", "operation", "with", "the", "appropriate", "CLOBBERs", "." ]

[ "powerpcspe", "1", "0", "2", "1", "1", "27", "0", "0" ]

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LanaiRegisterInfo", "*", "LRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "LRI", "->", "needsStackRealignment", "(", "MF", ")", "?", "MFI", ".", "getMaxAlignment", "(", ")", ":", "getStackAlignment", "(", ")", ";", "unsigned", "MaxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "MaxCallFrameSize", "=", "alignTo", "(", "MaxCallFrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallFrameSize", ")", ";", "if", "(", "!", "(", "hasReservedCallFrame", "(", "MF", ")", "&&", "MFI", ".", "adjustsStack", "(", ")", ")", ")", "FrameSize", "+=", "MaxCallFrameSize", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "void", "s390_asm_declare_function_size", "(", "FILE", "*", "asm_out_file", ",", "const", "char", "*", "fnname", ",", "tree", "decl", ")", "{", "if", "(", "!", "flag_inhibit_size_directive", ")", "ASM_OUTPUT_MEASURED_SIZE", "(", "asm_out_file", ",", "fnname", ")", ";", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "decl", ")", "==", "NULL", ")", "return", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machine pop\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machinemode pop\\n\"", ")", ";", "}", "</s>" ]

[ "Write", "an", "extra", "function", "footer", "after", "the", "very", "end", "of", "the", "function", "." ]

[ "s390", "\"\\t.machine pop\\n\"", "\"\\t.machinemode pop\\n\"" ]

[]

[ "<s>", "static", "cpp_hashnode", "*", "spu_macro_to_expand", "(", "cpp_reader", "*", "pfile", ",", "const", "cpp_token", "*", "tok", ")", "{", "cpp_hashnode", "*", "expand_this", "=", "tok", "->", "val", ".", "node", ".", "node", ";", "cpp_hashnode", "*", "ident", ";", "ident", "=", "spu_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", "==", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ")", "{", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "0", ")", ";", "ident", "=", "spu_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", ")", "{", "enum", "rid", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "if", "(", "cpp_macro_p", "(", "ident", ")", ")", "{", "(", "void", ")", "cpp_get_token", "(", "pfile", ")", ";", "tok", "=", "cpp_peek_token", "(", "pfile", ",", "0", ")", ";", "ident", "=", "spu_categorize_keyword", "(", "tok", ")", ";", "if", "(", "ident", ")", "rid_code", "=", "(", "enum", "rid", ")", "(", "ident", "->", "rid_code", ")", ";", "}", "if", "(", "rid_code", "==", "RID_UNSIGNED", "||", "rid_code", "==", "RID_LONG", "||", "rid_code", "==", "RID_SHORT", "||", "rid_code", "==", "RID_SIGNED", "||", "rid_code", "==", "RID_INT", "||", "rid_code", "==", "RID_CHAR", "||", "rid_code", "==", "RID_FLOAT", "||", "rid_code", "==", "RID_DOUBLE", ")", "expand_this", "=", "C_CPP_HASHNODE", "(", "__vector_keyword", ")", ";", "}", "}", "return", "expand_this", ";", "}", "</s>" ]

[ "Called", "to", "decide", "whether", "a", "conditional", "macro", "should", "be", "expanded", ".", "Since", "we", "have", "exactly", "one", "such", "macro", "(", "i.e", ",", "'vector", "'", ")", ",", "we", "do", "not", "need", "to", "examine", "the", "'tok", "'", "parameter", "." ]

[ "spu", "0", "0" ]

[]

[ "<s>", "void", "X86InstPrinterCommon", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "if", "(", "PrintBranchImmAsAddress", ")", "{", "uint64_t", "Target", "=", "Address", "+", "Op", ".", "getImm", "(", ")", ";", "if", "(", "MAI", ".", "getCodePointerSize", "(", ")", "==", "4", ")", "Target", "&=", "0xffffffff", ";", "O", "<<", "formatHex", "(", "Target", ")", ";", "}", "else", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "evaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "Op", ".", "getExpr", "(", ")", "->", "print", "(", "O", ",", "&", "MAI", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "4", "0xffffffff", "\"unknown pcrel immediate operand\"" ]

[]

[ "<s>", "static", "bool", "aarch64_legitimize_address_displacement", "(", "rtx", "*", "offset1", ",", "rtx", "*", "offset2", ",", "poly_int64", "orig_offset", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "is_constant", "(", "&", "size", ")", ")", "{", "HOST_WIDE_INT", "const_offset", ",", "second_offset", ";", "const_offset", "=", "orig_offset", ".", "coeffs", "[", "0", "]", "-", "orig_offset", ".", "coeffs", "[", "1", "]", ";", "if", "(", "mode", "==", "TImode", "||", "mode", "==", "TFmode", ")", "second_offset", "=", "(", "(", "const_offset", "+", "0x100", ")", "&", "0x1f8", ")", "-", "0x100", ";", "else", "if", "(", "(", "const_offset", "&", "(", "size", "-", "1", ")", ")", "!=", "0", ")", "second_offset", "=", "(", "(", "const_offset", "+", "0x100", ")", "&", "0x1ff", ")", "-", "0x100", ";", "else", "second_offset", "=", "const_offset", "&", "(", "size", "<", "4", "?", "0xfff", ":", "0x3ffc", ")", ";", "if", "(", "second_offset", "==", "0", "||", "known_eq", "(", "orig_offset", ",", "second_offset", ")", ")", "return", "false", ";", "*", "offset1", "=", "gen_int_mode", "(", "orig_offset", "-", "second_offset", ",", "Pmode", ")", ";", "*", "offset2", "=", "gen_int_mode", "(", "second_offset", ",", "Pmode", ")", ";", "return", "true", ";", "}", "else", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "machine_mode", "step_mode", "=", "(", "vec_flags", "&", "VEC_STRUCT", ")", "!=", "0", "?", "SVE_BYTE_MODE", ":", "mode", ";", "HOST_WIDE_INT", "factor", "=", "GET_MODE_SIZE", "(", "step_mode", ")", ".", "coeffs", "[", "1", "]", ";", "HOST_WIDE_INT", "vnum", "=", "orig_offset", ".", "coeffs", "[", "1", "]", "/", "factor", ";", "if", "(", "vec_flags", "&", "VEC_SVE_DATA", ")", "vnum", "=", "(", "(", "vnum", "+", "128", ")", "&", "255", ")", "-", "128", ";", "else", "vnum", "=", "(", "(", "vnum", "+", "256", ")", "&", "511", ")", "-", "256", ";", "if", "(", "vnum", "==", "0", ")", "return", "false", ";", "poly_int64", "second_offset", "=", "GET_MODE_SIZE", "(", "step_mode", ")", "*", "vnum", ";", "if", "(", "known_eq", "(", "second_offset", ",", "orig_offset", ")", ")", "return", "false", ";", "*", "offset1", "=", "gen_int_mode", "(", "orig_offset", "-", "second_offset", ",", "Pmode", ")", ";", "*", "offset2", "=", "gen_int_mode", "(", "second_offset", ",", "Pmode", ")", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Split", "an", "out-of-range", "address", "displacement", "into", "a", "base", "and", "offset", ".", "Use", "4KB", "range", "for", "1-", "and", "2-byte", "accesses", "and", "a", "16KB", "range", "otherwise", "to", "increase", "opportunities", "for", "sharing", "the", "base", "address", "of", "different", "sizes", ".", "For", "unaligned", "accesses", "and", "TI/TF", "mode", "use", "the", "signed", "9-bit", "range", "." ]

[ "aarch64", "0", "1", "0x100", "0x1f8", "0x100", "1", "0", "0x100", "0x1ff", "0x100", "4", "0xfff", "0x3ffc", "0", "0", "1", "1", "128", "255", "128", "256", "511", "256", "0" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "realRVLocIdx", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ",", "++", "realRVLocIdx", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "realRVLocIdx", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "if", "(", "Outs", "[", "i", "]", ".", "ArgVT", "==", "MVT", "::", "i1", ")", "{", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i1", ",", "Arg", ")", ";", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "}", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::OutputArg", "AArch64", "AArch64", "16", "4", "1", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "MVT::i1", "ISD::TRUNCATE", "MVT::i1", "ISD::ZERO_EXTEND", "ISD::BITCAST", "1", "0", "AArch64ISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "const", "TargetFrameLowering", "::", "SpillSlot", "*", "ARMFrameLowering", "::", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "{", "static", "const", "SpillSlot", "FixedSpillOffsets", "[", "]", "=", "{", "{", "ARM", "::", "FPCXTNS", ",", "-", "4", "}", "}", ";", "NumEntries", "=", "array_lengthof", "(", "FixedSpillOffsets", ")", ";", "return", "FixedSpillOffsets", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "ARM", "ARM", "ARM::FPCXTNS", "4" ]

[]

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

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

[ "PTX", "PTX" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Mandarin" ]

[]

[ "<s>", "bool", "RV16KAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "AsmVariant", "!=", "0", ")", "report_fatal_error", "(", "\"There are no defined alternate asm variants\"", ")", ";", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "OS", "<<", "\"0(\"", "<<", "RV16KInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\")\"", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "0", "\"There are no defined alternate asm variants\"", "\"0(\"", "RV16K", "\")\"" ]

[]

[ "<s>", "TargetStackID", "::", "Value", "AArch64FrameLowering", "::", "getStackIDForScalableVectors", "(", ")", "const", "{", "return", "TargetStackID", "::", "SVEVector", ";", "}", "</s>" ]

[ "Returns", "the", "StackID", "that", "scalable", "vectors", "should", "be", "associated", "with", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "spu_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_USER_ALIGN", "(", "decl", ")", "&&", "DECL_ALIGN", "(", "decl", ")", "<", "128", ")", "SYMBOL_REF_FLAGS", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "|=", "SYMBOL_FLAG_ALIGN1", ";", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "(", "local", "vs.", "global", ",", "tls", "model", ")", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

[ "spu", "128", "0" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "MFFrame", ".", "getStackSize", "(", ")", ";", "if", "(", "ZFI", "->", "getLowSavedGPR", "(", ")", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "return", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "getObjectFormat", "(", ")", "==", "Triple", "::", "MachO", "&&", "Subtarget", "->", "is64Bit", "(", ")", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "SDValue", "mprocTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "mproc_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "}", "}", "</s>" ]

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

[ "mproc", "mproc", "ISD::InputArg", "\"Unsupported calling convention\"", "mproc", "\"ISRs cannot have arguments\"" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "breakPartialRegDependency", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "MI", "&&", "OpNum", "<", "MI", "->", "getDesc", "(", ")", ".", "getNumDefs", "(", ")", "&&", "\"OpNum is not a def\"", ")", ";", "assert", "(", "TRI", "&&", "\"Need TRI instance\"", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "Reg", ")", "&&", "\"Can't break virtual register dependencies.\"", ")", ";", "unsigned", "DReg", "=", "Reg", ";", "if", "(", "ARM", "::", "SPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "DReg", "=", "ARM", "::", "D0", "+", "(", "Reg", "-", "ARM", "::", "S0", ")", "/", "2", ";", "assert", "(", "TRI", "->", "isSuperRegister", "(", "Reg", ",", "DReg", ")", "&&", "\"Register enums broken\"", ")", ";", "}", "assert", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "DReg", ")", "&&", "\"Can only break D-reg deps\"", ")", ";", "assert", "(", "MI", "->", "definesRegister", "(", "DReg", ",", "TRI", ")", "&&", "\"MI doesn't clobber full D-reg\"", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "FCONSTD", ")", ",", "DReg", ")", ".", "addImm", "(", "96", ")", ")", ";", "MI", "->", "addRegisterKilled", "(", "DReg", ",", "TRI", ",", "true", ")", ";", "}", "</s>" ]

[ "Insert", "a", "dependency-breaking", "instruction", "before", "MI", "to", "eliminate", "an", "unwanted", "dependency", "on", "OpNum", "." ]

[ "ARM", "ARM", "\"OpNum is not a def\"", "\"Need TRI instance\"", "\"Can't break virtual register dependencies.\"", "ARM::SPRRegClass", "ARM::D0", "ARM::S0", "2", "\"Register enums broken\"", "ARM::DPRRegClass", "\"Can only break D-reg deps\"", "\"MI doesn't clobber full D-reg\"", "ARM::FCONSTD", "96" ]

[]

[ "<s>", "bool", "isLegalMaskedScatter", "(", "Type", "*", "Ty", ",", "MaybeAlign", "Alignment", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "scatter", "." ]

[ "ARM" ]

[]

[ "<s>", "CSKYSubtarget", "&", "CSKYSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPUName", ",", "StringRef", "TuneCPUName", ",", "StringRef", "FS", ")", "{", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "TuneCPUName", ".", "empty", "(", ")", ")", "TuneCPUName", "=", "CPUName", ";", "UseHardFloat", "=", "false", ";", "UseHardFloatABI", "=", "false", ";", "HasFPUv2SingleFloat", "=", "false", ";", "HasFPUv2DoubleFloat", "=", "false", ";", "HasFPUv3HalfWord", "=", "false", ";", "HasFPUv3HalfFloat", "=", "false", ";", "HasFPUv3SingleFloat", "=", "false", ";", "HasFPUv3DoubleFloat", "=", "false", ";", "HasFdivdu", "=", "false", ";", "HasFLOATE1", "=", "false", ";", "HasFLOAT1E2", "=", "false", ";", "HasFLOAT1E3", "=", "false", ";", "HasFLOAT3E4", "=", "false", ";", "HasFLOAT7E60", "=", "false", ";", "HasExtendLrw", "=", "false", ";", "HasBTST16", "=", "false", ";", "HasTrust", "=", "false", ";", "HasJAVA", "=", "false", ";", "HasCache", "=", "false", ";", "HasNVIC", "=", "false", ";", "HasDSP", "=", "false", ";", "HasDSP1E2", "=", "false", ";", "HasDSPE60", "=", "false", ";", "HasDSPV2", "=", "false", ";", "HasDSP_Silan", "=", "false", ";", "HasDoloop", "=", "false", ";", "HasHardwareDivide", "=", "false", ";", "HasHighRegisters", "=", "false", ";", "HasVDSPV2", "=", "false", ";", "HasVDSP2E3", "=", "false", ";", "HasVDSP2E60F", "=", "false", ";", "ReadTPHard", "=", "false", ";", "HasVDSPV1_128", "=", "false", ";", "UseCCRT", "=", "false", ";", "DumpConstPool", "=", "false", ";", "EnableInterruptAttribute", "=", "false", ";", "HasPushPop", "=", "false", ";", "HasSTM", "=", "false", ";", "SmartMode", "=", "false", ";", "EnableStackSize", "=", "false", ";", "HasE1", "=", "false", ";", "HasE2", "=", "false", ";", "Has2E3", "=", "false", ";", "HasMP", "=", "false", ";", "Has3E3r1", "=", "false", ";", "Has3r1E3r2", "=", "false", ";", "Has3r2E3r3", "=", "false", ";", "Has3E7", "=", "false", ";", "HasMP1E2", "=", "false", ";", "Has7E10", "=", "false", ";", "Has10E60", "=", "false", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "TuneCPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "CSKY", "CSKY", "CSKY", "\"generic\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", ")", "return", "new", "PPCDispatchGroupSBHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "DIR_440", "&&", "Directive", "!=", "PPC", "::", "DIR_A2", "&&", "Directive", "!=", "PPC", "::", "DIR_E500mc", "&&", "Directive", "!=", "PPC", "::", "DIR_E5500", ")", "{", "assert", "(", "TM", ".", "getInstrInfo", "(", ")", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "TM", ")", ";", "}", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR7", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "\"No InstrInfo?\"", "PPC" ]

[]

[ "<s>", "static", "int", "c4x_address_cost", "(", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "return", "1", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "return", "10", ";", "case", "LO_SUM", ":", "{", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "op1", ")", "==", "SYMBOL_REF", ")", "return", "TARGET_SMALL", "?", "3", ":", "4", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", ")", "{", "rtx", "offset", "=", "const0_rtx", ";", "op1", "=", "eliminate_constant_term", "(", "op1", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "LABEL_REF", ")", "return", "3", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "SYMBOL_REF", ")", "return", "4", ";", "if", "(", "INTVAL", "(", "offset", ")", "==", "0", ")", "return", "3", ";", "return", "4", ";", "}", "fatal_insn", "(", "\"c4x_address_cost: Invalid addressing mode\"", ",", "addr", ")", ";", "}", "break", ";", "case", "PLUS", ":", "{", "register", "rtx", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "op1", ")", ")", "{", "default", ":", "break", ";", "case", "REG", ":", "return", "2", ";", "case", "CONST_INT", ":", "if", "(", "TARGET_DEVEL", "&&", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", ")", ")", "return", "1", ";", "if", "(", "IS_DISP1_CONST", "(", "INTVAL", "(", "op1", ")", ")", ")", "return", "1", ";", "if", "(", "!", "TARGET_C3X", "&&", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", ")", ")", "return", "2", ";", "return", "3", ";", "}", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", ".", "This", "is", "used", "in", "cse", "and", "loop", "optimization", "to", "determine", "if", "it", "is", "worthwhile", "storing", "a", "common", "address", "into", "a", "register", ".", "Unfortunately", ",", "the", "C4x", "address", "cost", "depends", "on", "other", "operands", "." ]

[ "c4x", "1", "1", "10", "1", "3", "4", "3", "4", "0", "3", "4", "\"c4x_address_cost: Invalid addressing mode\"", "0", "1", "2", "1", "1", "2", "3", "4" ]

[]

[ "<s>", "static", "int", "microblaze_must_save_register", "(", "int", "regno", ")", "{", "if", "(", "pic_offset_table_rtx", "&&", "(", "regno", "==", "MB_ABI_PIC_ADDR_REGNUM", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "1", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", "return", "1", ";", "if", "(", "frame_pointer_needed", "&&", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", "return", "1", ";", "if", "(", "crtl", "->", "calls_eh_return", "&&", "regno", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "return", "1", ";", "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "if", "(", "regno", "==", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "return", "1", ";", "if", "(", "(", "microblaze_is_interrupt_variant", "(", ")", "||", "save_volatiles", ")", "&&", "(", "regno", ">=", "3", "&&", "regno", "<=", "12", ")", ")", "return", "1", ";", "}", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_MSR_SAVE_REG", "||", "(", "(", "interrupt_handler", "||", "fast_interrupt", ")", "&&", "(", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", ")", ")", "return", "1", ";", "}", "if", "(", "save_volatiles", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "regno", "==", "MB_ABI_ASM_TEMP_REGNUM", "||", "regno", "==", "MB_ABI_EXCEPTION_RETURN_ADDR_REGNUM", ")", "return", "1", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", "&&", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "0", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "1", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Determine", "of", "register", "must", "be", "saved/restored", "in", "call", "." ]

[ "microblaze", "1", "1", "1", "1", "1", "3", "12", "1", "1", "1", "0", "1", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "mips_small_data_pattern_p", "(", "rtx", "op", ")", "{", "return", "mips_small_data_pattern_1", "(", "op", ",", "SYMBOL_CONTEXT_LEA", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "refers", "to", "small", "data", "symbols", "directly", ",", "not", "through", "a", "LO_SUM", "." ]

[ "mips" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int64_t", "&", "Mask", ",", "int64_t", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "C2_cmpeq", ":", "case", "Hexagon", "::", "C2_cmpeqp", ":", "case", "Hexagon", "::", "C2_cmpgt", ":", "case", "Hexagon", "::", "C2_cmpgtp", ":", "case", "Hexagon", "::", "C2_cmpgtu", ":", "case", "Hexagon", "::", "C2_cmpgtup", ":", "case", "Hexagon", "::", "A4_cmpbeq", ":", "case", "Hexagon", "::", "A4_cmpbgt", ":", "case", "Hexagon", "::", "A4_cmpbgtu", ":", "case", "Hexagon", "::", "A4_cmpheq", ":", "case", "Hexagon", "::", "A4_cmphgt", ":", "case", "Hexagon", "::", "A4_cmphgtu", ":", "case", "Hexagon", "::", "C4_cmpneq", ":", "case", "Hexagon", "::", "C4_cmplte", ":", "case", "Hexagon", "::", "C4_cmplteu", ":", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Value", "=", "0", ";", "return", "true", ";", "case", "Hexagon", "::", "C2_cmpeqi", ":", "case", "Hexagon", "::", "C2_cmpgtui", ":", "case", "Hexagon", "::", "C2_cmpgti", ":", "case", "Hexagon", "::", "C4_cmpneqi", ":", "case", "Hexagon", "::", "C4_cmplteui", ":", "case", "Hexagon", "::", "C4_cmpltei", ":", "case", "Hexagon", "::", "A4_cmpbeqi", ":", "case", "Hexagon", "::", "A4_cmpbgti", ":", "case", "Hexagon", "::", "A4_cmpbgtui", ":", "case", "Hexagon", "::", "A4_cmpheqi", ":", "case", "Hexagon", "::", "A4_cmphgti", ":", "case", "Hexagon", "::", "A4_cmphgtui", ":", "{", "SrcReg2", "=", "0", ";", "const", "MachineOperand", "&", "Op2", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "Op2", ".", "isImm", "(", ")", ")", "return", "false", ";", "Value", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgti", "Hexagon::C2_cmpgtui", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "1", "0", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "1", "0xFF", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "1", "0xFFFF", "Hexagon::C2_cmpeq", "Hexagon::C2_cmpeqp", "Hexagon::C2_cmpgt", "Hexagon::C2_cmpgtp", "Hexagon::C2_cmpgtu", "Hexagon::C2_cmpgtup", "Hexagon::A4_cmpbeq", "Hexagon::A4_cmpbgt", "Hexagon::A4_cmpbgtu", "Hexagon::A4_cmpheq", "Hexagon::A4_cmphgt", "Hexagon::A4_cmphgtu", "Hexagon::C4_cmpneq", "Hexagon::C4_cmplte", "Hexagon::C4_cmplteu", "2", "0", "Hexagon::C2_cmpeqi", "Hexagon::C2_cmpgtui", "Hexagon::C2_cmpgti", "Hexagon::C4_cmpneqi", "Hexagon::C4_cmplteui", "Hexagon::C4_cmpltei", "Hexagon::A4_cmpbeqi", "Hexagon::A4_cmpbgti", "Hexagon::A4_cmpbgtui", "Hexagon::A4_cmpheqi", "Hexagon::A4_cmphgti", "Hexagon::A4_cmphgtui", "0", "2", "2" ]

[]

[ "<s>", "bool", "RISCVRegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "PhysReg", "==", "RISCV", "::", "X0", "||", "PhysReg", "==", "RISCV", "::", "VLENB", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::X0", "RISCV::VLENB" ]

[]

[ "<s>", "const", "MachineOperand", "&", "WebAssemblyInstrInfo", "::", "getCalleeOperand", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "WebAssembly", "::", "getCalleeOp", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "the", "callee", "operand", "from", "the", "given", "MI", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::getCalleeOp" ]

[]

[ "<s>", "bool", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "SystemZ" ]

[]

[ "<s>", "bool", "OptimizePICCall", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "F", ".", "getSubtarget", "(", ")", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "SmallVector", "<", "MBBInfo", ",", "8", ">", "WorkList", "(", "1", ",", "MBBInfo", "(", "MDT", "->", "getRootNode", "(", ")", ")", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "MBBInfo", "&", "MBBI", "=", "WorkList", ".", "back", "(", ")", ";", "if", "(", "MBBI", ".", "isVisited", "(", ")", ")", "{", "MBBI", ".", "postVisit", "(", ")", ";", "WorkList", ".", "pop_back", "(", ")", ";", "continue", ";", "}", "MBBI", ".", "preVisit", "(", "ScopedHT", ")", ";", "Changed", "|=", "visitNode", "(", "MBBI", ")", ";", "const", "MachineDomTreeNode", "*", "Node", "=", "MBBI", ".", "getNode", "(", ")", ";", "WorkList", ".", "append", "(", "Node", "->", "begin", "(", ")", ",", "Node", "->", "end", "(", ")", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "8", "1" ]

[]

[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ",", "Mnemonic", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]

[]