Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "loongarch_binary_cost", "(", "rtx", "x", ",", "int", "single_cost", ",", "int", "double_cost", ",", "bool", "speed", ")", "{", "int", "cost", ";", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "==", "UNITS_PER_WORD", "*", "2", ")", "cost", "=", "double_cost", ";", "else", "cost", "=", "single_cost", ";", "return", "(", "cost", "+", "set_src_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "GET_MODE", "(", "x", ")", ",", "speed", ")", "+", "rtx_cost", "(", "XEXP", "(", "x", ",", "1", ")", ",", "GET_MODE", "(", "x", ")", ",", "GET_CODE", "(", "x", ")", ",", "1", ",", "speed", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "binary", "operation", "X", ",", "given", "that", "the", "instruction", "sequence", "for", "a", "word-sized", "or", "smaller", "operation", "has", "cost", "SINGLE_COST", "and", "that", "the", "sequence", "of", "a", "double-word", "operation", "has", "cost", "DOUBLE_COST", ".", "If", "SPEED", "is", "true", ",", "optimize", "for", "speed", "otherwise", "optimize", "for", "size", "." ]

[ "loongarch", "2", "0", "1", "1" ]

[]

[ "<s>", "void", "F2003fInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "F2003f", "::", "KRZrm", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addReg", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003f::KRZrm", "0", "0" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", "{", "Type", "*", "Ty", "=", "GV", "->", "getValueType", "(", ")", ";", "return", "IsInSmallSection", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "Comet2", "Comet2" ]

[]

[ "<s>", "static", "inline", "const", "MachineInstrBuilder", "&", "addMemOperand", "(", "const", "MachineInstrBuilder", "&", "MIB", ",", "int", "FI", ",", "int", "Offset", "=", "0", ")", "{", "MachineInstr", "*", "MI", "=", "MIB", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "auto", "Flags", "=", "MachineMemOperand", "::", "MONone", ";", "if", "(", "MCID", ".", "mayLoad", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "if", "(", "MCID", ".", "mayStore", "(", ")", ")", "Flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ",", "Offset", ")", ",", "Flags", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "return", "MIB", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Add", "a", "MachineMemOperand", "to", "the", "machine", "instruction", "." ]

[ "M68k", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createMicroMipsSizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createMipsBranchExpansion", "(", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "m32r_expand_block_move", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "orig_dst", "=", "operands", "[", "0", "]", ";", "rtx", "orig_src", "=", "operands", "[", "1", "]", ";", "rtx", "bytes_rtx", "=", "operands", "[", "2", "]", ";", "rtx", "align_rtx", "=", "operands", "[", "3", "]", ";", "int", "constp", "=", "GET_CODE", "(", "bytes_rtx", ")", "==", "CONST_INT", ";", "HOST_WIDE_INT", "bytes", "=", "constp", "?", "INTVAL", "(", "bytes_rtx", ")", ":", "0", ";", "int", "align", "=", "INTVAL", "(", "align_rtx", ")", ";", "int", "leftover", ";", "rtx", "src_reg", ";", "rtx", "dst_reg", ";", "if", "(", "constp", "&&", "bytes", "<=", "0", ")", "return", "1", ";", "dst_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "orig_dst", ",", "0", ")", ")", ";", "src_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "orig_src", ",", "0", ")", ")", ";", "if", "(", "align", ">", "UNITS_PER_WORD", ")", "align", "=", "UNITS_PER_WORD", ";", "if", "(", "optimize_size", "||", "!", "constp", "||", "align", "!=", "UNITS_PER_WORD", ")", "{", "block_move_call", "(", "dst_reg", ",", "src_reg", ",", "bytes_rtx", ")", ";", "return", "0", ";", "}", "leftover", "=", "bytes", "%", "MAX_MOVE_BYTES", ";", "bytes", "-=", "leftover", ";", "if", "(", "bytes", ")", "{", "rtx", "label", "=", "NULL_RTX", ";", "rtx", "final_src", "=", "NULL_RTX", ";", "rtx", "at_a_time", "=", "GEN_INT", "(", "MAX_MOVE_BYTES", ")", ";", "rtx", "rounded_total", "=", "GEN_INT", "(", "bytes", ")", ";", "rtx", "new_dst_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "new_src_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "bytes", ">", "MAX_MOVE_BYTES", ")", "{", "final_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "INT16_P", "(", "bytes", ")", ")", "emit_insn", "(", "gen_addsi3", "(", "final_src", ",", "src_reg", ",", "rounded_total", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_movsi", "(", "final_src", ",", "rounded_total", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "final_src", ",", "final_src", ",", "src_reg", ")", ")", ";", "}", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "}", "emit_insn", "(", "gen_movmemsi_internal", "(", "dst_reg", ",", "src_reg", ",", "at_a_time", ",", "new_dst_reg", ",", "new_src_reg", ")", ")", ";", "emit_move_insn", "(", "dst_reg", ",", "new_dst_reg", ")", ";", "emit_move_insn", "(", "src_reg", ",", "new_src_reg", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "dst_reg", ",", "dst_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "if", "(", "bytes", ">", "MAX_MOVE_BYTES", ")", "{", "emit_insn", "(", "gen_cmpsi", "(", "src_reg", ",", "final_src", ")", ")", ";", "emit_jump_insn", "(", "gen_bne", "(", "label", ")", ")", ";", "}", "}", "if", "(", "leftover", ")", "emit_insn", "(", "gen_movmemsi_internal", "(", "dst_reg", ",", "src_reg", ",", "GEN_INT", "(", "leftover", ")", ",", "gen_reg_rtx", "(", "SImode", ")", ",", "gen_reg_rtx", "(", "SImode", ")", ")", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Expand", "string/block", "move", "operations", ".", "operands", "[", "0", "]", "is", "the", "pointer", "to", "the", "destination", ".", "operands", "[", "1", "]", "is", "the", "pointer", "to", "the", "source", ".", "operands", "[", "2", "]", "is", "the", "number", "of", "bytes", "to", "move", ".", "operands", "[", "3", "]", "is", "the", "alignment", "." ]

[ "m32r", "0", "1", "2", "3", "0", "0", "1", "0", "0", "0", "4", "1" ]

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "fixBackwardsWLS", "(", "MachineLoop", "*", "ML", ")", "{", "MachineInstr", "*", "WlsInstr", "=", "findWLS", "(", "ML", ")", ";", "if", "(", "!", "WlsInstr", ")", "return", "false", ";", "MachineBasicBlock", "*", "Predecessor", "=", "WlsInstr", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "LoopExit", "=", "getWhileLoopStartTargetBB", "(", "*", "WlsInstr", ")", ";", "if", "(", "!", "LoopExit", "->", "getPrevNode", "(", ")", ")", "return", "false", ";", "if", "(", "blockIsBefore", "(", "Predecessor", ",", "LoopExit", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Found a backwards WLS from \"", "<<", "Predecessor", "->", "getFullName", "(", ")", "<<", "\" to \"", "<<", "LoopExit", "->", "getFullName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "auto", "It", "=", "++", "LoopExit", "->", "getIterator", "(", ")", ";", "It", "!=", "Predecessor", "->", "getIterator", "(", ")", ";", "++", "It", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "It", ";", "for", "(", "auto", "&", "Terminator", ":", "MBB", "->", "terminators", "(", ")", ")", "{", "if", "(", "!", "isWhileLoopStart", "(", "Terminator", ")", ")", "continue", ";", "MachineBasicBlock", "*", "WLSTarget", "=", "getWhileLoopStartTargetBB", "(", "Terminator", ")", ";", "if", "(", "WLSTarget", "==", "Predecessor", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move Predecessor block as \"", "<<", "\"it would convert a WLS from forward to a \"", "<<", "\"backwards branching WLS\\n\"", ")", ";", "RevertedWhileLoops", ".", "push_back", "(", "WlsInstr", ")", ";", "return", "false", ";", "}", "}", "}", "moveBasicBlock", "(", "Predecessor", ",", "LoopExit", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "if", "loop", "has", "a", "backwards", "branching", "WLS", ",", "and", "if", "possible", ",", "fixes", "it", "." ]

[ "ARM", "ARM", "\"Found a backwards WLS from \"", "\" to \"", "\"\\n\"", "\"Can't move Predecessor block as \"", "\"it would convert a WLS from forward to a \"", "\"backwards branching WLS\\n\"" ]

[]

[ "<s>", "bool", "SPIRVPreLegalizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SPIRVSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SPIRVSubtarget", ">", "(", ")", ";", "SPIRVGlobalRegistry", "*", "GR", "=", "ST", ".", "getSPIRVGlobalRegistry", "(", ")", ";", "GR", "->", "setCurrentFunc", "(", "MF", ")", ";", "MachineIRBuilder", "MIB", "(", "MF", ")", ";", "foldConstantsIntoIntrinsics", "(", "MF", ")", ";", "insertBitcasts", "(", "MF", ",", "GR", ",", "MIB", ")", ";", "generateAssignInstrs", "(", "MF", ",", "GR", ",", "MIB", ")", ";", "processInstrsWithTypeFolding", "(", "MF", ",", "GR", ",", "MIB", ")", ";", "processSwitches", "(", "MF", ",", "GR", ",", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "SPIRV", "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "static", "void", "cr16_create_dwarf_for_multi_push", "(", "rtx", "insn", ")", "{", "rtx", "dwarf", ",", "reg", ",", "tmp", ";", "int", "i", ",", "j", ",", "from", ",", "to", ",", "word_cnt", ",", "dwarf_par_index", ",", "inc", ";", "machine_mode", "mode", ";", "int", "num_regs", "=", "0", ",", "offset", "=", "0", ",", "split_here", "=", "0", ",", "total_push_bytes", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "current_frame_info", ".", "last_reg_to_save", ";", "++", "i", ")", "{", "if", "(", "current_frame_info", ".", "save_regs", "[", "i", "]", ")", "{", "++", "num_regs", ";", "if", "(", "i", "<", "CR16_FIRST_DWORD_REGISTER", ")", "total_push_bytes", "+=", "2", ";", "else", "total_push_bytes", "+=", "4", ";", "}", "}", "if", "(", "!", "num_regs", ")", "return", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "1", ")", ")", ";", "dwarf_par_index", "=", "num_regs", ";", "from", "=", "current_frame_info", ".", "last_reg_to_save", "+", "1", ";", "to", "=", "current_frame_info", ".", "last_reg_to_save", ";", "word_cnt", "=", "0", ";", "for", "(", "i", "=", "current_frame_info", ".", "last_reg_to_save", ";", "i", ">=", "0", ";", ")", "{", "if", "(", "!", "current_frame_info", ".", "save_regs", "[", "i", "]", "||", "0", "==", "i", "||", "split_here", ")", "{", "if", "(", "0", "==", "i", "&&", "current_frame_info", ".", "save_regs", "[", "i", "]", ")", "from", "=", "0", ";", "for", "(", "j", "=", "to", ";", "j", ">=", "from", ";", "--", "j", ")", "{", "if", "(", "j", "<", "CR16_FIRST_DWORD_REGISTER", ")", "{", "mode", "=", "HImode", ";", "inc", "=", "1", ";", "}", "else", "{", "mode", "=", "SImode", ";", "inc", "=", "2", ";", "}", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "j", ")", ";", "offset", "+=", "2", "*", "inc", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "total_push_bytes", "-", "offset", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "dwarf_par_index", "--", ")", "=", "tmp", ";", "}", "from", "=", "i", ";", "to", "=", "--", "i", ";", "split_here", "=", "0", ";", "word_cnt", "=", "0", ";", "continue", ";", "}", "if", "(", "i", "!=", "RETURN_ADDRESS_REGNUM", ")", "{", "inc", "=", "(", "i", "<", "CR16_FIRST_DWORD_REGISTER", ")", "?", "1", ":", "2", ";", "if", "(", "word_cnt", "+", "inc", ">=", "MAX_COUNT", "||", "FRAME_POINTER_REGNUM", "==", "i", ")", "{", "split_here", "=", "1", ";", "from", "=", "i", ";", "continue", ";", "}", "word_cnt", "+=", "inc", ";", "}", "from", "=", "i", "--", ";", "}", "tmp", "=", "gen_rtx_SET", "(", "SImode", ",", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "SImode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "}", "</s>" ]

[ "Generate", "DWARF2", "annotation", "for", "multi-push", "instruction", "." ]

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

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "for", "(", "std", "::", "map", "<", "const", "char", "*", ",", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", ">", "::", "const_iterator", "it", "=", "MipsFI", "->", "StubsNeeded", ".", "begin", "(", ")", ";", "it", "!=", "MipsFI", "->", "StubsNeeded", ".", "end", "(", ")", ";", "++", "it", ")", "{", "const", "char", "*", "Symbol", "=", "it", "->", "first", ";", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", "Signature", "=", "it", "->", "second", ";", "if", "(", "StubsNeeded", ".", "find", "(", "Symbol", ")", "==", "StubsNeeded", ".", "end", "(", ")", ")", "StubsNeeded", "[", "Symbol", "]", "=", "Signature", ";", "}", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "NaClAlignIndirectJumpTargets", "(", "MF", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "PPC", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "AMDGPU_PS", ")", "return", "false", ";", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "AMDGPU", "::", "EXEC", ")", ";", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "unsigned", "LiveMaskReg", "=", "0", ";", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "return", "true", ";", "}", "}", "DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "SI", "SI", "AMDGPU::EXEC", "0", "AMDGPU::SReg_64RegClass", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::S_WQM_B64", "AMDGPU::EXEC", "AMDGPU::EXEC", "AMDGPU::SCC" ]

[]

[ "<s>", "const", "X86TargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "X86TargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_set_one_block_and_progress_pointer", "(", "rtx", "src", ",", "rtx", "*", "dst", ",", "machine_mode", "mode", ")", "{", "if", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "256", ")", ")", "{", "mode", "=", "GET_MODE", "(", "src", ")", ";", "*", "dst", "=", "adjust_address", "(", "*", "dst", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "*", "dst", ",", "src", ",", "aarch64_progress_pointer", "(", "*", "dst", ")", ",", "src", ")", ")", ";", "*", "dst", "=", "aarch64_move_pointer", "(", "*", "dst", ",", "32", ")", ";", "return", ";", "}", "if", "(", "known_eq", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "128", ")", ")", "{", "*", "dst", "=", "adjust_address", "(", "*", "dst", ",", "GET_MODE", "(", "src", ")", ",", "0", ")", ";", "emit_move_insn", "(", "*", "dst", ",", "src", ")", ";", "*", "dst", "=", "aarch64_move_pointer", "(", "*", "dst", ",", "16", ")", ";", "return", ";", "}", "rtx", "reg", "=", "lowpart_subreg", "(", "mode", ",", "src", ",", "GET_MODE", "(", "src", ")", ")", ";", "*", "dst", "=", "adjust_address", "(", "*", "dst", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "*", "dst", ",", "reg", ")", ";", "*", "dst", "=", "aarch64_progress_pointer", "(", "*", "dst", ")", ";", "}", "</s>" ]

[ "Like", "aarch64_copy_one_block_and_progress_pointers", ",", "except", "for", "memset", "where", "SRC", "is", "a", "register", "we", "have", "created", "with", "the", "duplicated", "value", "to", "be", "set", "." ]

[ "aarch64", "256", "0", "32", "128", "0", "16", "0" ]

[]

[ "<s>", "static", "void", "mips_init_builtins", "(", "void", ")", "{", "const", "struct", "mips_builtin_description", "*", "d", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ";", "i", "++", ")", "{", "d", "=", "&", "mips_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "mips_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "mips_build_function_type", "(", "d", "->", "function_type", ")", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "}", "}", "</s>" ]

[ "Init", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_INIT_BUILTIN", "." ]

[ "mips", "0" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "GlobalBaseReg", "=", "0", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "InsertVRSaveCode", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "0" ]

[]

[ "<s>", "static", "int", "csky_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep", ",", "int", "cost", ",", "unsigned", "int", "dw", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "dep_type", "==", "REG_DEP_ANTI", "||", "dep_type", "==", "REG_DEP_OUTPUT", ")", "return", "0", ";", "else", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "recog_memoized", "(", "dep", ")", ">=", "0", ")", "{", "enum", "attr_type", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "CSKY_TARGET_ARCH", "(", "CK803", ")", ")", "{", "if", "(", "insn_type", "==", "TYPE_LOAD", "||", "insn_type", "==", "TYPE_STORE", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "rtx", "addr", "=", "(", "insn_type", "==", "TYPE_LOAD", "?", "SET_SRC", "(", "pattern", ")", ":", "SET_DEST", "(", "pattern", ")", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "addr", ")", ";", "if", "(", "code", "==", "ZERO_EXTEND", "||", "code", "==", "SIGN_EXTEND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "MEM", ")", ";", "rtx", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "reg", "=", "NULL_RTX", ";", "if", "(", "REG_P", "(", "base", ")", ")", "reg", "=", "base", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "base", ",", "0", ")", ")", "==", "REG", ")", "reg", "=", "XEXP", "(", "base", ",", "0", ")", ";", "if", "(", "(", "reg", "!=", "NULL_RTX", ")", "&&", "reg_set_p", "(", "reg", ",", "PATTERN", "(", "dep", ")", ")", ")", "return", "2", ";", "}", "}", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", ")", "{", "if", "(", "(", "insn_type", "==", "TYPE_CALL_JSR", "||", "insn_type", "==", "TYPE_BRANCH_JMP", ")", "&&", "get_attr_type", "(", "dep", ")", "!=", "TYPE_LOAD", ")", "return", "1", ";", "if", "(", "insn_type", "==", "TYPE_LOAD", "||", "insn_type", "==", "TYPE_STORE", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", ";", "rtx", "addr", "=", "(", "insn_type", "==", "TYPE_LOAD", "?", "SET_SRC", "(", "pattern", ")", ":", "SET_DEST", "(", "pattern", ")", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "addr", ")", ";", "if", "(", "code", "==", "ZERO_EXTEND", "||", "code", "==", "SIGN_EXTEND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "MEM", ")", ";", "rtx", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "reg", "=", "NULL_RTX", ";", "if", "(", "REG_P", "(", "base", ")", ")", "reg", "=", "base", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "base", ",", "0", ")", ")", "==", "REG", ")", "reg", "=", "XEXP", "(", "base", ",", "0", ")", ";", "if", "(", "(", "reg", "!=", "NULL_RTX", ")", "&&", "reg_set_p", "(", "reg", ",", "PATTERN", "(", "dep", ")", ")", "&&", "get_attr_type", "(", "dep", ")", "!=", "TYPE_LOAD", ")", "return", "1", ";", "if", "(", "insn_type", "==", "TYPE_STORE", "&&", "reg_referenced_p", "(", "SET_SRC", "(", "pattern", ")", ",", "PATTERN", "(", "dep", ")", ")", ")", "return", "1", ";", "}", "}", "}", "return", "cost", ";", "}", "</s>" ]

[ "This", "function", "implements", "the", "target", "macro", "TARGET_SCHED_ADJUST_COST", ".", "It", "corrects", "the", "value", "of", "COST", "based", "on", "the", "relationship", "between", "INSN", "and", "DEP", "through", "the", "dependence", "DEP_TYPE", ".", "It", "returns", "the", "new", "value", "." ]

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "ReverseVEXT", ";", "unsigned", "Imm", ",", "WhichResult", ";", "unsigned", "EltSize", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "return", "(", "EltSize", ">=", "32", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isVEXTMask", "(", "M", ",", "VT", ",", "ReverseVEXT", ",", "Imm", ")", "||", "isVTBLMask", "(", "M", ",", "VT", ")", "||", "isVTRNMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVUZPMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVZIPMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "(", "(", "VT", "==", "MVT", "::", "v8i16", "||", "VT", "==", "MVT", "::", "v16i8", ")", "&&", "isReverseMask", "(", "M", ",", "VT", ")", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "32", "0", "64", "32", "16", "MVT::v8i16", "MVT::v16i8" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDR", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tRestore", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "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", "." ]

[ "ARM", "ARM", "ARM::LDR", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::t2LDRi12", "ARM::tRestore", "1", "2", "2", "0", "1", "0", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "PIC16TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "tm", ")", "{", "TargetLoweringObjectFile", "::", "Initialize", "(", "Ctx", ",", "tm", ")", ";", "TM", "=", "&", "tm", ";", "BSSSection", "=", "getPIC16Section", "(", "\"udata.# UDATA\"", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "ReadOnlySection", "=", "getPIC16Section", "(", "\"romdata.# ROMDATA\"", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "DataSection", "=", "getPIC16Section", "(", "\"idata.# IDATA\"", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "TextSection", "=", "getPIC16Section", "(", "\"\"", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "ROSections", ".", "push_back", "(", "new", "PIC16Section", "(", "(", "MCSectionPIC16", "*", ")", "ReadOnlySection", ")", ")", ";", "ExternalVarDecls", "=", "new", "PIC16Section", "(", "getPIC16Section", "(", "\"ExternalVarDecls\"", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ")", ";", "ExternalVarDefs", "=", "new", "PIC16Section", "(", "getPIC16Section", "(", "\"ExternalVarDefs\"", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "PIC16", "\"udata.# UDATA\"", "PIC16", "\"romdata.# ROMDATA\"", "PIC16", "\"idata.# IDATA\"", "PIC16", "\"\"", "PIC16", "PIC16", "PIC16", "PIC16", "\"ExternalVarDecls\"", "PIC16", "PIC16", "\"ExternalVarDefs\"" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "DiagnosticInfo", "*", "DI", ")", "{", "return", "DI", "->", "getKind", "(", ")", "==", "DK_MisalignedTrap", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_indirect_function_return", "(", "rtx", "ret_op", ")", "{", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_keep", ")", "{", "char", "thunk_name", "[", "32", "]", ";", "enum", "indirect_thunk_prefix", "need_prefix", "=", "indirect_thunk_need_prefix", "(", "current_output_insn", ")", ";", "unsigned", "int", "regno", "=", "REGNO", "(", "ret_op", ")", ";", "gcc_assert", "(", "regno", "==", "CX_REG", ")", ";", "if", "(", "cfun", "->", "machine", "->", "function_return_type", "!=", "indirect_branch_thunk_inline", ")", "{", "bool", "need_thunk", "=", "(", "cfun", "->", "machine", "->", "function_return_type", "==", "indirect_branch_thunk", ")", ";", "indirect_thunk_name", "(", "thunk_name", ",", "regno", ",", "need_prefix", ",", "true", ")", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "{", "if", "(", "need_thunk", ")", "{", "indirect_return_via_cx_bnd", "=", "true", ";", "indirect_thunks_bnd_used", "|=", "1", "<<", "CX_REG", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\tbnd jmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "}", "else", "{", "if", "(", "need_thunk", ")", "{", "indirect_return_via_cx", "=", "true", ";", "indirect_thunks_used", "|=", "1", "<<", "CX_REG", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%s\\n\"", ",", "thunk_name", ")", ";", "}", "}", "else", "output_indirect_thunk", "(", "need_prefix", ",", "regno", ")", ";", "return", "\"\"", ";", "}", "else", "return", "\"%!jmp\\t%A0\"", ";", "}", "</s>" ]

[ "Output", "indirect", "function", "return", ".", "RET_OP", "is", "the", "function", "return", "target", "." ]

[ "i386", "32", "1", "\"\\tbnd jmp\\t%s\\n\"", "1", "\"\\tjmp\\t%s\\n\"", "\"\"", "\"%!jmp\\t%A0\"" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "ix86_emit_save_reg_using_mov", "(", "V4SFmode", ",", "regno", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "GET_MODE_SIZE", "(", "V4SFmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "SSE", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "stored", "at", "CFA", "-", "CFA_OFFSET", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", "->", "isTargetNaCl", "(", ")", "&&", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "M", ".", "data", "(", ")", ",", "VT", ")", ")", "return", "true", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "bool", "SwapSources", ";", "int", "LoSrc", ",", "HiSrc", ";", "return", "(", "isElementRotate", "(", "LoSrc", ",", "HiSrc", ",", "M", ")", ">", "0", ")", "||", "isInterleaveShuffle", "(", "M", ",", "SVT", ",", "SwapSources", ",", "Subtarget", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ix86_code_end", "(", "void", ")", "{", "rtx", "xops", "[", "2", "]", ";", "int", "regno", ";", "for", "(", "regno", "=", "AX_REG", ";", "regno", "<=", "SP_REG", ";", "regno", "++", ")", "{", "char", "name", "[", "32", "]", ";", "tree", "decl", ";", "if", "(", "!", "(", "pic_labels_used", "&", "(", "1", "<<", "regno", ")", ")", ")", "continue", ";", "get_pc_thunk_name", "(", "name", ",", "regno", ")", ";", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "1", ";", "if", "(", "TARGET_MACHO", ")", "{", "switch_to_section", "(", "darwin_sections", "[", "text_coal_section", "]", ")", ";", "fputs", "(", "\"\\t.weak_definition\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\n\\t.private_extern\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "DECL_WEAK", "(", "decl", ")", "=", "1", ";", "}", "else", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "cgraph_node", "::", "create", "(", "decl", ")", "->", "set_comdat_group", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "targetm", ".", "asm_out", ".", "unique_section", "(", "decl", ",", "0", ")", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\t.hidden\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_DECLARE_FUNCTION_NAME", "(", "asm_out_file", ",", "name", ",", "decl", ")", ";", "}", "else", "{", "switch_to_section", "(", "text_section", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "name", ")", ";", "}", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "current_function_decl", "=", "decl", ";", "allocate_struct_function", "(", "decl", ",", "false", ")", ";", "init_function_start", "(", "decl", ")", ";", "first_function_block_is_cold", "=", "false", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "asm_out_file", ",", "1", ")", ";", "if", "(", "TARGET_PAD_SHORT_FUNCTION", ")", "{", "int", "i", "=", "8", ";", "while", "(", "i", "--", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "}", "xops", "[", "0", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "xops", "[", "1", "]", "=", "gen_rtx_MEM", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "output_asm_insn", "(", "\"mov%z0\\t{%1, %0|%0, %1}\"", ",", "xops", ")", ";", "output_asm_insn", "(", "\"%!ret\"", ",", "NULL", ")", ";", "final_end_function", "(", ")", ";", "init_insn_lengths", "(", ")", ";", "free_after_compilation", "(", "cfun", ")", ";", "set_cfun", "(", "NULL", ")", ";", "current_function_decl", "=", "NULL", ";", "}", "if", "(", "flag_split_stack", ")", "file_end_indicate_split_stack", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "code", "for", "-fpic", "that", "loads", "%", "ebx", "with", "the", "return", "address", "of", "the", "caller", "and", "then", "returns", "." ]

[ "i386", "2", "32", "1", "1", "1", "1", "\"\\t.weak_definition\\t\"", "\"\\n\\t.private_extern\\t\"", "1", "0", "0", "\"\\t.hidden\\t\"", "1", "8", "\"\\tnop\\n\"", "0", "1", "\"mov%z0\\t{%1, %0|%0, %1}\"", "\"%!ret\"" ]

[]

[ "<s>", "static", "bool", "tilepro_current_function_is_leaf", "(", "void", ")", "{", "return", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "machine", "->", "calls_tls_get_addr", ";", "}", "</s>" ]

[ "Return", "whether", "the", "current", "function", "is", "leaf", ".", "This", "takes", "into", "account", "whether", "the", "function", "calls", "tls_get_addr", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "case", "ISD", "::", "ATOMIC_SWAP", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::READCYCLECOUNTER", "ISD::ATOMIC_STORE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_LOAD_ADD", "ISD::ATOMIC_LOAD_AND", "ISD::ATOMIC_LOAD_NAND", "ISD::ATOMIC_LOAD_OR", "ISD::ATOMIC_LOAD_SUB", "ISD::ATOMIC_LOAD_XOR", "ISD::ATOMIC_SWAP", "ISD::ATOMIC_CMP_SWAP", "ISD::ATOMIC_LOAD_MIN", "ISD::ATOMIC_LOAD_UMIN", "ISD::ATOMIC_LOAD_MAX", "ISD::ATOMIC_LOAD_UMAX" ]

[]

[ "<s>", "VETargetMachine", "::", "VETargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Small", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "Aurora", "VE", "architecture", "model", "." ]

[ "VE", "VE", "VE" ]

[]

[ "<s>", "static", "bool", "sparc_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "flag_pic", "&&", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "rtx", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "op0", "==", "pic_offset_table_rtx", "&&", "symbolic_operand", "(", "op1", ",", "VOIDmode", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", ".", "In", "PIC", "mode", ",", "(", "mem", ":", "HI", "[", "%", "l7+a", "]", ")", "is", "not", "equivalent", "to", "(", "mem", ":", "QI", "[", "%", "l7+a", "]", ")", "(", "mem", ":", "QI", "[", "%", "l7+a+1", "]", ")", "because", "[", "%", "l7+a+1", "]", "is", "interpreted", "as", "the", "address", "of", "(", "a+1", ")", "." ]

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

[]

[ "<s>", "static", "void", "aarch64_pop_regs", "(", "unsigned", "regno1", ",", "unsigned", "regno2", ",", "HOST_WIDE_INT", "adjustment", ",", "rtx", "*", "cfi_ops", ")", "{", "machine_mode", "mode", "=", "aarch64_reg_save_mode", "(", "cfun", "->", "decl", ",", "regno1", ")", ";", "rtx", "reg1", "=", "gen_rtx_REG", "(", "mode", ",", "regno1", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg1", ",", "*", "cfi_ops", ")", ";", "if", "(", "regno2", "==", "INVALID_REGNUM", ")", "{", "rtx", "mem", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "adjustment", ")", ";", "mem", "=", "gen_rtx_POST_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "mem", ")", ";", "emit_move_insn", "(", "reg1", ",", "gen_frame_mem", "(", "mode", ",", "mem", ")", ")", ";", "}", "else", "{", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "*", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg2", ",", "*", "cfi_ops", ")", ";", "emit_insn", "(", "aarch64_gen_loadwb_pair", "(", "mode", ",", "stack_pointer_rtx", ",", "reg1", ",", "reg2", ",", "adjustment", ")", ")", ";", "}", "}", "</s>" ]

[ "Pop", "the", "two", "registers", "numbered", "REGNO1", ",", "REGNO2", "from", "the", "stack", ",", "adjusting", "it", "afterwards", "by", "ADJUSTMENT", "and", "writing", "the", "appropriate", "REG_CFA_RESTORE", "notes", "into", "CFI_OPS", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "findCommutedOpIndices", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "unsigned", "op1", ",", "op2", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Patmos", "::", "ADDr", ":", "case", "Patmos", "::", "ADDr_ow", ":", "case", "Patmos", "::", "ORr", ":", "case", "Patmos", "::", "ORr_ow", ":", "case", "Patmos", "::", "ANDr", ":", "case", "Patmos", "::", "ANDr_ow", ":", "case", "Patmos", "::", "XORr", ":", "case", "Patmos", "::", "XORr_ow", ":", "case", "Patmos", "::", "NORr", ":", "case", "Patmos", "::", "NORr_ow", ":", "op1", "=", "3", ";", "op2", "=", "4", ";", "break", ";", "case", "Patmos", "::", "MUL", ":", "case", "Patmos", "::", "MULU", ":", "op1", "=", "2", ";", "op2", "=", "3", ";", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "op1", ",", "op2", ")", "||", "!", "MI", ".", "getOperand", "(", "SrcOpIdx1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "SrcOpIdx2", ")", ".", "isReg", "(", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "Patmos", "Patmos", "Patmos::ADDr", "Patmos::ADDr_ow", "Patmos::ORr", "Patmos::ORr_ow", "Patmos::ANDr", "Patmos::ANDr_ow", "Patmos::XORr", "Patmos::XORr_ow", "Patmos::NORr", "Patmos::NORr_ow", "3", "4", "Patmos::MUL", "Patmos::MULU", "2", "3" ]

[]

[ "<s>", "static", "void", "mips_set_frame_expr", "(", "rtx", "frame_pattern", ")", "{", "rtx", "insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "frame_pattern", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Make", "the", "last", "instruction", "frame", "related", "and", "note", "that", "it", "performs", "the", "operation", "described", "by", "FRAME_PATTERN", "." ]

[ "mips", "1" ]

[]

[ "<s>", "unsigned", "PPCAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "int64_t", "ImmVal", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_0", ":", "ImmVal", "=", "0", ";", "break", ";", "case", "MCK_1", ":", "ImmVal", "=", "1", ";", "break", ";", "case", "MCK_2", ":", "ImmVal", "=", "2", ";", "break", ";", "case", "MCK_3", ":", "ImmVal", "=", "3", ";", "break", ";", "case", "MCK_4", ":", "ImmVal", "=", "4", ";", "break", ";", "case", "MCK_5", ":", "ImmVal", "=", "5", ";", "break", ";", "case", "MCK_6", ":", "ImmVal", "=", "6", ";", "break", ";", "case", "MCK_7", ":", "ImmVal", "=", "7", ";", "break", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "PPCOperand", "&", "Op", "=", "static_cast", "<", "PPCOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "Op", ".", "isU3Imm", "(", ")", "&&", "Op", ".", "getImm", "(", ")", "==", "ImmVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "PowerPC", "PPC", "0", "1", "2", "3", "4", "5", "6", "7", "PPC", "PPC" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TRI", "->", "getRegSizeInBits", "(", "RISCV", "::", "GPRRegClass", ")", "==", "32", "?", "RISCV", "::", "SW", ":", "RISCV", "::", "SD", ";", "else", "if", "(", "RISCV", "::", "FPR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSH", ";", "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", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "thumb1_extra_regs_pushed", "(", "arm_stack_offsets", "*", "offsets", ",", "bool", "for_prologue", ")", "{", "HOST_WIDE_INT", "amount", ";", "unsigned", "long", "live_regs_mask", "=", "offsets", "->", "saved_regs_mask", ";", "unsigned", "long", "l_mask", "=", "live_regs_mask", "&", "(", "for_prologue", "?", "0x40ff", ":", "0xff", ")", ";", "unsigned", "long", "high_regs_pushed", "=", "bit_count", "(", "live_regs_mask", "&", "0x0f00", ")", ";", "int", "n_free", ",", "reg_base", ",", "size", ";", "if", "(", "!", "for_prologue", "&&", "frame_pointer_needed", ")", "amount", "=", "offsets", "->", "locals_base", "-", "offsets", "->", "saved_regs", ";", "else", "amount", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "if", "(", "!", "optimize_size", "&&", "amount", "!=", "512", ")", "return", "0", ";", "if", "(", "high_regs_pushed", "!=", "0", ")", "return", "0", ";", "if", "(", "l_mask", "==", "0", "&&", "(", "for_prologue", "||", "TARGET_BACKTRACE", "||", "(", "live_regs_mask", "&", "1", "<<", "LR_REGNUM", ")", "==", "0", "||", "TARGET_INTERWORK", "||", "crtl", "->", "args", ".", "pretend_args_size", "!=", "0", ")", ")", "return", "0", ";", "if", "(", "for_prologue", "&&", "(", "(", "flag_pic", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", ")", "||", "(", "!", "frame_pointer_needed", "&&", "CALLER_INTERWORKING_SLOT_SIZE", ">", "0", ")", ")", ")", "return", "0", ";", "reg_base", "=", "0", ";", "n_free", "=", "0", ";", "if", "(", "!", "for_prologue", ")", "{", "size", "=", "arm_size_return_regs", "(", ")", ";", "reg_base", "=", "ARM_NUM_INTS", "(", "size", ")", ";", "live_regs_mask", ">>=", "reg_base", ";", "}", "while", "(", "reg_base", "+", "n_free", "<", "8", "&&", "!", "(", "live_regs_mask", "&", "1", ")", "&&", "(", "for_prologue", "||", "call_used_or_fixed_reg_p", "(", "reg_base", "+", "n_free", ")", ")", ")", "{", "live_regs_mask", ">>=", "1", ";", "n_free", "++", ";", "}", "if", "(", "n_free", "==", "0", ")", "return", "0", ";", "gcc_assert", "(", "amount", "/", "4", "*", "4", "==", "amount", ")", ";", "if", "(", "amount", ">=", "512", "&&", "(", "amount", "-", "n_free", "*", "4", ")", "<", "512", ")", "return", "(", "amount", "-", "508", ")", "/", "4", ";", "if", "(", "amount", "<=", "n_free", "*", "4", ")", "return", "amount", "/", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Given", "the", "stack", "offsets", "and", "register", "mask", "in", "OFFSETS", ",", "decide", "how", "many", "additional", "registers", "to", "push", "instead", "of", "subtracting", "a", "constant", "from", "SP", ".", "For", "epilogues", "the", "principle", "is", "the", "same", "except", "we", "use", "pop", ".", "FOR_PROLOGUE", "indicates", "which", "we", "'re", "generating", "." ]

[ "arm", "0x40ff", "0xff", "0x0f00", "512", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "8", "1", "1", "0", "0", "4", "4", "512", "4", "512", "508", "4", "4", "4", "0" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "is64bit", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveSparcCodeModel", "(", "CM", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "is64bit", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "SparcELFTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "is64bit", ")", ",", "is64Bit", "(", "is64bit", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "riscv_emit_int_order_test", "(", "enum", "rtx_code", "code", ",", "bool", "*", "invert_ptr", ",", "rtx", "target", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ")", "{", "enum", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "cmp0", ")", ";", "if", "(", "riscv_canonicalize_int_order_test", "(", "&", "code", ",", "&", "cmp1", ",", "mode", ")", ")", "riscv_emit_binary", "(", "code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "else", "{", "enum", "rtx_code", "inv_code", "=", "reverse_condition", "(", "code", ")", ";", "if", "(", "!", "riscv_canonicalize_int_order_test", "(", "&", "inv_code", ",", "&", "cmp1", ",", "mode", ")", ")", "{", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "riscv_emit_int_order_test", "(", "code", ",", "invert_ptr", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "else", "if", "(", "invert_ptr", "==", "0", ")", "{", "rtx", "inv_target", "=", "riscv_force_binary", "(", "GET_MODE", "(", "target", ")", ",", "inv_code", ",", "cmp0", ",", "cmp1", ")", ";", "riscv_emit_binary", "(", "XOR", ",", "target", ",", "inv_target", ",", "const1_rtx", ")", ";", "}", "else", "{", "*", "invert_ptr", "=", "!", "*", "invert_ptr", ";", "riscv_emit_binary", "(", "inv_code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "}", "}", "</s>" ]

[ "Compare", "CMP0", "and", "CMP1", "using", "ordering", "test", "CODE", "and", "store", "the", "result", "in", "TARGET", ".", "CMP0", "and", "TARGET", "are", "register_operands", ".", "If", "INVERT_PTR", "is", "nonnull", ",", "it", "'s", "OK", "to", "set", "TARGET", "to", "the", "inverse", "of", "the", "result", "and", "flip", "*", "INVERT_PTR", "instead", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "m32r_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "<", "0", "||", "size", ">", "8", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TYPE", "must", "be", "passed", "by", "indirect", "reference", "." ]

[ "m32r", "0", "8" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "bool", "Is64Bit", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "isPPC64", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "IE", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsgdLADDR32", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "ADDItlsldLADDR32", ")", "{", "++", "I", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"TLS Dynamic Call Fixup:\\n \"", "<<", "MI", ")", ";", "unsigned", "OutReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "InReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "GPR3", "=", "Is64Bit", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "unsigned", "Opc1", ",", "Opc2", ";", "const", "unsigned", "OrigRegs", "[", "]", "=", "{", "OutReg", ",", "InReg", ",", "GPR3", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode inconsistency error\"", ")", ";", "case", "PPC", "::", "ADDItlsgdLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR", ";", "break", ";", "case", "PPC", "::", "ADDItlsgdLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsgdL32", ";", "Opc2", "=", "PPC", "::", "GETtlsADDR32", ";", "break", ";", "case", "PPC", "::", "ADDItlsldLADDR32", ":", "Opc1", "=", "PPC", "::", "ADDItlsldL32", ";", "Opc2", "=", "PPC", "::", "GETtlsldADDR32", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKDOWN", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "MachineInstr", "*", "Addi", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc1", ")", ",", "GPR3", ")", ".", "addReg", "(", "InReg", ")", ";", "Addi", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "First", "=", "I", ";", "--", "First", ";", "MachineInstr", "*", "Call", "=", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Opc2", ")", ",", "GPR3", ")", ".", "addReg", "(", "GPR3", ")", ")", ";", "Call", "->", "addOperand", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "PPC", "::", "ADJCALLSTACKUP", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "OutReg", ")", ".", "addReg", "(", "GPR3", ")", ";", "MachineBasicBlock", "::", "iterator", "Last", "=", "I", ";", "--", "Last", ";", "++", "I", ";", "MI", ".", "removeFromParent", "(", ")", ";", "LIS", "->", "repairIntervalsInRange", "(", "&", "MBB", ",", "First", ",", "Last", ",", "OrigRegs", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsldLADDR32", "\"TLS Dynamic Call Fixup:\\n \"", "0", "1", "PPC::X3", "PPC::R3", "\"Opcode inconsistency error\"", "PPC::ADDItlsgdLADDR", "PPC::ADDItlsgdL", "PPC::GETtlsADDR", "PPC::ADDItlsldLADDR", "PPC::ADDItlsldL", "PPC::GETtlsldADDR", "PPC::ADDItlsgdLADDR32", "PPC::ADDItlsgdL32", "PPC::GETtlsADDR32", "PPC::ADDItlsldLADDR32", "PPC::ADDItlsldL32", "PPC::GETtlsldADDR32", "PPC::ADJCALLSTACKDOWN", "0", "0", "2", "3", "PPC::ADJCALLSTACKUP", "0", "0" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createUnpackMachineBundles", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb2", "(", ")", ";", "}", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createARMBlockPlacementPass", "(", ")", ")", ";", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "machine_mode", "ix86_cc_modes_compatible", "(", "machine_mode", "m1", ",", "machine_mode", "m2", ")", "{", "if", "(", "m1", "==", "m2", ")", "return", "m1", ";", "if", "(", "GET_MODE_CLASS", "(", "m1", ")", "!=", "MODE_CC", "||", "GET_MODE_CLASS", "(", "m2", ")", "!=", "MODE_CC", ")", "return", "VOIDmode", ";", "if", "(", "(", "m1", "==", "CCGCmode", "&&", "m2", "==", "CCGOCmode", ")", "||", "(", "m1", "==", "CCGOCmode", "&&", "m2", "==", "CCGCmode", ")", ")", "return", "CCGCmode", ";", "if", "(", "m1", "==", "CCZmode", "&&", "(", "m2", "==", "CCGCmode", "||", "m2", "==", "CCGOCmode", ")", ")", "return", "m2", ";", "else", "if", "(", "m2", "==", "CCZmode", "&&", "(", "m1", "==", "CCGCmode", "||", "m1", "==", "CCGOCmode", ")", ")", "return", "m1", ";", "switch", "(", "m1", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "CCmode", ":", "case", "CCGCmode", ":", "case", "CCGOCmode", ":", "case", "CCNOmode", ":", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCPmode", ":", "case", "CCSmode", ":", "case", "CCZmode", ":", "switch", "(", "m2", ")", "{", "default", ":", "return", "VOIDmode", ";", "case", "CCmode", ":", "case", "CCGCmode", ":", "case", "CCGOCmode", ":", "case", "CCNOmode", ":", "case", "CCAmode", ":", "case", "CCCmode", ":", "case", "CCOmode", ":", "case", "CCPmode", ":", "case", "CCSmode", ":", "case", "CCZmode", ":", "return", "CCmode", ";", "}", "case", "CCFPmode", ":", "case", "CCFPUmode", ":", "return", "VOIDmode", ";", "}", "}", "</s>" ]

[ "If", "two", "condition", "code", "modes", "are", "compatible", ",", "return", "a", "condition", "code", "mode", "which", "is", "compatible", "with", "both", ".", "Otherwise", ",", "return", "VOIDmode", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "aarch64_progress_pointer", "(", "rtx", "pointer", ")", "{", "return", "aarch64_move_pointer", "(", "pointer", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "pointer", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "new", "RTX", "holding", "the", "result", "of", "moving", "POINTER", "forward", "by", "the", "size", "of", "the", "mode", "it", "points", "to", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_XCore", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::InputArg", "16", "XCore", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "R600DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "unsigned", "int", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "AMDGPUISD", "::", "BUILD_VERTICAL_VECTOR", ":", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "case", "ISD", "::", "BUILD_VECTOR", ":", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "unsigned", "NumVectorElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "RegClassID", ";", "switch", "(", "NumVectorElts", ")", "{", "case", "2", ":", "RegClassID", "=", "AMDGPU", "::", "R600_Reg64RegClassID", ";", "break", ";", "case", "4", ":", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BUILD_VERTICAL_VECTOR", ")", "RegClassID", "=", "AMDGPU", "::", "R600_Reg128VerticalRegClassID", ";", "else", "RegClassID", "=", "AMDGPU", "::", "R600_Reg128RegClassID", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Do not know how to lower this BUILD_VECTOR\"", ")", ";", "}", "SelectBuildVector", "(", "N", ",", "RegClassID", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "AMDGPU", "R600", "1", "AMDGPUISD::BUILD_VERTICAL_VECTOR", "ISD::SCALAR_TO_VECTOR", "ISD::BUILD_VECTOR", "0", "2", "AMDGPU::R600_Reg64RegClassID", "4", "AMDGPUISD::BUILD_VERTICAL_VECTOR", "AMDGPU::R600_Reg128VerticalRegClassID", "AMDGPU::R600_Reg128RegClassID", "\"Do not know how to lower this BUILD_VECTOR\"" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "DIV_INF", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "FMAX", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "R600", "0" ]

[]

[ "<s>", "static", "void", "process_cfa_register", "(", "FILE", "*", "out_file", ",", "rtx", "pat", ",", "bool", "unwind", ")", "{", "rtx", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "pat", ")", ";", "int", "dest_regno", "=", "REGNO", "(", "dest", ")", ";", "int", "src_regno", ";", "if", "(", "src", "==", "pc_rtx", ")", "{", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save rp, r%d\\n\"", ",", "ia64_dbx_register_number", "(", "dest_regno", ")", ")", ";", "return", ";", "}", "src_regno", "=", "REGNO", "(", "src", ")", ";", "switch", "(", "src_regno", ")", "{", "case", "PR_REG", "(", "0", ")", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_pr", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save pr, r%d\\n\"", ",", "ia64_dbx_register_number", "(", "dest_regno", ")", ")", ";", "break", ";", "case", "AR_UNAT_REGNUM", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_ar_unat", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save ar.unat, r%d\\n\"", ",", "ia64_dbx_register_number", "(", "dest_regno", ")", ")", ";", "break", ";", "case", "AR_LC_REGNUM", ":", "gcc_assert", "(", "dest_regno", "==", "current_frame_info", ".", "r", "[", "reg_save_ar_lc", "]", ")", ";", "if", "(", "unwind", ")", "fprintf", "(", "out_file", ",", "\"\\t.save ar.lc, r%d\\n\"", ",", "ia64_dbx_register_number", "(", "dest_regno", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "function", "processes", "a", "SET", "pattern", "for", "REG_CFA_REGISTER", "." ]

[ "ia64", "\"\\t.save rp, r%d\\n\"", "0", "\"\\t.save pr, r%d\\n\"", "\"\\t.save ar.unat, r%d\\n\"", "\"\\t.save ar.lc, r%d\\n\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "STI", ".", "is64Bit", "(", ")", "||", "!", "Fn", "->", "hasPersonalityFn", "(", ")", "||", "classifyEHPersonality", "(", "MF", ".", "getFunction", "(", ")", "->", "getPersonalityFn", "(", ")", ")", "!=", "EHPersonality", "::", "MSVC_CXX", ")", "return", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "MinFixedObjOffset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "I", "<", "0", ";", "++", "I", ")", "MinFixedObjOffset", "=", "std", "::", "min", "(", "MinFixedObjOffset", ",", "MFI", "->", "getObjectOffset", "(", "I", ")", ")", ";", "int64_t", "UnwindHelpOffset", "=", "MinFixedObjOffset", "-", "SlotSize", ";", "int", "UnwindHelpFI", "=", "MFI", "->", "CreateFixedObject", "(", "SlotSize", ",", "UnwindHelpOffset", ",", "false", ")", ";", "MF", ".", "getMMI", "(", ")", ".", "getWinEHFuncInfo", "(", "Fn", ")", ".", "UnwindHelpFrameIdx", "=", "UnwindHelpFI", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "MBBI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "++", "MBBI", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV64mi32", ")", ")", ",", "UnwindHelpFI", ")", ".", "addImm", "(", "-", "2", ")", ";", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "X86", "X86", "0", "0", "X86::MOV64mi32", "2" ]

[]

[ "<s>", "unsigned", "MCS51InstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "NewDestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "MCS51", "::", "JMPk", ")", ")", ".", "addMBB", "(", "&", "NewDestBB", ")", ";", "return", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "MCS51", "MCS51", "MCS51::JMPk" ]

[]

[ "<s>", "bool", "isKMasked", "(", ")", "const", "{", "return", "(", "Attributes", "&", "(", "KMergeMasked", "|", "KZeroMasked", ")", ")", "!=", "0", ";", "}", "</s>" ]

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

[ "X86", "0" ]

[]

[ "<s>", "rtx", "legitimize_address", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Try", "machine-dependent", "ways", "of", "modifying", "an", "illegitimate", "address", "X", "to", "be", "legitimate", ".", "If", "we", "find", "one", ",", "return", "the", "new", ",", "valid", "address", ".", "OLDX", "is", "the", "address", "as", "it", "was", "before", "break_out_memory_refs", "was", "called", ".", "In", "some", "cases", "it", "is", "useful", "to", "look", "at", "this", "to", "decide", "what", "needs", "to", "be", "done", ".", "MODE", "is", "the", "mode", "of", "the", "operand", "pointed", "to", "by", "X", "." ]

[ "bfin" ]

[]

[ "<s>", "static", "bool", "s390_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "addr", ",", "bool", "strict", ")", "{", "struct", "s390_address", "ad", ";", "if", "(", "TARGET_Z10", "&&", "larl_operand", "(", "addr", ",", "VOIDmode", ")", "&&", "(", "mode", "==", "VOIDmode", "||", "s390_check_symref_alignment", "(", "addr", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "return", "true", ";", "if", "(", "!", "s390_decompose_address", "(", "addr", ",", "&", "ad", ")", ")", "return", "false", ";", "if", "(", "strict", ")", "{", "if", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "return", "false", ";", "if", "(", "ad", ".", "indx", "&&", "!", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "ad", ".", "base", "&&", "!", "(", "REGNO", "(", "ad", ".", "base", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "ad", ".", "base", ")", ")", "==", "ADDR_REGS", ")", ")", "return", "false", ";", "if", "(", "ad", ".", "indx", "&&", "!", "(", "REGNO", "(", "ad", ".", "indx", ")", ">=", "FIRST_PSEUDO_REGISTER", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", "==", "ADDR_REGS", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "is", "a", "valid", "memory", "address", ".", "STRICT", "specifies", "whether", "strict", "register", "checking", "applies", "." ]

[ "s390" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "aarch64_split_128bit_move_p", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "return", "(", "!", "REG_P", "(", "src", ")", "||", "!", "(", "FP_REGNUM_P", "(", "REGNO", "(", "dst", ")", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "src", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "should", "split", "a", "move", "from", "128-bit", "value", "SRC", "to", "128-bit", "register", "DEST", "." ]

[ "aarch64" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "createPatmosVLIWMachineSched", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "RC", "==", "&", "X86", "::", "GR8_NOREXRegClass", ")", "return", "RC", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "TargetRegisterClass", "*", "Super", "=", "RC", ";", "TargetRegisterClass", "::", "sc_iterator", "I", "=", "RC", "->", "getSuperClasses", "(", ")", ";", "do", "{", "switch", "(", "Super", "->", "getID", "(", ")", ")", "{", "case", "X86", "::", "FR32RegClassID", ":", "case", "X86", "::", "FR64RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "VR128RegClassID", ":", "case", "X86", "::", "VR256RegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", "&&", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "break", ";", "case", "X86", "::", "FR32XRegClassID", ":", "case", "X86", "::", "FR64XRegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasVLX", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "X86", "::", "VR128XRegClassID", ":", "case", "X86", "::", "VR256XRegClassID", ":", "if", "(", "!", "Subtarget", ".", "hasAVX512", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "X86", "::", "GR8RegClassID", ":", "case", "X86", "::", "GR16RegClassID", ":", "case", "X86", "::", "GR32RegClassID", ":", "case", "X86", "::", "GR64RegClassID", ":", "case", "X86", "::", "RFP32RegClassID", ":", "case", "X86", "::", "RFP64RegClassID", ":", "case", "X86", "::", "RFP80RegClassID", ":", "case", "X86", "::", "VR512RegClassID", ":", "if", "(", "Super", "->", "getSize", "(", ")", "==", "RC", "->", "getSize", "(", ")", ")", "return", "Super", ";", "}", "Super", "=", "*", "I", "++", ";", "}", "while", "(", "Super", ")", ";", "return", "RC", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "X86", "X86", "X86::GR8_NOREXRegClass", "X86", "X86", "X86::FR32RegClassID", "X86::FR64RegClassID", "X86::VR128RegClassID", "X86::VR256RegClassID", "X86::FR32XRegClassID", "X86::FR64XRegClassID", "X86::VR128XRegClassID", "X86::VR256XRegClassID", "X86::GR8RegClassID", "X86::GR16RegClassID", "X86::GR32RegClassID", "X86::GR64RegClassID", "X86::RFP32RegClassID", "X86::RFP64RegClassID", "X86::RFP80RegClassID", "X86::VR512RegClassID" ]

[]

[ "<s>", "static", "rtx", "frv_volatile_memref", "(", "enum", "machine_mode", "mode", ",", "rtx", "arg", ")", "{", "rtx", "mem", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "memory_address", "(", "mode", ",", "arg", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "return", "mem", ";", "}", "</s>" ]

[ "Return", "a", "volatile", "memory", "reference", "of", "mode", "MODE", "whose", "address", "is", "ARG", "." ]

[ "frv", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "const", "MachineOperand", "*", "BaseOpA", "=", "nullptr", ",", "*", "BaseOpB", "=", "nullptr", ";", "int64_t", "OffsetA", "=", "0", ",", "OffsetB", "=", "0", ";", "unsigned", "WidthA", "=", "0", ",", "WidthB", "=", "0", ";", "bool", "OffsetAIsScalable", "=", "false", ",", "OffsetBIsScalable", "=", "false", ";", "assert", "(", "MIa", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIa must be a load or store.\"", ")", ";", "assert", "(", "MIb", ".", "mayLoadOrStore", "(", ")", "&&", "\"MIb must be a load or store.\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "getMemOperandWithOffsetWidth", "(", "MIa", ",", "BaseOpA", ",", "OffsetA", ",", "OffsetAIsScalable", ",", "WidthA", ",", "TRI", ")", "&&", "getMemOperandWithOffsetWidth", "(", "MIb", ",", "BaseOpB", ",", "OffsetB", ",", "OffsetBIsScalable", ",", "WidthB", ",", "TRI", ")", ")", "{", "if", "(", "BaseOpA", "->", "isIdenticalTo", "(", "*", "BaseOpB", ")", "&&", "OffsetAIsScalable", "==", "OffsetBIsScalable", ")", "{", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AArch64", "AArch64", "0", "0", "0", "0", "\"MIa must be a load or store.\"", "\"MIb must be a load or store.\"" ]

[]

[ "<s>", "void", "HexagonMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "&", "HMB", "=", "const_cast", "<", "MCInst", "&", ">", "(", "MI", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "HMB", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Encoding bundle\\n\"", ";", ")", ";", "State", ".", "Addend", "=", "0", ";", "State", ".", "Extended", "=", "false", ";", "State", ".", "Bundle", "=", "&", "MI", ";", "State", ".", "Index", "=", "0", ";", "size_t", "Last", "=", "HexagonMCInstrInfo", "::", "bundleSize", "(", "HMB", ")", "-", "1", ";", "FeatureBitset", "Features", "=", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "HMB", ")", ")", "{", "MCInst", "&", "HMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "HMI", ",", "Features", ")", ";", "EncodeSingleInstruction", "(", "HMI", ",", "OS", ",", "Fixups", ",", "STI", ",", "parseBits", "(", "Last", ",", "HMB", ",", "HMI", ")", ")", ";", "State", ".", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "HMI", ")", ";", "State", ".", "Addend", "+=", "HEXAGON_INSTR_SIZE", ";", "++", "State", ".", "Index", ";", "}", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "\"Encoding bundle\\n\"", "0", "0", "Hexagon", "1", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "SIAnnotateControlFlow", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "LLVMContext", "&", "Context", "=", "M", ".", "getContext", "(", ")", ";", "Void", "=", "Type", "::", "getVoidTy", "(", "Context", ")", ";", "Boolean", "=", "Type", "::", "getInt1Ty", "(", "Context", ")", ";", "Int64", "=", "Type", "::", "getInt64Ty", "(", "Context", ")", ";", "ReturnStruct", "=", "StructType", "::", "get", "(", "Boolean", ",", "Int64", ",", "(", "Type", "*", ")", "nullptr", ")", ";", "BoolTrue", "=", "ConstantInt", "::", "getTrue", "(", "Context", ")", ";", "BoolFalse", "=", "ConstantInt", "::", "getFalse", "(", "Context", ")", ";", "BoolUndef", "=", "UndefValue", "::", "get", "(", "Boolean", ")", ";", "Int64Zero", "=", "ConstantInt", "::", "get", "(", "Int64", ",", "0", ")", ";", "If", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if", ")", ";", "Else", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_else", ")", ";", "Break", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_break", ")", ";", "IfBreak", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_if_break", ")", ";", "ElseBreak", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_else_break", ")", ";", "Loop", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_loop", ")", ";", "EndCf", "=", "Intrinsic", "::", "getDeclaration", "(", "&", "M", ",", "Intrinsic", "::", "amdgcn_end_cf", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_if", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_else", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_if_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_else_break", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_loop", "Intrinsic::getDeclaration", "Intrinsic::amdgcn_end_cf" ]

[]

[ "<s>", "inline", "hashval_t", "registered_function_hasher", "::", "hash", "(", "value_type", "value", ")", "{", "return", "value", "->", "instance", ".", "hash", "(", ")", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "VideocoreTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "Chain", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "ISD::InputArg" ]

[]

[ "<s>", "void", "SPIRVMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ",", "SPIRV", "::", "ModuleAnalysisInfo", "*", "MAI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getMF", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "Register", "FuncReg", "=", "MAI", "->", "getFuncReg", "(", "MO", ".", "getGlobal", "(", ")", "->", "getGlobalIdentifier", "(", ")", ")", ";", "assert", "(", "FuncReg", ".", "isValid", "(", ")", "&&", "\"Cannot find function Id\"", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "FuncReg", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MAI", "->", "getOrCreateMBBRegister", "(", "*", "MO", ".", "getMBB", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "{", "Register", "NewReg", "=", "MAI", "->", "getRegisterAlias", "(", "MF", ",", "MO", ".", "getReg", "(", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "NewReg", ".", "isValid", "(", ")", "?", "NewReg", ":", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "MCOp", "=", "MCOperand", "::", "createDFPImm", "(", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "SPIRV", "SPIRV", "SPIRV::ModuleAnalysisInfo", "0", "\"unknown operand type\"", "\"Cannot find function Id\"" ]

[]

[ "<s>", "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "AArch64", "::", "X1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "AArch64", "AArch64::X1" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDSri", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDLri", "||", "MI", ".", "getOpcode", "(", ")", "==", "VE", "::", "LDUri", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE::LDSri", "VE::LDLri", "VE::LDUri", "1", "2", "2", "0", "1", "0", "0" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Set p2align Operands\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "XCoreSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "XCore", "XCore", "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "static", "void", "mcore_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "ptr_pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "args_so_far", "=", "get_cumulative_args", "(", "args_so_far_v", ")", ";", "current_function_anonymous_args", "=", "1", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "number_of_regs_before_varargs", "+=", "mcore_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", ";", "if", "(", "number_of_regs_before_varargs", ">", "NPARM_REGS", ")", "number_of_regs_before_varargs", "=", "NPARM_REGS", ";", "}", "</s>" ]

[ "Keep", "track", "of", "some", "information", "about", "varargs", "for", "the", "prolog", "." ]

[ "mcore", "1" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "return", "createX86MachObjectWriter", "(", "OS", ",", "true", ",", "MachO", "::", "CPU_TYPE_X86_64", ",", "Subtype", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "pa_adjust_insn_length", "(", "rtx", "insn", ",", "int", "length", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_BTABLE_BRANCH", ")", "return", "4", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "pat", ")", "!=", "SEQUENCE", "&&", "GET_CODE", "(", "pat", ")", "!=", "USE", "&&", "GET_CODE", "(", "pat", ")", "!=", "CLOBBER", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_MILLI", ")", "return", "4", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "MEM", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", ")", "==", "BLKmode", ")", "return", "compute_movmem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", "&&", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "MEM", "&&", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "1", ")", "==", "const0_rtx", "&&", "GET_MODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ",", "0", ")", ")", "==", "BLKmode", ")", "return", "compute_clrmem_length", "(", "insn", ")", "-", "4", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "!", "simplejump_p", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "length", "==", "4", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "return", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_PARALLEL_BRANCH", "&&", "length", "==", "4", ")", "return", "4", ";", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "==", "REG", "&&", "!", "FP_REG_P", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", "&&", "length", "==", "4", "&&", "!", "forward_branch_p", "(", "insn", ")", ")", "return", "4", ";", "else", "return", "0", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "any", "length", "adjustment", "needed", "by", "INSN", "which", "already", "has", "its", "length", "computed", "as", "LENGTH", ".", "Return", "zero", "if", "no", "adjustment", "is", "necessary", ".", "For", "the", "PA", ":", "function", "calls", ",", "millicode", "calls", ",", "and", "backwards", "short", "conditional", "branches", "with", "unfilled", "delay", "slots", "need", "an", "adjustment", "by", "+1", "(", "to", "account", "for", "the", "NOP", "which", "will", "be", "inserted", "into", "the", "instruction", "stream", ")", ".", "Also", "compute", "the", "length", "of", "an", "inline", "block", "move", "here", "as", "it", "is", "too", "complicated", "to", "express", "as", "a", "length", "attribute", "in", "pa.md", "." ]

[ "pa", "4", "4", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "4", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "4", "4", "4", "4", "4", "0", "1", "0", "1", "0", "0", "1", "0", "4", "4", "0", "0" ]

[]

[ "<s>", "unsigned", "AlphaRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "llvm_unreachable", "(", "\"What is the return address register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "\"What is the return address register\"", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDriw_f", ":", "case", "Hexagon", "::", "STriw", ":", "case", "Hexagon", "::", "STriw_f", ":", "assert", "(", "(", "Offset", "%", "4", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrid_f", ":", "case", "Hexagon", "::", "STrid", ":", "case", "Hexagon", "::", "STrid_f", ":", "assert", "(", "(", "Offset", "%", "8", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDriuh", ":", "case", "Hexagon", "::", "STrih", ":", "assert", "(", "(", "Offset", "%", "2", "==", "0", ")", "&&", "\"Offset has incorrect alignment\"", ")", ";", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "STrib", ":", "case", "Hexagon", "::", "LDriub", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "ADD_ri", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "MEMw_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_MEM_V4", ":", "assert", "(", "(", "Offset", "%", "4", ")", "==", "0", "&&", "\"MEMOPw offset is not aligned correctly.\"", ")", ";", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "MEMh_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_MEM_V4", ":", "assert", "(", "(", "Offset", "%", "2", ")", "==", "0", "&&", "\"MEMOPh offset is not aligned correctly.\"", ")", ";", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "MEMb_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_MEM_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "Hexagon::LDriw", "Hexagon::LDriw_f", "Hexagon::STriw", "Hexagon::STriw_f", "4", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrid", "Hexagon::LDrid_f", "Hexagon::STrid", "Hexagon::STrid_f", "8", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrih", "Hexagon::LDriuh", "Hexagon::STrih", "2", "0", "\"Offset has incorrect alignment\"", "Hexagon", "Hexagon", "Hexagon::LDrib", "Hexagon::STrib", "Hexagon::LDriub", "Hexagon", "Hexagon", "Hexagon::ADD_ri", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::MEMw_ADDi_indexed_MEM_V4", "Hexagon::MEMw_SUBi_indexed_MEM_V4", "Hexagon::MEMw_ADDr_indexed_MEM_V4", "Hexagon::MEMw_SUBr_indexed_MEM_V4", "Hexagon::MEMw_ANDr_indexed_MEM_V4", "Hexagon::MEMw_ORr_indexed_MEM_V4", "Hexagon::MEMw_ADDi_MEM_V4", "Hexagon::MEMw_SUBi_MEM_V4", "Hexagon::MEMw_ADDr_MEM_V4", "Hexagon::MEMw_SUBr_MEM_V4", "Hexagon::MEMw_ANDr_MEM_V4", "Hexagon::MEMw_ORr_MEM_V4", "4", "0", "\"MEMOPw offset is not aligned correctly.\"", "0", "255", "Hexagon::MEMh_ADDi_indexed_MEM_V4", "Hexagon::MEMh_SUBi_indexed_MEM_V4", "Hexagon::MEMh_ADDr_indexed_MEM_V4", "Hexagon::MEMh_SUBr_indexed_MEM_V4", "Hexagon::MEMh_ANDr_indexed_MEM_V4", "Hexagon::MEMh_ORr_indexed_MEM_V4", "Hexagon::MEMh_ADDi_MEM_V4", "Hexagon::MEMh_SUBi_MEM_V4", "Hexagon::MEMh_ADDr_MEM_V4", "Hexagon::MEMh_SUBr_MEM_V4", "Hexagon::MEMh_ANDr_MEM_V4", "Hexagon::MEMh_ORr_MEM_V4", "2", "0", "\"MEMOPh offset is not aligned correctly.\"", "0", "127", "Hexagon::MEMb_ADDi_indexed_MEM_V4", "Hexagon::MEMb_SUBi_indexed_MEM_V4", "Hexagon::MEMb_ADDr_indexed_MEM_V4", "Hexagon::MEMb_SUBr_indexed_MEM_V4", "Hexagon::MEMb_ANDr_indexed_MEM_V4", "Hexagon::MEMb_ORr_indexed_MEM_V4", "Hexagon::MEMb_ADDi_MEM_V4", "Hexagon::MEMb_SUBi_MEM_V4", "Hexagon::MEMb_ADDr_MEM_V4", "Hexagon::MEMb_SUBr_MEM_V4", "Hexagon::MEMb_ANDr_MEM_V4", "Hexagon::MEMb_ORr_MEM_V4", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "static", "bool", "aarch64_short_vector_p", "(", "const_tree", "type", ",", "machine_mode", "mode", ")", "{", "poly_int64", "size", "=", "-", "1", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "aarch64_sve", "::", "builtin_type_p", "(", "type", ")", ")", "return", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "if", "(", "type", "&&", "aarch64_some_values_include_pst_objects_p", "(", "type", ")", ")", "gcc_assert", "(", "aarch64_sve_mode_p", "(", "mode", ")", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "if", "(", "known_eq", "(", "size", ",", "8", ")", "||", "known_eq", "(", "size", ",", "16", ")", ")", "{", "gcc_assert", "(", "!", "aarch64_sve_mode_p", "(", "mode", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "the", "type", ",", "as", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "short", "vector", "type", "as", "described", "in", "AAPCS64", "\\S", "4.1.2", ".", "See", "the", "comment", "above", "aarch64_composite_type_p", "for", "the", "notes", "on", "MODE", "." ]

[ "aarch64", "1", "aarch64_sve::builtin_type_p", "8", "16" ]

[]

[ "<s>", "void", "xstormy16_expand_andqi3", "(", "rtx", "*", "operands", ")", "{", "rtx", "in", ",", "out", ",", "outsub", ",", "val", ";", "out", "=", "operands", "[", "0", "]", ";", "in", "=", "operands", "[", "1", "]", ";", "val", "=", "operands", "[", "2", "]", ";", "if", "(", "xstormy16_onebit_clr_operand", "(", "val", ",", "QImode", ")", ")", "{", "if", "(", "!", "xstormy16_below100_or_register", "(", "in", ",", "QImode", ")", ")", "in", "=", "copy_to_mode_reg", "(", "QImode", ",", "in", ")", ";", "if", "(", "!", "xstormy16_below100_or_register", "(", "out", ",", "QImode", ")", ")", "out", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "emit_insn", "(", "gen_andqi3_internal", "(", "out", ",", "in", ",", "val", ")", ")", ";", "if", "(", "out", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "out", ")", ";", "return", ";", "}", "if", "(", "!", "REG_P", "(", "in", ")", ")", "in", "=", "copy_to_mode_reg", "(", "QImode", ",", "in", ")", ";", "if", "(", "!", "REG_P", "(", "val", ")", "&&", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "copy_to_mode_reg", "(", "QImode", ",", "val", ")", ";", "if", "(", "!", "REG_P", "(", "out", ")", ")", "out", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "in", "=", "simplify_gen_subreg", "(", "HImode", ",", "in", ",", "QImode", ",", "0", ")", ";", "outsub", "=", "simplify_gen_subreg", "(", "HImode", ",", "out", ",", "QImode", ",", "0", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "val", ")", ")", "val", "=", "simplify_gen_subreg", "(", "HImode", ",", "val", ",", "QImode", ",", "0", ")", ";", "emit_insn", "(", "gen_andhi3", "(", "outsub", ",", "in", ",", "val", ")", ")", ";", "if", "(", "out", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "out", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "for", "AND", "." ]

[ "stormy16", "0", "1", "2", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ",", "STI", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "if", "(", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBZ", "||", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBNZ", ")", "&&", "RelaxedOp", "==", "ARM", "::", "tHINT", ")", "{", "MCInst", "Res", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "14", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "0", ")", ")", ";", "Inst", "=", "std", "::", "move", "(", "Res", ")", ";", "return", ";", "}", "Inst", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "ARM", "ARM", "256", "\"\\n\"", "\"unexpected instruction to relax: \"", "ARM::tCBZ", "ARM::tCBNZ", "ARM::tHINT", "0", "14", "0" ]

[]

[ "<s>", "unsigned", "R600RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "R600", "::", "NoRegister", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600::NoRegister" ]

[]

[ "<s>", "static", "void", "ia64_file_start", "(", "void", ")", "{", "ia64_flag_var_tracking", "=", "flag_var_tracking", ";", "flag_var_tracking", "=", "0", ";", "default_file_start", "(", ")", ";", "emit_safe_across_calls", "(", ")", ";", "}", "</s>" ]

[ "Begin", "the", "assembly", "file", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "bool", "ClobbersEFLAGS", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Orig", "->", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "{", "ClobbersEFLAGS", "=", "true", ";", "break", ";", "}", "}", "if", "(", "ClobbersEFLAGS", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "int", "Value", ";", "switch", "(", "Orig", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "Value", "=", "0", ";", "break", ";", "case", "X86", "::", "MOV32r1", ":", "Value", "=", "1", ";", "break", ";", "case", "X86", "::", "MOV32r_1", ":", "Value", "=", "-", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "addOperand", "(", "Orig", "->", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "std", "::", "prev", "(", "I", ")", ";", "NewMI", "->", "substituteRegister", "(", "Orig", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::MOV32r0", "0", "X86::MOV32r1", "1", "X86::MOV32r_1", "1", "\"Unexpected instruction!\"", "X86::MOV32ri", "0", "0" ]

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", "&&", "AM", ".", "Scale", ")", "return", "false", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "Ty", "->", "isSized", "(", ")", ")", "{", "uint64_t", "NumBits", "=", "getDataLayout", "(", ")", "->", "getTypeSizeInBits", "(", "Ty", ")", ";", "NumBytes", "=", "NumBits", "/", "8", ";", "if", "(", "!", "isPowerOf2_64", "(", "NumBits", ")", ")", "NumBytes", "=", "0", ";", "}", "if", "(", "!", "AM", ".", "Scale", ")", "{", "int64_t", "Offset", "=", "AM", ".", "BaseOffs", ";", "if", "(", "Offset", ">=", "-", "(", "1LL", "<<", "9", ")", "&&", "Offset", "<=", "(", "1LL", "<<", "9", ")", "-", "1", ")", "return", "true", ";", "unsigned", "shift", "=", "Log2_64", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", "&&", "Offset", ">", "0", "&&", "(", "Offset", "/", "NumBytes", ")", "<=", "(", "1LL", "<<", "12", ")", "-", "1", "&&", "(", "Offset", ">>", "shift", ")", "<<", "shift", "==", "Offset", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "!", "AM", ".", "Scale", "||", "AM", ".", "Scale", "==", "1", "||", "(", "AM", ".", "Scale", ">", "0", "&&", "(", "uint64_t", ")", "AM", ".", "Scale", "==", "NumBytes", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "0", "8", "0", "1LL", "9", "1LL", "9", "1", "0", "1LL", "12", "1", "1", "0" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_4", ")", ";", "else", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_16", ")", ";", "auto", "ParseResult", "=", "RISCVFeatures", "::", "parseFeatureBits", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "Feature64Bit", ")", ",", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "if", "(", "!", "ParseResult", ")", "{", "report_fatal_error", "(", "ParseResult", ".", "takeError", "(", ")", ")", ";", "}", "else", "{", "auto", "&", "ISAInfo", "=", "*", "ParseResult", ";", "emitTextAttribute", "(", "RISCVAttrs", "::", "ARCH", ",", "ISAInfo", "->", "toString", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRV32E", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_4", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_16", "RISCVFeatures::parseFeatureBits", "RISCV::Feature64Bit", "RISCVAttrs::ARCH" ]

[]

[ "<s>", "unsigned", "HexagonMCInst", "::", "getUnits", "(", "HexagonTargetMachine", "const", "&", "TM", ")", "const", "{", "const", "HexagonInstrInfo", "*", "QII", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "const", "InstrItineraryData", "*", "II", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrItineraryData", "(", ")", ";", "const", "InstrStage", "*", "IS", "=", "II", "->", "beginStage", "(", "QII", "->", "get", "(", "this", "->", "getOpcode", "(", ")", ")", ".", "getSchedClass", "(", ")", ")", ";", "return", "(", "IS", "->", "getUnits", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "choice", "of", "FUs", "." ]

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

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "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", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isDFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "bit_cast", "<", "double", ">", "(", "MO", ".", "getDFPImm", "(", ")", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "TargetTransformInfo", "SystemZTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "SystemZTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

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

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "const", "char", "*", "p", ";", "if", "(", "is64Bit", "(", ")", ")", "p", "=", "\"e-p:64:64-s:64-f64:64:64-i64:64:64-f80:128:128\"", ";", "else", "{", "if", "(", "isTargetDarwin", "(", ")", ")", "p", "=", "\"e-p:32:32-f64:32:64-i64:32:64-f80:128:128\"", ";", "else", "p", "=", "\"e-p:32:32-f64:32:64-i64:32:64-f80:32:32\"", ";", "}", "return", "std", "::", "string", "(", "p", ")", ";", "}", "</s>" ]

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

[ "X86", "\"e-p:64:64-s:64-f64:64:64-i64:64:64-f80:128:128\"", "\"e-p:32:32-f64:32:64-i64:32:64-f80:128:128\"", "\"e-p:32:32-f64:32:64-i64:32:64-f80:32:32\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "riscv_constant_alignment", "(", "const_tree", "exp", ",", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "(", "TREE_CODE", "(", "exp", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "exp", ")", "==", "CONSTRUCTOR", ")", "&&", "(", "riscv_align_data_type", "==", "riscv_align_data_type_xlen", ")", ")", "return", "MAX", "(", "align", ",", "BITS_PER_WORD", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", "." ]

[ "riscv" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "c6x_call_saved_register_used", "(", "tree", "call_expr", ")", "{", "CUMULATIVE_ARGS", "cum_v", ";", "cumulative_args_t", "cum", ";", "HARD_REG_SET", "call_saved_regset", ";", "tree", "parameter", ";", "machine_mode", "mode", ";", "tree", "type", ";", "rtx", "parm_rtx", ";", "int", "i", ";", "INIT_CUMULATIVE_ARGS", "(", "cum_v", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "cum", "=", "pack_cumulative_args", "(", "&", "cum_v", ")", ";", "COMPL_HARD_REG_SET", "(", "call_saved_regset", ",", "call_used_reg_set", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "call_expr_nargs", "(", "call_expr", ")", ";", "i", "++", ")", "{", "parameter", "=", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "type", "=", "TREE_TYPE", "(", "parameter", ")", ";", "gcc_assert", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "gcc_assert", "(", "mode", ")", ";", "if", "(", "pass_by_reference", "(", "&", "cum_v", ",", "mode", ",", "type", ",", "true", ")", ")", "{", "mode", "=", "Pmode", ";", "type", "=", "build_pointer_type", "(", "type", ")", ";", "}", "parm_rtx", "=", "c6x_function_arg", "(", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "c6x_function_arg_advance", "(", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "if", "(", "!", "parm_rtx", ")", "continue", ";", "if", "(", "REG_P", "(", "parm_rtx", ")", "&&", "overlaps_hard_reg_set_p", "(", "call_saved_regset", ",", "GET_MODE", "(", "parm_rtx", ")", ",", "REGNO", "(", "parm_rtx", ")", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "parm_rtx", ")", "==", "PARALLEL", ")", "{", "int", "n", "=", "XVECLEN", "(", "parm_rtx", ",", "0", ")", ";", "while", "(", "n", "--", ">", "0", ")", "{", "rtx", "x", "=", "XEXP", "(", "XVECEXP", "(", "parm_rtx", ",", "0", ",", "n", ")", ",", "0", ")", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "overlaps_hard_reg_set_p", "(", "call_saved_regset", ",", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "CALL_EXPR", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

[ "c6x", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "TMS320C64XFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "int", "frame_size", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ")", ";", "MBB", ".", "addLiveIn", "(", "TMS320C64X", "::", "B3", ")", ";", "frame_size", "=", "MFI", "->", "getStackSize", "(", ")", ";", "frame_size", "+=", "8", ";", "frame_size", "+=", "7", ";", "frame_size", "&=", "~", "7", ";", "const", "TMS320C64XInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "TMS320C64XInstrInfo", "::", "addDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TMS320C64X", "::", "prolog", ")", ")", ".", "addImm", "(", "frame_size", ")", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "TMS320C64X::B3", "8", "7", "7", "TMS320C64X", "TMS320C64X", "TMS320C64X::prolog" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "const", "bool", "restrict_addressing_modes_for_nacl", "=", "(", "(", "FlagSfiLoad", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "LOAD", ")", "||", "(", "FlagSfiStore", "&&", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "STORE", ")", ")", ";", "if", "(", "restrict_addressing_modes_for_nacl", ")", "{", "return", "false", ";", "}", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "!", "isLegal", ")", "return", "false", ";", "if", "(", "Ptr", "!=", "Base", ")", "{", "if", "(", "Ptr", "==", "Offset", "&&", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "!", "Subtarget", "->", "isThumb2", "(", ")", ")", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "if", "(", "Ptr", "!=", "Base", ")", "return", "false", ";", "}", "AM", "=", "isInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::LOAD", "ISD::STORE", "ISD::SEXTLOAD", "ARM", "ISD::ADD", "ISD::POST_INC", "ISD::POST_DEC" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "base_reg_adjustment_p", "(", "rtx", "set", ",", "rtx", "*", "base_reg", ",", "rtx", "*", "offset", ")", "{", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "REG_P", "(", "SET_DEST", "(", "set", ")", ")", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ")", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", ")", "{", "*", "base_reg", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "routine", "tests", "for", "the", "base", "register", "update", "SET", "in", "load/store", "multiple", "RTL", "insns", ",", "used", "in", "pop_operation_p", "and", "ldstwm_operation_p", "." ]

[ "nios2", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "ThumbRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "Register", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MI", ",", "BaseReg", ",", "Offset", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "rewriteFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "static", "bool", "aarch64_validate_march", "(", "const", "char", "*", "str", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_arch", "(", "str", ",", "res", ",", "isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "return", "true", ";", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing arch name in -march=%qs\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for -march\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier in -march=%qs\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Validate", "a", "command-line", "-march", "option", ".", "Parse", "the", "arch", "and", "extensions", "(", "if", "any", ")", "specified", "in", "STR", "and", "throw", "errors", "if", "appropriate", ".", "Put", "the", "results", ",", "if", "they", "are", "valid", ",", "in", "RES", "and", "ISA_FLAGS", ".", "Return", "whether", "the", "option", "is", "valid", "." ]

[ "aarch64", "\"missing arch name in -march=%qs\"", "\"unknown value %qs for -march\"", "\"invalid feature modifier in -march=%qs\"" ]

[]

[ "<s>", "static", "rtx", "m68k_get_tls_get_addr", "(", "void", ")", "{", "if", "(", "m68k_tls_get_addr", "==", "NULL_RTX", ")", "m68k_tls_get_addr", "=", "init_one_libfunc", "(", "\"__tls_get_addr\"", ")", ";", "return", "m68k_tls_get_addr", ";", "}", "</s>" ]

[ "Return", "SYMBOL_REF", "for", "__tls_get_addr", "." ]

[ "m68k", "\"__tls_get_addr\"" ]

[]

[ "<s>", "const", "HexagonRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]