Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Single-Path Prepare\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Single-Path Prepare\"" ]

[]

[ "<s>", "static", "bool", "s390_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "return", "label", "&&", "label", "!=", "const0_rtx", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "the", "case", "for", "execute", "insns", "that", "carry", "a", "unique", "label", "." ]

[ "s390" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", "->", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "inline", "unsigned", "ptr_regno_for_savres", "(", "int", "sel", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "return", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "||", "(", "sel", "&", "SAVRES_LR", ")", "?", "1", ":", "12", ";", "return", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "(", "sel", "&", "SAVRES_REG", ")", "==", "SAVRES_FPR", "?", "1", ":", "11", ";", "}", "</s>" ]

[ "Return", "the", "register", "number", "used", "as", "a", "pointer", "by", "out-of-line", "save/restore", "functions", "." ]

[ "powerpcspe", "1", "12", "1", "11" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "assert", "(", "Kind", "==", "k_Reg", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ";", "}", "</s>" ]

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

[ "MSP430", "\"Invalid access!\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "const", "bool", "restrict_addressing_modes_for_nacl", "=", "Subtarget", "->", "isTargetNaCl", "(", ")", "&&", "isa", "<", "MemSDNode", ">", "(", "N", ")", ";", "if", "(", "restrict_addressing_modes_for_nacl", ")", "{", "return", "false", ";", "}", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "!", "isLegal", ")", "return", "false", ";", "AM", "=", "isInc", "?", "ISD", "::", "PRE_INC", ":", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ARM", "ISD::PRE_INC", "ISD::PRE_DEC" ]

[]

[ "<s>", "static", "void", "iq2000_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "unsigned", "int", "iq2000_off", "=", "!", "cum", "->", "last_arg_fp", ";", "unsigned", "int", "iq2000_fp_off", "=", "cum", "->", "last_arg_fp", ";", "if", "(", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", ")", "{", "int", "iq2000_save_gp_regs", "=", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "arg_words", "-", "iq2000_off", ";", "int", "iq2000_save_fp_regs", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "fp_arg_words", "-", "iq2000_fp_off", ")", ";", "if", "(", "iq2000_save_gp_regs", "<", "0", ")", "iq2000_save_gp_regs", "=", "0", ";", "if", "(", "iq2000_save_fp_regs", "<", "0", ")", "iq2000_save_fp_regs", "=", "0", ";", "*", "pretend_size", "=", "(", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", "+", "(", "iq2000_save_fp_regs", "*", "UNITS_PER_FPREG", ")", ")", ";", "if", "(", "!", "(", "no_rtl", ")", ")", "{", "if", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "move_block_from_reg", "(", "cum", "->", "arg_words", "+", "GP_ARG_FIRST", "+", "iq2000_off", ",", "mem", ",", "iq2000_save_gp_regs", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "bool", "rvexInstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "*", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", "||", "MI", "->", "isLabel", "(", ")", "||", "MI", "->", "isInlineAsm", "(", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "rvex", "rvex" ]

[]

[ "<s>", "bool", "xtensa_b4constu", "(", "HOST_WIDE_INT", "v", ")", "{", "switch", "(", "v", ")", "{", "case", "32768", ":", "case", "65536", ":", "case", "2", ":", "case", "3", ":", "case", "4", ":", "case", "5", ":", "case", "6", ":", "case", "7", ":", "case", "8", ":", "case", "10", ":", "case", "12", ":", "case", "16", ":", "case", "32", ":", "case", "64", ":", "case", "128", ":", "case", "256", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Functions", "to", "test", "Xtensa", "immediate", "operand", "validity", "." ]

[ "xtensa", "32768", "65536", "2", "3", "4", "5", "6", "7", "8", "10", "12", "16", "32", "64", "128", "256" ]

[]

[ "<s>", "static", "bool", "riscv_in_small_data_p", "(", "const_tree", "x", ")", "{", "if", "(", "TREE_CODE", "(", "x", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "x", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "x", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "x", ")", ")", "{", "const", "char", "*", "sec", "=", "DECL_SECTION_NAME", "(", "x", ")", ";", "return", "strcmp", "(", "sec", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "sec", ",", "\".sbss\"", ")", "==", "0", ";", "}", "return", "riscv_size_ok_for_small_data_p", "(", "int_size_in_bytes", "(", "TREE_TYPE", "(", "x", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXP", "should", "be", "placed", "in", "the", "small", "data", "section", "." ]

[ "riscv", "\".sdata\"", "0", "\".sbss\"", "0" ]

[]

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

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

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

[]

[ "<s>", "bool", "X86DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ";", "switch", "(", "ConstraintCode", ")", "{", "case", "'o'", ":", "case", "'v'", ":", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Op4", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "OutOps", ".", "push_back", "(", "Op2", ")", ";", "OutOps", ".", "push_back", "(", "Op3", ")", ";", "OutOps", ".", "push_back", "(", "Op4", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isSafeToMoveRegClassDefs", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "RC", "!=", "&", "AMDGPU", "::", "EXECRegRegClass", ";", "}", "</s>" ]

[ "isSafeToMoveRegClassDefs", "-", "Return", "true", "if", "it", "'s", "safe", "to", "move", "a", "machine", "instruction", "that", "defines", "the", "specified", "register", "class", "." ]

[ "R600", "SI" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "bool", "RISCVELFTargetObjectFile", "::", "isConstantInSmallSection", "(", "const", "DataLayout", "&", "DL", ",", "const", "Constant", "*", "CN", ")", "const", "{", "return", "isInSmallSection", "(", "DL", ".", "getTypeAllocSize", "(", "CN", "->", "getType", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "constant", "should", "be", "placed", "into", "small", "data", "section", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "void", "AArch64CallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "const", "DataLayout", "&", "DL", ",", "MachineRegisterInfo", "&", "MRI", ",", "CallingConv", "::", "ID", "CallConv", ")", "const", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "if", "(", "OrigArg", ".", "Ty", "->", "isVoidTy", "(", ")", ")", "return", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "SmallVector", "<", "uint64_t", ",", "4", ">", "Offsets", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "&", "Offsets", ",", "0", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "bool", "NeedsRegBlock", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "OrigArg", ".", "Ty", ",", "CallConv", ",", "false", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "Type", "*", "SplitTy", "=", "SplitVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "i", "]", ",", "SplitTy", ",", "OrigArg", ".", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "if", "(", "NeedsRegBlock", ")", "SplitArgs", ".", "back", "(", ")", ".", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "}", "SplitArgs", ".", "back", "(", ")", ".", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "4", "4", "0", "1", "0", "0", "\"Regs / types mismatch\"", "0" ]

[]

[ "<s>", "bool", "HexagonEarlyIfConversion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MFN", "=", "&", "MF", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MBPI", "=", "EnableHexagonBP", "?", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ":", "nullptr", ";", "Deleted", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineLoop", "*", "L", ":", "*", "MLI", ")", "Changed", "|=", "visitLoop", "(", "L", ")", ";", "Changed", "|=", "visitLoop", "(", "nullptr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Kudeyar", "\"Kudeyar Assembly Printer\"" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "SW", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSD", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::SW", "RISCV::FPR32RegClass", "RISCV::FSW", "RISCV::FPR64RegClass", "RISCV::FSD", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "BitVector", "KudeyarRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "Kudeyar", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "Kudeyar", "::", "FP", ")", ";", "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", "." ]

[ "Kudeyar", "Kudeyar", "Kudeyar::SP", "Kudeyar::FP" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "MIRBuilder", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::S_ENDPGM" ]

[]

[ "<s>", "static", "void", "aarch64_override_options", "(", "void", ")", "{", "uint64_t", "cpu_isa", "=", "0", ";", "uint64_t", "arch_isa", "=", "0", ";", "aarch64_isa_flags", "=", "0", ";", "bool", "valid_cpu", "=", "true", ";", "bool", "valid_tune", "=", "true", ";", "bool", "valid_arch", "=", "true", ";", "selected_cpu", "=", "NULL", ";", "selected_arch", "=", "NULL", ";", "selected_tune", "=", "NULL", ";", "if", "(", "aarch64_branch_protection_string", ")", "aarch64_validate_mbranch_protection", "(", "aarch64_branch_protection_string", ")", ";", "if", "(", "aarch64_cpu_string", ")", "valid_cpu", "=", "aarch64_validate_mcpu", "(", "aarch64_cpu_string", ",", "&", "selected_cpu", ",", "&", "cpu_isa", ")", ";", "if", "(", "aarch64_arch_string", ")", "valid_arch", "=", "aarch64_validate_march", "(", "aarch64_arch_string", ",", "&", "selected_arch", ",", "&", "arch_isa", ")", ";", "if", "(", "aarch64_tune_string", ")", "valid_tune", "=", "aarch64_validate_mtune", "(", "aarch64_tune_string", ",", "&", "selected_tune", ")", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "if", "(", "!", "selected_cpu", ")", "{", "if", "(", "selected_arch", ")", "{", "selected_cpu", "=", "&", "all_cores", "[", "selected_arch", "->", "ident", "]", ";", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "else", "{", "selected_cpu", "=", "aarch64_get_tune_cpu", "(", "aarch64_none", ")", ";", "aarch64_isa_flags", "=", "TARGET_CPU_DEFAULT", ">>", "6", ";", "}", "if", "(", "selected_tune", ")", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "}", "else", "if", "(", "selected_arch", ")", "{", "if", "(", "selected_arch", "->", "arch", "!=", "selected_cpu", "->", "arch", ")", "{", "warning", "(", "0", ",", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", ",", "aarch64_cpu_string", ",", "aarch64_arch_string", ")", ";", "}", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "}", "else", "{", "aarch64_isa_flags", "=", "cpu_isa", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "if", "(", "!", "selected_arch", ")", "{", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "}", "if", "(", "!", "selected_tune", ")", "selected_tune", "=", "selected_cpu", ";", "if", "(", "aarch64_enable_bti", "==", "2", ")", "{", "aarch64_enable_bti", "=", "1", ";", "aarch64_enable_bti", "=", "0", ";", "}", "if", "(", "!", "TARGET_ILP32", "&&", "accepted_branch_protection_string", "==", "NULL", ")", "{", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NON_LEAF", ";", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NONE", ";", "}", "if", "(", "TARGET_ILP32", ")", "error", "(", "\"assembler does not support %<-mabi=ilp32%>\"", ")", ";", "aarch64_sve_vg", "=", "aarch64_convert_sve_vector_bits", "(", "aarch64_sve_vector_bits", ")", ";", "if", "(", "aarch64_ra_sign_scope", "!=", "AARCH64_FUNCTION_NONE", "&&", "TARGET_ILP32", ")", "sorry", "(", "\"return address signing is only supported for %<-mabi=lp64%>\"", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_tune_string", "&&", "valid_tune", ")", ")", "gcc_assert", "(", "explicit_tune_core", "!=", "aarch64_none", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_arch_string", "&&", "valid_arch", ")", ")", "gcc_assert", "(", "explicit_arch", "!=", "aarch64_no_arch", ")", ";", "if", "(", "aarch64_track_speculation", ")", "flag_shrink_wrap", "=", "0", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "aarch64", "0", "0", "0", "6", "0", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", "2", "1", "0", "\"assembler does not support %<-mabi=ilp32%>\"", "\"return address signing is only supported for %<-mabi=lp64%>\"", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "isFrameOperand", "(", "MI", ",", "1", ",", "FrameIndex", ")", ")", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "rs6000_emit_vector_cond_expr", "(", "rtx", "dest", ",", "rtx", "op_true", ",", "rtx", "op_false", ",", "rtx", "cond", ",", "rtx", "cc_op0", ",", "rtx", "cc_op1", ")", "{", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "mask_mode", "=", "GET_MODE", "(", "cc_op0", ")", ";", "enum", "rtx_code", "rcode", "=", "GET_CODE", "(", "cond", ")", ";", "machine_mode", "cc_mode", "=", "CCmode", ";", "rtx", "mask", ";", "rtx", "cond2", ";", "rtx", "tmp", ";", "bool", "invert_move", "=", "false", ";", "if", "(", "VECTOR_UNIT_NONE_P", "(", "dest_mode", ")", ")", "return", "0", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "dest_mode", ")", "==", "GET_MODE_SIZE", "(", "mask_mode", ")", "&&", "GET_MODE_NUNITS", "(", "dest_mode", ")", "==", "GET_MODE_NUNITS", "(", "mask_mode", ")", ")", ";", "switch", "(", "rcode", ")", "{", "case", "NE", ":", "case", "UNLE", ":", "case", "UNLT", ":", "case", "UNGE", ":", "case", "UNGT", ":", "invert_move", "=", "true", ";", "rcode", "=", "reverse_condition_maybe_unordered", "(", "rcode", ")", ";", "if", "(", "rcode", "==", "UNKNOWN", ")", "return", "0", ";", "break", ";", "case", "GTU", ":", "case", "GEU", ":", "case", "LTU", ":", "case", "LEU", ":", "cc_mode", "=", "CCUNSmode", ";", "break", ";", "default", ":", "break", ";", "}", "mask", "=", "rs6000_emit_vector_compare", "(", "rcode", ",", "cc_op0", ",", "cc_op1", ",", "mask_mode", ")", ";", "if", "(", "!", "mask", ")", "return", "0", ";", "if", "(", "invert_move", ")", "{", "tmp", "=", "op_true", ";", "op_true", "=", "op_false", ";", "op_false", "=", "tmp", ";", "}", "cond2", "=", "gen_rtx_fmt_ee", "(", "NE", ",", "cc_mode", ",", "gen_lowpart", "(", "dest_mode", ",", "mask", ")", ",", "CONST0_RTX", "(", "dest_mode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "dest_mode", ",", "cond2", ",", "op_true", ",", "op_false", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Emit", "vector", "conditional", "expression", ".", "DEST", "is", "destination", ".", "OP1", "and", "OP2", "are", "two", "VEC_COND_EXPR", "operands", ".", "CC_OP0", "and", "CC_OP1", "are", "the", "two", "operands", "for", "the", "relation", "operation", "COND", "." ]

[ "rs6000", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "MCInst", "const", "&", "MCB", "=", "DF", "->", "getInst", "(", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "MCInst", "&", "MCI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "HexagonMCInstrInfo", "::", "instruction", "(", "MCB", ",", "Fixup", ".", "getOffset", "(", ")", "/", "HEXAGON_INSTR_SIZE", ")", ")", ";", "bool", "Relaxable", "=", "isInstRelaxable", "(", "MCI", ")", ";", "if", "(", "Relaxable", "==", "false", ")", "return", "false", ";", "if", "(", "!", "Resolved", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "fixup_Hexagon_B22_PCREL", ":", "default", ":", "return", "false", ";", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "break", ";", "}", "}", "}", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "sValue", "=", "Value", ";", "int64_t", "maxValue", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "fixup_Hexagon_B7_PCREL", ":", "maxValue", "=", "1", "<<", "8", ";", "break", ";", "case", "fixup_Hexagon_B9_PCREL", ":", "maxValue", "=", "1", "<<", "10", ";", "break", ";", "case", "fixup_Hexagon_B15_PCREL", ":", "maxValue", "=", "1", "<<", "16", ";", "break", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "maxValue", "=", "1", "<<", "23", ";", "break", ";", "default", ":", "maxValue", "=", "INT64_MAX", ";", "break", ";", "}", "bool", "isFarAway", "=", "-", "maxValue", ">", "sValue", "||", "sValue", ">", "maxValue", "-", "1", ";", "if", "(", "isFarAway", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "8", "Hexagon", "1", "10", "Hexagon", "1", "16", "Hexagon", "1", "23", "1", "Hexagon" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "&", "SILoadStoreOptimizerID", ")", ";", "if", "(", "EnableSDWAPeephole", ")", "{", "addPass", "(", "&", "SIPeepholeSDWAID", ")", ";", "addPass", "(", "&", "MachineLICMID", ")", ";", "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

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

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"ARM hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "LastMI", "&&", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "!=", "ARMII", "::", "DomainGeneral", ")", "{", "MachineInstr", "*", "DefMI", "=", "LastMI", ";", "const", "MCInstrDesc", "&", "LastMCID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "LastMI", "->", "isBarrier", "(", ")", "&&", "!", "(", "TII", ".", "getSubtarget", "(", ")", ".", "hasMuxedUnits", "(", ")", "&&", "LastMI", "->", "mayLoadOrStore", "(", ")", ")", "&&", "(", "LastMCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainGeneral", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "std", "::", "prev", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}", "}", "if", "(", "TII", ".", "isFpMLxInstruction", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "&&", "(", "TII", ".", "canCauseFpMLxStall", "(", "MI", "->", "getOpcode", "(", ")", ")", "||", "hasRAWHazard", "(", "DefMI", ",", "MI", ",", "TII", ".", "getRegisterInfo", "(", ")", ")", ")", ")", "{", "if", "(", "FpMLxStalls", "==", "0", ")", "FpMLxStalls", "=", "4", ";", "return", "Hazard", ";", "}", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ",", "Stalls", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "ARM", "ARM", "0", "\"ARM hazards don't support scoreboard lookahead\"", "ARMII::DomainMask", "ARMII::DomainGeneral", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainGeneral", "0", "4" ]

[]

[ "<s>", "void", "AVRFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "!", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", ")", "{", "return", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "FrameSize", ")", "{", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "AVR", "::", "POPRd", "&&", "Opc", "!=", "AVR", "::", "POPWRd", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "unsigned", "Opcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "FrameSize", ")", ")", "{", "Opcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "Opcode", "=", "AVR", "::", "SUBIWRdK", ";", "FrameSize", "=", "-", "FrameSize", ";", "}", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "AVR", "::", "R29R28", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ";", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "\"Can only insert epilog into returning blocks\"", "AVR", "AVR", "AVR", "AVR::POPRd", "AVR::POPWRd", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::R29R28", "AVR::R29R28", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R29R28" ]

[]

[ "<s>", "bool", "MSP430PassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", "->", "add", "(", "createMSP430BranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "SIMemoryLegalizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "SIMemOpAccess", "MOA", "(", "MF", ")", ";", "CC", "=", "SICacheControl", "::", "create", "(", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "maybeAtomic", ")", ")", "continue", ";", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getLoadInfo", "(", "MI", ")", ")", "Changed", "|=", "expandLoad", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getStoreInfo", "(", "MI", ")", ")", "Changed", "|=", "expandStore", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicFenceInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicFence", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "else", "if", "(", "const", "auto", "&", "MOI", "=", "MOA", ".", "getAtomicCmpxchgOrRmwInfo", "(", "MI", ")", ")", "Changed", "|=", "expandAtomicCmpxchgOrRmw", "(", "MOI", ".", "getValue", "(", ")", ",", "MI", ")", ";", "}", "}", "Changed", "|=", "removeAtomicPseudoMIs", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SIInstrFlags::maybeAtomic" ]

[]

[ "<s>", "NVPTXSubtarget", "&", "NVPTXSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "TargetName", "=", "std", "::", "string", "(", "CPU", ".", "empty", "(", ")", "?", "\"sm_20\"", ":", "CPU", ")", ";", "ParseSubtargetFeatures", "(", "TargetName", ",", "FS", ")", ";", "if", "(", "PTXVersion", "==", "0", ")", "{", "PTXVersion", "=", "32", ";", "}", "return", "*", "this", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "\"sm_20\"", "0", "32" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Spill callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</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", "(", ")", "." ]

[ "ARC", "ARC", "\"Spill callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "enum", "calling_abi", "ix86_function_type_abi", "(", "const_tree", "fntype", ")", "{", "enum", "calling_abi", "abi", "=", "ix86_abi", ";", "if", "(", "fntype", "==", "NULL_TREE", "||", "TYPE_ATTRIBUTES", "(", "fntype", ")", "==", "NULL_TREE", ")", "return", "abi", ";", "if", "(", "abi", "==", "SYSV_ABI", "&&", "lookup_attribute", "(", "\"ms_abi\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "{", "static", "int", "warned", ";", "if", "(", "TARGET_X32", "&&", "!", "warned", ")", "{", "error", "(", "\"X32 does not support ms_abi attribute\"", ")", ";", "warned", "=", "1", ";", "}", "abi", "=", "MS_ABI", ";", "}", "else", "if", "(", "abi", "==", "MS_ABI", "&&", "lookup_attribute", "(", "\"sysv_abi\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "abi", "=", "SYSV_ABI", ";", "return", "abi", ";", "}", "</s>" ]

[ "Returns", "value", "SYSV_ABI", ",", "MS_ABI", "dependent", "on", "fntype", ",", "specifying", "the", "call", "abi", "used", "." ]

[ "i386", "\"ms_abi\"", "\"X32 does not support ms_abi attribute\"", "1", "\"sysv_abi\"" ]

[]

[ "<s>", "DecodeStatus", "TL45Disassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "support", "::", "endian", "::", "read32be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "TL45", "TL45", "4", "0", "support::endian", "4" ]

[]

[ "<s>", "static", "unsigned", "int", "arc_autovectorize_vector_sizes", "(", "void", ")", "{", "return", "TARGET_PLUS_QMACW", "?", "(", "8", "|", "4", ")", ":", "0", ";", "}", "</s>" ]

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

[ "arc", "8", "4", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "Trunc", "==", "Imm", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "{", "if", "(", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "if", "(", "!", "(", "Imm", "&", "0xffff", ")", ")", "{", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Imm", ">>", "16", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "16", "AMDGPU::isInlinableLiteral16", "0xffff", "AMDGPU::isInlinableLiteral16", "16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "tree", "mips_build_va_list", "(", ")", "{", "if", "(", "mips_abi", "==", "ABI_EABI", "&&", "!", "TARGET_SOFT_FLOAT", "&&", "!", "TARGET_SINGLE_FLOAT", ")", "{", "tree", "f_ovfl", ",", "f_gtop", ",", "f_ftop", ",", "f_goff", ",", "f_foff", ",", "record", ";", "record", "=", "make_node", "(", "RECORD_TYPE", ")", ";", "f_ovfl", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__overflow_argptr\"", ")", ",", "ptr_type_node", ")", ";", "f_gtop", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_ftop", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_top\"", ")", ",", "ptr_type_node", ")", ";", "f_goff", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr_offset\"", ")", ",", "unsigned_char_type_node", ")", ";", "f_foff", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr_offset\"", ")", ",", "unsigned_char_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_ovfl", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_gtop", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ftop", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_goff", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_foff", ")", "=", "record", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_ovfl", ";", "TREE_CHAIN", "(", "f_ovfl", ")", "=", "f_gtop", ";", "TREE_CHAIN", "(", "f_gtop", ")", "=", "f_ftop", ";", "TREE_CHAIN", "(", "f_ftop", ")", "=", "f_goff", ";", "TREE_CHAIN", "(", "f_goff", ")", "=", "f_foff", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "else", "return", "ptr_type_node", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", ".", "We", "keep", "3", "pointers", ",", "and", "two", "offsets", ".", "Two", "pointers", "are", "to", "the", "overflow", "area", ",", "which", "starts", "at", "the", "CFA", ".", "One", "of", "these", "is", "constant", ",", "for", "addressing", "into", "the", "GPR", "save", "area", "below", "it", ".", "The", "other", "is", "advanced", "up", "the", "stack", "through", "the", "overflow", "region", ".", "The", "third", "pointer", "is", "to", "the", "GPR", "save", "area", ".", "Since", "the", "FPR", "save", "area", "is", "just", "below", "it", ",", "we", "can", "address", "FPR", "slots", "off", "this", "pointer", ".", "We", "also", "keep", "two", "one-byte", "offsets", ",", "which", "are", "to", "be", "subtracted", "from", "the", "constant", "pointers", "to", "yield", "addresses", "in", "the", "GPR", "and", "FPR", "save", "areas", ".", "These", "are", "downcounted", "as", "float", "or", "non-float", "arguments", "are", "used", ",", "and", "when", "they", "get", "to", "zero", ",", "the", "argument", "must", "be", "obtained", "from", "the", "overflow", "region", ".", "If", "TARGET_SOFT_FLOAT", "or", "TARGET_SINGLE_FLOAT", ",", "then", "no", "FPR", "save", "area", "exists", ",", "and", "a", "single", "pointer", "is", "enough", ".", "It", "'s", "started", "at", "the", "GPR", "save", "area", ",", "and", "is", "advanced", ",", "period", ".", "Note", "that", "the", "GPR", "save", "area", "is", "not", "constant", "size", ",", "due", "to", "optimization", "in", "the", "prologue", ".", "Hence", ",", "we", "ca", "n't", "use", "a", "design", "with", "two", "pointers", "and", "two", "offsets", ",", "although", "we", "could", "have", "designed", "this", "with", "two", "pointers", "and", "three", "offsets", "." ]

[ "mips", "\"__overflow_argptr\"", "\"__gpr_top\"", "\"__fpr_top\"", "\"__gpr_offset\"", "\"__fpr_offset\"" ]

[]

[ "<s>", "static", "rtx", "rs6000_internal_arg_pointer", "(", "void", ")", "{", "if", "(", "flag_split_stack", "&&", "(", "lookup_attribute", "(", "\"no_split_stack\"", ",", "DECL_ATTRIBUTES", "(", "cfun", "->", "decl", ")", ")", "==", "NULL", ")", ")", "{", "if", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "==", "NULL_RTX", ")", "{", "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "1", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ")", ";", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "pat", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ")", ";", "}", "return", "virtual_incoming_args_rtx", ";", "}", "</s>" ]

[ "Return", "the", "internal", "arg", "pointer", "used", "for", "function", "incoming", "arguments", ".", "When", "-fsplit-stack", ",", "the", "arg", "pointer", "is", "r12", "so", "we", "need", "to", "copy", "it", "to", "a", "pseudo", "in", "order", "for", "it", "to", "be", "preserved", "over", "calls", "and", "suchlike", ".", "We", "'d", "really", "like", "to", "use", "a", "pseudo", "here", "for", "the", "internal", "arg", "pointer", "but", "data-flow", "analysis", "is", "not", "prepared", "to", "accept", "pseudos", "as", "live", "at", "the", "beginning", "of", "a", "function", "." ]

[ "rs6000", "\"no_split_stack\"", "1", "12" ]

[]

[ "<s>", "void", "BTFDebug", "::", "emitCommonHeader", "(", ")", "{", "OS", ".", "AddComment", "(", "\"0x\"", "+", "Twine", "::", "utohexstr", "(", "BTF", "::", "MAGIC", ")", ")", ";", "OS", ".", "emitIntValue", "(", "BTF", "::", "MAGIC", ",", "2", ")", ";", "OS", ".", "emitInt8", "(", "BTF", "::", "VERSION", ")", ";", "OS", ".", "emitInt8", "(", "0", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "part", "of", "the", "header", "for", "this", "unit", "." ]

[ "BPF", "\"0x\"", "BTF::MAGIC", "BTF::MAGIC", "2", "BTF::VERSION", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "RegName", "=", "[", "]", "(", "unsigned", "Reg", ")", "{", "if", "(", "Reg", ")", "return", "RISCVInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "else", "return", "\"noreg\"", ";", "}", ";", "switch", "(", "Kind", ")", "{", "case", "KindTy", "::", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"<register \"", "<<", "RegName", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "KindTy", "::", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "KindTy", "::", "SystemRegister", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "KindTy", "::", "VType", ":", "OS", "<<", "\"<vtype: \"", ";", "RISCVVType", "::", "printVType", "(", "getVType", "(", ")", ",", "OS", ")", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

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

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "unsigned", "M68kOperand", "::", "getReg", "(", ")", "const", "{", "assert", "(", "isReg", "(", ")", ")", ";", "return", "MemOp", ".", "OuterReg", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "int", "PPCInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "int", "Latency", "=", "PPCGenInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "!", "DefMI", ".", "getParent", "(", ")", ")", "return", "Latency", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "Register", "Reg", "=", "DefMO", ".", "getReg", "(", ")", ";", "bool", "IsRegCR", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "DefMI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "IsRegCR", "=", "MRI", "->", "getRegClass", "(", "Reg", ")", "->", "hasSuperClassEq", "(", "&", "PPC", "::", "CRRCRegClass", ")", "||", "MRI", "->", "getRegClass", "(", "Reg", ")", "->", "hasSuperClassEq", "(", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "else", "{", "IsRegCR", "=", "PPC", "::", "CRRCRegClass", ".", "contains", "(", "Reg", ")", "||", "PPC", "::", "CRBITRCRegClass", ".", "contains", "(", "Reg", ")", ";", "}", "if", "(", "UseMI", ".", "isBranch", "(", ")", "&&", "IsRegCR", ")", "{", "if", "(", "Latency", "<", "0", ")", "Latency", "=", "getInstrLatency", "(", "ItinData", ",", "DefMI", ")", ";", "unsigned", "Directive", "=", "Subtarget", ".", "getCPUDirective", "(", ")", ";", "switch", "(", "Directive", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_7400", ":", "case", "PPC", "::", "DIR_750", ":", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_E5500", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "Latency", "+=", "2", ";", "break", ";", "}", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "0", "PPC::DIR_7400", "PPC::DIR_750", "PPC::DIR_970", "PPC::DIR_E5500", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "2" ]

[]

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

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

[ "HSAIL", "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isSafeMemOpType", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "Subtarget", ".", "hasSSE1", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "Subtarget", ".", "hasSSE2", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "'s", "safe", "to", "use", "load", "/", "store", "of", "the", "specified", "type", "to", "expand", "memcpy", "/", "memset", "inline", "." ]

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

[]

[ "<s>", "void", "function_builder", "::", "append_base_name", "(", "const", "char", "*", "name", ")", "{", "append_name", "(", "\"__riscv_\"", ")", ";", "append_name", "(", "name", ")", ";", "}", "</s>" ]

[ "Add", "``", "__riscv_", "''", "and", "``", "name", "''", "." ]

[ "riscv", "\"__riscv_\"" ]

[]

[ "<s>", "static", "rtx", "m32c_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "fprintf", "(", "stderr", ",", "\"m32c_legitimize_address for mode %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "FB_REGNO", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "-", "128", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "(", "128", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "copy_rtx", "(", "x", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "temp", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "temp", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Implements", "LEGITIMIZE_ADDRESS", ".", "The", "only", "address", "we", "really", "have", "to", "worry", "about", "is", "frame", "base", "offsets", ",", "as", "$", "fb", "has", "a", "limited", "displacement", "range", ".", "We", "deal", "with", "this", "by", "attempting", "to", "reload", "$", "fb", "itself", "into", "an", "address", "register", ";", "that", "seems", "to", "result", "in", "the", "best", "code", "." ]

[ "m32c", "\"m32c_legitimize_address for mode %s\\n\"", "\"\\n\"", "0", "0", "1", "1", "128", "1", "128", "0", "0" ]

[]

[ "<s>", "inline", "static", "const", "char", "*", "getTagName", "(", "TAGS", "tag", ")", "{", "switch", "(", "tag", ")", "{", "default", ":", "return", "\"\"", ";", "case", "PREFIX_SYMBOL", ":", "return", "\"@\"", ";", "case", "AUTOS_LABEL", ":", "return", "\".auto.\"", ";", "case", "FRAME_LABEL", ":", "return", "\".frame.\"", ";", "case", "TEMPS_LABEL", ":", "return", "\".temp.\"", ";", "case", "ARGS_LABEL", ":", "return", "\".args.\"", ";", "case", "RET_LABEL", ":", "return", "\".ret.\"", ";", "case", "LIBCALL", ":", "return", "\".lib.\"", ";", "case", "FRAME_SECTION", ":", "return", "\".frame_section.\"", ";", "case", "AUTOS_SECTION", ":", "return", "\".autos_section.\"", ";", "case", "CODE_SECTION", ":", "return", "\".code_section.\"", ";", "}", "}", "</s>" ]

[ "Return", "the", "tag", "of", "this", "operand", "bundle", "as", "a", "string", "." ]

[ "PIC16", "\"\"", "\"@\"", "\".auto.\"", "\".frame.\"", "\".temp.\"", "\".args.\"", "\".ret.\"", "\".lib.\"", "\".frame_section.\"", "\".autos_section.\"", "\".code_section.\"" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", "0", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "llvm", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", "0", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "0", "1", "0" ]

[]

[ "<s>", "rtx", "expand_builtin", "(", "unsigned", "int", "code", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "registered_function", "&", "rfn", "=", "*", "(", "*", "registered_functions", ")", "[", "code", "]", ";", "return", "function_expander", "(", "rfn", ".", "instance", ",", "rfn", ".", "decl", ",", "exp", ",", "target", ")", ".", "expand", "(", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "the", "RVV", "function", "with", "subcode", "CODE", ".", "EXP", "is", "the", "call", "expression", "and", "TARGET", "is", "the", "preferred", "location", "for", "the", "result", ".", "Return", "the", "value", "of", "the", "lhs", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "rs6000_expand_atomic_exchange", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "retval", ",", "mem", ",", "val", ",", "cond", ";", "machine_mode", "mode", ";", "enum", "memmodel", "model", ";", "rtx", "label", ",", "x", ",", "mask", ",", "shift", ";", "retval", "=", "operands", "[", "0", "]", ";", "mem", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "model", "=", "(", "enum", "memmodel", ")", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "mask", "=", "shift", "=", "NULL_RTX", ";", "if", "(", "!", "TARGET_SYNC_HI_QI", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", ")", "{", "mem", "=", "rs6000_adjust_atomic_subword", "(", "mem", ",", "&", "shift", ",", "&", "mask", ")", ";", "val", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "val", ",", "1", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "val", ",", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "retval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mode", "=", "SImode", ";", "}", "mem", "=", "rs6000_pre_atomic_barrier", "(", "mem", ",", "model", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "x", "=", "val", ";", "if", "(", "mask", ")", "x", "=", "rs6000_mask_atomic_subword", "(", "retval", ",", "val", ",", "mask", ")", ";", "cond", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "x", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "rs6000_post_atomic_barrier", "(", "model", ")", ";", "if", "(", "shift", ")", "rs6000_finish_atomic_subword", "(", "operands", "[", "0", "]", ",", "retval", ",", "shift", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "exchange", "operation", "." ]

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

[]

[ "<s>", "static", "bool", "arc_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "||", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Given", "FROM", "and", "TO", "register", "numbers", ",", "say", "whether", "this", "elimination", "is", "allowed", ".", "Frame", "pointer", "elimination", "is", "automatically", "handled", ".", "All", "eliminations", "are", "permissible", ".", "If", "we", "need", "a", "frame", "pointer", ",", "we", "must", "eliminate", "ARG_POINTER_REGNUM", "into", "FRAME_POINTER_REGNUM", "and", "not", "into", "STACK_POINTER_REGNUM", "." ]

[ "arc" ]

[]

[ "<s>", "static", "rtx", "riscv_unspec_address_offset", "(", "rtx", "base", ",", "rtx", "offset", ",", "enum", "riscv_symbol_type", "symbol_type", ")", "{", "base", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "base", ")", ",", "UNSPEC_ADDRESS_FIRST", "+", "symbol_type", ")", ";", "if", "(", "offset", "!=", "const0_rtx", ")", "base", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "return", "gen_rtx_CONST", "(", "Pmode", ",", "base", ")", ";", "}", "</s>" ]

[ "Wrap", "symbol", "or", "label", "BASE", "in", "an", "UNSPEC", "address", "of", "type", "SYMBOL_TYPE", ",", "then", "add", "CONST_INT", "OFFSET", "to", "the", "result", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "uint32_t", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "static_cast", "<", "uint8_t", ">", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "AMDGPU", "AMDGPU", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "parse_codes", "parse_bif_stanza", "(", "void", ")", "{", "pos", "=", "0", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'['", ")", "{", "diag", "(", "pos", ",", "\"ill-formed stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "const", "char", "*", "stanza_name", "=", "match_to_right_bracket", "(", ")", ";", "if", "(", "!", "stanza_name", ")", "{", "diag", "(", "pos", ",", "\"no expression found in stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "curr_bif_stanza", "=", "stanza_name_to_stanza", "(", "stanza_name", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "']'", ")", "{", "diag", "(", "pos", ",", "\"ill-formed stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "safe_inc_pos", "(", ")", ";", "consume_whitespace", "(", ")", ";", "if", "(", "linebuf", "[", "pos", "]", "!=", "'\\n'", "&&", "pos", "!=", "LINELEN", "-", "1", ")", "{", "diag", "(", "pos", ",", "\"garbage after stanza header.\\n\"", ")", ";", "return", "PC_PARSEFAIL", ";", "}", "parse_codes", "result", "=", "PC_OK", ";", "while", "(", "result", "!=", "PC_EOSTANZA", ")", "{", "if", "(", "!", "advance_line", "(", "bif_file", ")", ")", "return", "PC_EOFILE", ";", "result", "=", "parse_bif_entry", "(", ")", ";", "if", "(", "result", "==", "PC_PARSEFAIL", ")", "return", "PC_PARSEFAIL", ";", "}", "return", "PC_OK", ";", "}", "</s>" ]

[ "Parse", "one", "stanza", "of", "the", "input", "BIF", "file", ".", "linebuf", "already", "contains", "the", "first", "line", "to", "parse", "." ]

[ "rs6000", "0", "\"ill-formed stanza header.\\n\"", "\"no expression found in stanza header.\\n\"", "\"ill-formed stanza header.\\n\"", "1", "\"garbage after stanza header.\\n\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "Register", "ExtReg", "=", "extendRegisterMin32", "(", "*", "this", ",", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ExtReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "MachinePointerInfo", "Cpu0MachineFunctionInfo", "::", "callPtrInfo", "(", "const", "GlobalValue", "*", "GV", ")", "{", "return", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getGlobalValueCallEntry", "(", "GV", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemmove", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "const", "AArch64Subtarget", "&", "STI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "hasMOPS", "(", ")", ")", "{", "return", "EmitMOPS", "(", "AArch64ISD", "::", "MOPS_MEMMOVE", ",", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Alignment", ",", "isVolatile", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memmove", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64ISD::MOPS_MEMMOVE" ]

[]

[ "<s>", "void", "sparc_expand_vcond", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ",", "int", "ccode", ",", "int", "fcode", ")", "{", "rtx", "mask", ",", "cop0", ",", "cop1", ",", "fcmp", ",", "cmask", ",", "bshuf", ",", "gsr", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "mask", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "cop0", "=", "operands", "[", "4", "]", ";", "cop1", "=", "operands", "[", "5", "]", ";", "if", "(", "code", "==", "LT", "||", "code", "==", "GE", ")", "{", "rtx", "t", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "t", "=", "cop0", ";", "cop0", "=", "cop1", ";", "cop1", "=", "t", ";", "}", "gsr", "=", "gen_rtx_REG", "(", "DImode", ",", "SPARC_GSR_REG", ")", ";", "fcmp", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cop0", ",", "cop1", ")", ")", ",", "fcode", ")", ";", "cmask", "=", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "2", ",", "mask", ",", "gsr", ")", ",", "ccode", ")", ";", "bshuf", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "gsr", ")", ",", "UNSPEC_BSHUFFLE", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "fcmp", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gsr", ",", "cmask", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "bshuf", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "conditionally", "move", "a", "combination", "of", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "into", "OPERANDS", "[", "0", "]", "in", "MODE", ",", "depending", "on", "the", "outcome", "of", "the", "comparison", "of", "OPERANDS", "[", "4", "]", "and", "OPERANDS", "[", "5", "]", ".", "OPERANDS", "[", "3", "]", "is", "the", "operator", "of", "the", "condition", ".", "FCODE", "is", "the", "machine", "code", "to", "be", "used", "for", "OPERANDS", "[", "3", "]", "and", "CCODE", "the", "machine", "code", "to", "be", "used", "for", "the", "condition", "mask", "." ]

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

[]

[ "<s>", "inline", "void", "function_expander", "::", "add_input_operand", "(", "machine_mode", "mode", ",", "rtx", "op", ")", "{", "create_input_operand", "(", "&", "m_ops", "[", "opno", "++", "]", ",", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Create", "op", "and", "add", "it", "into", "M_OPS", "and", "increase", "OPNO", "." ]

[ "riscv" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "csky_minipool_load_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "op1", ",", "addr", ";", "extract_insn_cached", "(", "insn", ")", ";", "op1", "=", "recog_data", ".", "operand", "[", "1", "]", ";", "if", "(", "CONSTANT_P", "(", "op1", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "ZERO_EXTEND", "||", "GET_CODE", "(", "op1", ")", "==", "SIGN_EXTEND", ")", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "MEM", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "return", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "a", "minipool", "load", "or", "instruction", "that", "will", "be", "converted", "to", "one", ".", "It", "is", "assumed", "that", "INSN", "has", "type", "attribute", "``", "load", "''", "." ]

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

[]

[ "<s>", "unsigned", "ARMCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "II", "->", "getRegisterInfo", "(", ")", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ",", "true", ",", "false", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "unsigned", "Reloc", "=", "(", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "FormMask", ")", "==", "ARMII", "::", "VFPLdStFrm", ")", "?", "ARM", "::", "reloc_arm_vfp_cp_entry", ":", "ARM", "::", "reloc_arm_cp_entry", ";", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "Reloc", ")", ";", "}", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "ARM", "::", "reloc_arm_relative", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "ARM", "::", "reloc_arm_branch", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "32", "ARM::reloc_arm_branch", "ARM::reloc_arm_branch", "ARMII::FormMask", "ARMII::VFPLdStFrm", "ARM::reloc_arm_vfp_cp_entry", "ARM::reloc_arm_cp_entry", "ARM::reloc_arm_relative", "ARM::reloc_arm_branch", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "AArch64", "AArch64" ]

[]

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

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

[ "VE", "VE" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".option\"", ")", "return", "parseDirectiveOption", "(", ")", ";", "else", "if", "(", "IDVal", "==", "\".attribute\"", ")", "return", "parseDirectiveAttribute", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "RISCV", "RISCV", "\".option\"", "\".attribute\"" ]

[]

[ "<s>", "bool", "NEONPreAllocPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "Modified", "|=", "PreAllocNEONRegisters", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "aarch64_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "&&", "!", "optimize_size", ")", "return", "MAX", "(", "align", ",", "BITS_PER_WORD", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", ".", "Make", "strings", "word-aligned", "so", "that", "strcpy", "from", "constants", "will", "be", "faster", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64ConditionalCompares", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Compares **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SchedModel", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getSchedModel", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomTree", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Loops", "=", "getAnalysisIfAvailable", "<", "MachineLoopInfo", ">", "(", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "MinSize", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "bool", "Changed", "=", "false", ";", "CmpConv", ".", "runOnMachineFunction", "(", "MF", ")", ";", "for", "(", "auto", "*", "I", ":", "depth_first", "(", "DomTree", ")", ")", "if", "(", "tryConvert", "(", "I", "->", "getBlock", "(", ")", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Compares **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "isa", "<", "PointerType", ">", "(", "ScalarTy", ")", "?", "DL", ".", "getPointerSizeInBits", "(", ")", ":", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "(", "DataWidth", "==", "32", "||", "DataWidth", "==", "64", ")", "&&", "ST", "->", "hasAVX", "(", ")", ")", "||", "(", "(", "DataWidth", "==", "8", "||", "DataWidth", "==", "16", ")", "&&", "ST", "->", "hasBWI", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "32", "64", "8", "16" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "return", "false", ";", "case", "MatchOperand_ParseFail", ":", "return", "Error", "(", "NameLoc", ",", "\"Failed parsing operand\"", ")", ";", "case", "MatchOperand_NoMatch", ":", "return", "Error", "(", "NameLoc", ",", "\"Not a valid operand\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "R600", "\"Failed parsing operand\"", "\"Not a valid operand\"" ]

[]

[ "<s>", "unsigned", "ARMMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "ARM", "::", "HasMVEIntegerOps", "]", ")", "return", "RegNo", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "RegNo", ";", "case", "ARM", "::", "Q0", ":", "case", "ARM", "::", "Q1", ":", "case", "ARM", "::", "Q2", ":", "case", "ARM", "::", "Q3", ":", "case", "ARM", "::", "Q4", ":", "case", "ARM", "::", "Q5", ":", "case", "ARM", "::", "Q6", ":", "case", "ARM", "::", "Q7", ":", "case", "ARM", "::", "Q8", ":", "case", "ARM", "::", "Q9", ":", "case", "ARM", "::", "Q10", ":", "case", "ARM", "::", "Q11", ":", "case", "ARM", "::", "Q12", ":", "case", "ARM", "::", "Q13", ":", "case", "ARM", "::", "Q14", ":", "case", "ARM", "::", "Q15", ":", "return", "2", "*", "RegNo", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isDFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "bit_cast", "<", "double", ">", "(", "MO", ".", "getDFPImm", "(", ")", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "llvm_unreachable", "(", "\"Unable to encode MCOperand!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::HasMVEIntegerOps", "ARM::Q0", "ARM::Q1", "ARM::Q2", "ARM::Q3", "ARM::Q4", "ARM::Q5", "ARM::Q6", "ARM::Q7", "ARM::Q8", "ARM::Q9", "ARM::Q10", "ARM::Q11", "ARM::Q12", "ARM::Q13", "ARM::Q14", "ARM::Q15", "2", "32", "\"Unable to encode MCOperand!\"" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "IsBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "void", "*", "Decoder", ")", "{", "const", "MCDisassembler", "*", "Dis", "=", "static_cast", "<", "const", "MCDisassembler", "*", ">", "(", "Decoder", ")", ";", "return", "Dis", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "IsBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "DLX" ]

[]

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

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

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

[]

[ "<s>", "bool", "GBZ80PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createGBZ80ISelDAG", "(", "getGBZ80TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "mergeSPUpdates", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "bool", "doMergeWithPrevious", ")", "const", "{", "if", "(", "(", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "begin", "(", ")", ")", "||", "(", "!", "doMergeWithPrevious", "&&", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", ")", "return", "0", ";", "MachineBasicBlock", "::", "iterator", "PI", "=", "doMergeWithPrevious", "?", "std", "::", "prev", "(", "MBBI", ")", ":", "MBBI", ";", "PI", "=", "skipDebugInstructionsBackward", "(", "PI", ",", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "doMergeWithPrevious", "&&", "PI", "!=", "MBB", ".", "begin", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "PI", "=", "std", "::", "prev", "(", "PI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "int", "Offset", "=", "0", ";", "if", "(", "(", "Opc", "==", "X86", "::", "ADD64ri32", "||", "Opc", "==", "X86", "::", "ADD64ri8", "||", "Opc", "==", "X86", "::", "ADD32ri", "||", "Opc", "==", "X86", "::", "ADD32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "LEA32r", "||", "Opc", "==", "X86", "::", "LEA64_32r", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", "&&", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "1", "&&", "PI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", "&&", "PI", "->", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", "==", "X86", "::", "NoRegister", ")", "{", "Offset", "=", "PI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "(", "Opc", "==", "X86", "::", "SUB64ri32", "||", "Opc", "==", "X86", "::", "SUB64ri8", "||", "Opc", "==", "X86", "::", "SUB32ri", "||", "Opc", "==", "X86", "::", "SUB32ri8", ")", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", "{", "assert", "(", "PI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "StackPtr", ")", ";", "Offset", "=", "-", "PI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "return", "0", ";", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "PI", "!=", "MBB", ".", "end", "(", ")", "&&", "PI", "->", "isCFIInstruction", "(", ")", ")", "PI", "=", "MBB", ".", "erase", "(", "PI", ")", ";", "if", "(", "!", "doMergeWithPrevious", ")", "MBBI", "=", "skipDebugInstructionsForward", "(", "PI", ",", "MBB", ".", "end", "(", ")", ")", ";", "return", "Offset", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "X86::ADD64ri32", "X86::ADD64ri8", "X86::ADD32ri", "X86::ADD32ri8", "0", "1", "2", "X86::LEA32r", "X86::LEA64_32r", "0", "1", "2", "1", "3", "X86::NoRegister", "5", "X86::NoRegister", "4", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "analyzeLoop", "(", "MachineLoop", "&", "L", ",", "MachineInstr", "*", "&", "IndVarInst", ",", "MachineInstr", "*", "&", "CmpInst", ")", "const", "{", "MachineBasicBlock", "*", "LoopEnd", "=", "L", ".", "getBottomBlock", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "LoopEnd", "->", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "!=", "LoopEnd", "->", "end", "(", ")", "&&", "isBDNZ", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "IndVarInst", "=", "nullptr", ";", "CmpInst", "=", "&", "*", "I", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Analyze", "the", "loop", "code", ",", "return", "true", "if", "it", "can", "not", "be", "understood", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Imm", ".", "isPosZero", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f32", ")", ")", "return", "true", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "ARM64_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "ARM64_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "MVT::f64", "MVT::f32", "MVT::f64", "ARM64_AM::getFP64Imm", "1", "MVT::f32", "ARM64_AM::getFP32Imm", "1" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "i", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "</s>" ]

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

[ "TOY", "0", "8", "0xff" ]

[]

[ "<s>", "static", "int", "mem_is_padded_component_ref", "(", "rtx", "x", ")", "{", "tree", "t", "=", "MEM_EXPR", "(", "x", ")", ";", "tree", "r", ";", "if", "(", "!", "t", "||", "TREE_CODE", "(", "t", ")", "!=", "COMPONENT_REF", ")", "return", "0", ";", "t", "=", "TREE_OPERAND", "(", "t", ",", "1", ")", ";", "if", "(", "!", "t", "||", "TREE_CODE", "(", "t", ")", "!=", "FIELD_DECL", "||", "DECL_ALIGN", "(", "t", ")", "<", "128", "||", "AGGREGATE_TYPE_P", "(", "TREE_TYPE", "(", "t", ")", ")", ")", "return", "0", ";", "r", "=", "DECL_FIELD_CONTEXT", "(", "t", ")", ";", "if", "(", "!", "r", "||", "TREE_CODE", "(", "r", ")", "!=", "RECORD_TYPE", ")", "return", "0", ";", "if", "(", "GET_MODE", "(", "x", ")", "!=", "TYPE_MODE", "(", "TREE_TYPE", "(", "t", ")", ")", ")", "return", "0", ";", "if", "(", "TREE_CHAIN", "(", "t", ")", "==", "0", ")", "return", "1", ";", "t", "=", "TREE_CHAIN", "(", "t", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "==", "FIELD_DECL", "&&", "DECL_ALIGN", "(", "t", ")", ">=", "128", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "MEM", "which", "is", "a", "struct", "member", "reference", "and", "the", "member", "can", "safely", "be", "loaded", "and", "stored", "with", "a", "single", "instruction", "because", "it", "is", "padded", "." ]

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

[]

[ "<s>", "void", "order_regs_for_local_alloc", "(", "void", ")", "{", "static", "int", "last_order_nonleaf", "=", "1", ";", "if", "(", "df_regs_ever_live_p", "(", "15", ")", "!=", "last_order_nonleaf", ")", "{", "last_order_nonleaf", "=", "!", "last_order_nonleaf", ";", "memcpy", "(", "(", "char", "*", ")", "reg_alloc_order", ",", "(", "const", "char", "*", ")", "reg_alloc_orders", "[", "last_order_nonleaf", "]", ",", "FIRST_PSEUDO_REGISTER", "*", "sizeof", "(", "int", ")", ")", ";", "}", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "sparc", "1", "15" ]

[]

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

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

[ "i386" ]

[]

[ "<s>", "VariantKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "VE" ]

[]

[ "<s>", "unsigned", "getMaxInlineSizeThreshold", "(", ")", "const", "{", "return", "64", ";", "}", "</s>" ]

[ "Returns", "the", "maximum", "memset", "/", "memcpy", "size", "that", "still", "makes", "it", "profitable", "to", "inline", "the", "call", "." ]

[ "AArch64", "64" ]

[]

[ "<s>", "bool", "OR1KInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "OR1K", "::", "JR", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "OR1K", "::", "J", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "0", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "0", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "OR1K", "OR1K", "OR1K::JR", "OR1K::J", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "bool", "FPGATTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "FPGA", "FPGA" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldNormalizeToSelectSequence", "(", "LLVMContext", "&", ",", "EVT", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "we", "should", "normalize", "select", "(", "N0", "&", "N1", ",", "X", ",", "Y", ")", "=", ">", "select", "(", "N0", ",", "select", "(", "N1", ",", "X", ",", "Y", ")", ",", "Y", ")", "and", "select", "(", "N0|N1", ",", "X", ",", "Y", ")", "=", ">", "select", "(", "N0", ",", "select", "(", "N1", ",", "X", ",", "Y", ",", "Y", ")", ")", "if", "it", "is", "likely", "that", "it", "saves", "us", "from", "materializing", "N0", "and", "N1", "in", "an", "integer", "register", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "invalid_e500_subreg", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "mode", "==", "SImode", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DFmode", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", "&&", "mode", "==", "DFmode", "&&", "REG_P", "(", "SUBREG_REG", "(", "op", ")", ")", "&&", "GET_MODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "DImode", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "an", "invalid", "SUBREG", "operation", "on", "the", "e500", "." ]

[ "rs6000" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Vector Combine\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Vector Combine\"" ]

[]

[ "<s>", "static", "void", "mips16_build_function_stub", "(", "void", ")", "{", "const", "char", "*", "fnname", ",", "*", "alias_name", ",", "*", "separator", ";", "char", "*", "secname", ",", "*", "stubname", ";", "tree", "stubdecl", ";", "unsigned", "int", "f", ";", "rtx", "symbol", ",", "alias", ";", "symbol", "=", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ";", "alias", "=", "mips16_local_alias", "(", "symbol", ")", ";", "fnname", "=", "targetm", ".", "strip_name_encoding", "(", "XSTR", "(", "symbol", ",", "0", ")", ")", ";", "alias_name", "=", "targetm", ".", "strip_name_encoding", "(", "XSTR", "(", "alias", ",", "0", ")", ")", ";", "secname", "=", "ACONCAT", "(", "(", "\".mips16.fn.\"", ",", "fnname", ",", "NULL", ")", ")", ";", "stubname", "=", "ACONCAT", "(", "(", "\"__fn_stub_\"", ",", "fnname", ",", "NULL", ")", ")", ";", "stubdecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "stubname", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "set_decl_section_name", "(", "stubdecl", ",", "secname", ")", ";", "DECL_RESULT", "(", "stubdecl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t# Stub function for %s (\"", ",", "current_function_name", "(", ")", ")", ";", "separator", "=", "\"\"", ";", "for", "(", "f", "=", "(", "unsigned", "int", ")", "crtl", "->", "args", ".", "info", ".", "fp_code", ";", "f", "!=", "0", ";", "f", ">>=", "2", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"%s%s\"", ",", "separator", ",", "(", "f", "&", "3", ")", "==", "1", "?", "\"float\"", ":", "\"double\"", ")", ";", "separator", "=", "\", \"", ";", "}", "fprintf", "(", "asm_out_file", ",", "\")\\n\"", ")", ";", "assemble_start_function", "(", "stubdecl", ",", "stubname", ")", ";", "mips_start_function_definition", "(", "stubname", ",", "false", ")", ";", "if", "(", "TARGET_ABICALLS_PIC2", ")", "{", "if", "(", "TARGET_ABSOLUTE_ABICALLS", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option\\tpic0\\n\"", ")", ";", "else", "{", "output_asm_insn", "(", "\"%(.cpload\\t%^%)\"", ",", "NULL", ")", ";", "output_asm_insn", "(", "\".reloc\\t0,R_MIPS_NONE,%0\"", ",", "&", "symbol", ")", ";", "symbol", "=", "alias", ";", "}", "}", "output_asm_insn", "(", "\"la\\t%^,%0\"", ",", "&", "symbol", ")", ";", "mips_output_args_xfer", "(", "crtl", "->", "args", ".", "info", ".", "fp_code", ",", "'f'", ")", ";", "output_asm_insn", "(", "\"jr\\t%^\"", ",", "NULL", ")", ";", "if", "(", "TARGET_ABICALLS_PIC2", "&&", "TARGET_ABSOLUTE_ABICALLS", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option\\tpic2\\n\"", ")", ";", "mips_end_function_definition", "(", "stubname", ")", ";", "ASM_OUTPUT_DEF", "(", "asm_out_file", ",", "alias_name", ",", "fnname", ")", ";", "switch_to_section", "(", "function_section", "(", "current_function_decl", ")", ")", ";", "}", "</s>" ]

[ "Write", "a", "MIPS16", "stub", "for", "the", "current", "function", ".", "This", "stub", "is", "used", "for", "functions", "which", "take", "arguments", "in", "the", "floating-point", "registers", ".", "It", "is", "normal-mode", "code", "that", "moves", "the", "floating-point", "arguments", "into", "the", "general", "registers", "and", "then", "jumps", "to", "the", "MIPS16", "code", "." ]

[ "mips", "0", "0", "0", "\".mips16.fn.\"", "\"__fn_stub_\"", "\"\\t# Stub function for %s (\"", "\"\"", "0", "2", "\"%s%s\"", "3", "1", "\"float\"", "\"double\"", "\", \"", "\")\\n\"", "\"\\t.option\\tpic0\\n\"", "\"%(.cpload\\t%^%)\"", "\".reloc\\t0,R_MIPS_NONE,%0\"", "\"la\\t%^,%0\"", "\"jr\\t%^\"", "\"\\t.option\\tpic2\\n\"" ]

[]

[ "<s>", "bool", "X86CallFrameOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TFL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isLegal", "(", "MF", ")", ")", "return", "false", ";", "unsigned", "FrameSetupOpcode", "=", "TII", "->", "getCallFrameSetupOpcode", "(", ")", ";", "bool", "Changed", "=", "false", ";", "ContextVector", "CallSeqVector", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "BB", "->", "begin", "(", ")", ";", "I", "!=", "BB", "->", "end", "(", ")", ";", "++", "I", ")", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "FrameSetupOpcode", ")", "{", "CallContext", "Context", ";", "collectCallInfo", "(", "MF", ",", "*", "BB", ",", "I", ",", "Context", ")", ";", "CallSeqVector", ".", "push_back", "(", "Context", ")", ";", "}", "if", "(", "!", "isProfitable", "(", "MF", ",", "CallSeqVector", ")", ")", "return", "false", ";", "for", "(", "auto", "CC", ":", "CallSeqVector", ")", "if", "(", "CC", ".", "UsePush", ")", "Changed", "|=", "adjustCallSequence", "(", "MF", ",", "CC", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "hasFusion", "(", ")", "const", "{", "return", "hasArithmeticBccFusion", "(", ")", "||", "hasArithmeticCbzFusion", "(", ")", "||", "hasFuseAES", "(", ")", "||", "hasFuseLiterals", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "CPU", "supports", "any", "kind", "of", "instruction", "fusion", "." ]

[ "AArch64" ]

[]

[ "<s>", "int", "legitimate_const_double_p", "(", "rtx", "address", ")", "{", "REAL_VALUE_TYPE", "r", ";", "long", "sval", "[", "2", "]", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "address", ")", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "r", ",", "sval", ")", ";", "if", "(", "(", "sval", "[", "0", "]", "&", "0xffff", ")", "==", "0", "&&", "sval", "[", "1", "]", "==", "0", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "This", "function", "checks", "whether", "a", "real", "value", "can", "be", "encoded", "as", "a", "literal", ",", "i.e.", ",", "addressing", "mode", "27", ".", "In", "that", "mode", ",", "real", "values", "are", "one", "word", "values", ",", "so", "the", "remaining", "48", "bits", "have", "to", "be", "zero", "." ]

[ "pdp11", "2", "0", "0xffff", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_cmov", "(", "rtx", "operands", "[", "]", ",", "int", "cmp_t", ",", "const", "char", "*", "test", ")", "{", "HOST_WIDE_INT", "load_value", ";", "HOST_WIDE_INT", "adjust_value", ";", "rtx", "out_operands", "[", "4", "]", ";", "out_operands", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "if", "(", "const_ok_for_mcore", "(", "INTVAL", "(", "operands", "[", "1", "]", ")", ")", ")", "{", "out_operands", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "out_operands", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "}", "else", "if", "(", "const_ok_for_mcore", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ")", "{", "out_operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "out_operands", "[", "2", "]", "=", "operands", "[", "1", "]", ";", "cmp_t", "=", "(", "cmp_t", "==", "0", ")", ";", "}", "load_value", "=", "INTVAL", "(", "out_operands", "[", "1", "]", ")", ";", "adjust_value", "=", "INTVAL", "(", "out_operands", "[", "2", "]", ")", ";", "if", "(", "test", ")", "output_asm_insn", "(", "test", ",", "operands", ")", ";", "if", "(", "load_value", ">=", "0", "&&", "load_value", "<=", "127", ")", "output_asm_insn", "(", "\"movi\\t%0,%1\"", ",", "out_operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_M", "(", "load_value", ")", ")", "output_asm_insn", "(", "\"bgeni\\t%0,%P1\"", ",", "out_operands", ")", ";", "else", "if", "(", "CONST_OK_FOR_N", "(", "load_value", ")", ")", "output_asm_insn", "(", "\"bmaski\\t%0,%N1\"", ",", "out_operands", ")", ";", "if", "(", "load_value", ">", "adjust_value", ")", "{", "if", "(", "cmp_t", ")", "output_asm_insn", "(", "\"decf\\t%0\"", ",", "out_operands", ")", ";", "else", "output_asm_insn", "(", "\"dect\\t%0\"", ",", "out_operands", ")", ";", "}", "else", "{", "if", "(", "cmp_t", ")", "output_asm_insn", "(", "\"incf\\t%0\"", ",", "out_operands", ")", ";", "else", "output_asm_insn", "(", "\"inct\\t%0\"", ",", "out_operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "conditional", "move", "of", "two", "constants", "that", "are", "+/-", "1", "within", "each", "other", ".", "See", "the", "``", "movtK", "''", "patterns", "in", "mcore.md", ".", "I", "'m", "not", "sure", "this", "is", "really", "worth", "the", "effort", "." ]

[ "mcore", "4", "0", "0", "1", "1", "1", "2", "2", "2", "1", "2", "2", "1", "0", "1", "2", "0", "127", "\"movi\\t%0,%1\"", "\"bgeni\\t%0,%P1\"", "\"bmaski\\t%0,%N1\"", "\"decf\\t%0\"", "\"dect\\t%0\"", "\"incf\\t%0\"", "\"inct\\t%0\"", "\"\"" ]

[]

[ "<s>", "static", "int", "xtensa_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "from", "==", "to", "&&", "from", "!=", "BR_REGS", "&&", "to", "!=", "BR_REGS", ")", "return", "2", ";", "else", "if", "(", "reg_class_subset_p", "(", "from", ",", "AR_REGS", ")", "&&", "reg_class_subset_p", "(", "to", ",", "AR_REGS", ")", ")", "return", "2", ";", "else", "if", "(", "reg_class_subset_p", "(", "from", ",", "AR_REGS", ")", "&&", "to", "==", "ACC_REG", ")", "return", "3", ";", "else", "if", "(", "from", "==", "ACC_REG", "&&", "reg_class_subset_p", "(", "to", ",", "AR_REGS", ")", ")", "return", "3", ";", "else", "return", "10", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_REGISTER_MOVE_COST", "." ]

[ "xtensa", "2", "2", "3", "3", "10" ]

[]