Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "SubsumesPredicate", "(", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred1", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred2", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "first", "specified", "predicate", "subsumes", "the", "second", ",", "e.g", "." ]

[ "R600" ]

[]

[ "<s>", "static", "int", "cr16_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "GENERAL_REGS", ")", ")", "return", "(", "4", "*", "HARD_REGNO_NREGS", "(", "0", ",", "mode", ")", ")", ";", "else", "return", "(", "100", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "of", "mode", "MODE", "between", "a", "register", "of", "class", "CLASS", "and", "memory", ";", "IN", "is", "zero", "if", "the", "value", "is", "to", "be", "written", "to", "memory", ",", "nonzero", "if", "it", "is", "to", "be", "read", "in", ".", "This", "cost", "is", "relative", "to", "those", "in", "REGISTER_MOVE_COST", "." ]

[ "cr16", "4", "0", "100" ]

[]

[ "<s>", "static", "void", "vector_init_bshuffle", "(", "rtx", "target", ",", "rtx", "elt", ",", "machine_mode", "mode", ",", "machine_mode", "inner_mode", ")", "{", "rtx", "t1", ",", "final_insn", ",", "sel", ";", "int", "bmask", ";", "t1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "elt", "=", "convert_modes", "(", "SImode", ",", "inner_mode", ",", "elt", ",", "true", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "SImode", ",", "t1", ")", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "V2SImode", ":", "final_insn", "=", "gen_bshufflev2si_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x45674567", ";", "break", ";", "case", "V4HImode", ":", "final_insn", "=", "gen_bshufflev4hi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x67676767", ";", "break", ";", "case", "V8QImode", ":", "final_insn", "=", "gen_bshufflev8qi_vis", "(", "target", ",", "t1", ",", "t1", ")", ";", "bmask", "=", "0x77777777", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "sel", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "bmask", ")", ")", ";", "emit_insn", "(", "gen_bmasksi_vis", "(", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ",", "sel", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "final_insn", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "sparc_expand_vector_init", ".", "Emit", "code", "to", "initialize", "all", "fields", "of", "TARGET", "to", "ELT", "by", "means", "of", "VIS2", "BSHUFFLE", "insn", ".", "MODE", "and", "INNER_MODE", "are", "the", "modes", "describing", "TARGET", "." ]

[ "sparc", "0x45674567", "0x67676767", "0x77777777", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Alignment", ",", "MachineMemOperand", "::", "Flags", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Subtarget", ".", "isHVXVectorType", "(", "SVT", ",", "true", ")", ")", "return", "allowsHvxMisalignedMemoryAccesses", "(", "SVT", ",", "Flags", ",", "Fast", ")", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "Hexagon", "Hexagon" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"MIPS Os16 Optimization\"", ";", "}", "</s>" ]

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

[ "Mips", "\"MIPS Os16 Optimization\"" ]

[]

[ "<s>", "void", "TLCS900InstrInfo", "::", "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", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "TLCS900", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TLCS900", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "TLCS900", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TLCS900", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "TLCS900", "TLCS900", "TLCS900::GR16RegClass", "TLCS900::MOV16rm", "0", "TLCS900::GR8RegClass", "TLCS900::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "rtx", "emit_frame_insn", "(", "rtx", "x", ")", "{", "x", "=", "emit_insn", "(", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "Wrapper", "around", "emit_insn", "that", "sets", "RTX_FRAME_RELATED_P", "on", "the", "insn", "." ]

[ "visium", "1" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFHI64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFHI64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMFLO64", ":", "expandPseudoMFHiLo", "(", "MBB", ",", "MI", ",", "Mips", "::", "MFLO64", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO", ",", "Mips", "::", "MTHI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI64", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO64", ",", "Mips", "::", "MTHI64", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoMTLOHI_DSP", ":", "expandPseudoMTLoHi", "(", "MBB", ",", "MI", ",", "Mips", "::", "MTLO_DSP", ",", "Mips", "::", "MTHI_DSP", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64_64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64_64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RetRA", "Mips::RET", "Mips::PseudoMFHI", "Mips::MFHI", "Mips::PseudoMFLO", "Mips::MFLO", "Mips::PseudoMFHI64", "Mips::MFHI64", "Mips::PseudoMFLO64", "Mips::MFLO64", "Mips::PseudoMTLOHI", "Mips::MTLO", "Mips::MTHI", "Mips::PseudoMTLOHI64", "Mips::MTLO64", "Mips::MTHI64", "Mips::PseudoMTLOHI_DSP", "Mips::MTLO_DSP", "Mips::MTHI_DSP", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::BuildPairF64_64", "Mips::ExtractElementF64", "Mips::ExtractElementF64_64", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "static", "int", "mt_function_arg_slotno", "(", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ",", "int", "incoming_p", "ATTRIBUTE_UNUSED", ",", "int", "*", "pregno", ")", "{", "int", "regbase", "=", "FIRST_ARG_REGNUM", ";", "int", "slotno", "=", "*", "cum", ";", "if", "(", "mode", "==", "VOIDmode", "||", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "-", "1", ";", "if", "(", "slotno", ">=", "MT_NUM_ARG_REGS", ")", "return", "-", "1", ";", "*", "pregno", "=", "regbase", "+", "slotno", ";", "return", "slotno", ";", "}", "</s>" ]

[ "Compute", "the", "slot", "number", "to", "pass", "an", "argument", "in", ".", "Returns", "the", "slot", "number", "or", "-1", "if", "passing", "on", "the", "stack", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "INCOMING_P", "is", "zero", "for", "FUNCTION_ARG", ",", "nonzero", "for", "FUNCTION_INCOMING_ARG", ".", "*", "PREGNO", "records", "the", "register", "number", "to", "use", "if", "scalar", "type", "." ]

[ "mt", "1", "1" ]

[]

[ "<s>", "rtx", "ix86_memtag_untagged_pointer", "(", "rtx", "tagged_pointer", ",", "rtx", "target", ")", "{", "rtx", "tag_mask", "=", "gen_int_mode", "(", "(", "(", "HOST_WIDE_INT_1U", "<<", "IX86_HWASAN_SHIFT", ")", "+", "(", "HOST_WIDE_INT_1U", "<<", "63", ")", "-", "1", ")", ",", "Pmode", ")", ";", "rtx", "untagged_base", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "tagged_pointer", ",", "tag_mask", ",", "target", ",", "true", ",", "OPTAB_DIRECT", ")", ";", "gcc_assert", "(", "untagged_base", ")", ";", "return", "untagged_base", ";", "}", "</s>" ]

[ "The", "default", "implementation", "of", "TARGET_MEMTAG_UNTAGGED_POINTER", "." ]

[ "i386", "63", "1" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "AArch64", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "AArch64", "AArch64", "\"sp\"", "AArch64::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "static", "avr_map_op_t", "avr_map_decompose", "(", "unsigned", "int", "f", ",", "const", "avr_map_op_t", "*", "g", ",", "bool", "val_const_p", ")", "{", "bool", "val_used_p", "=", "avr_map_metric", "(", "f", ",", "MAP_MASK_PREIMAGE_F", ")", "!=", "0", ";", "avr_map_op_t", "f_ginv", "=", "*", "g", ";", "unsigned", "int", "ginv", "=", "g", "->", "ginv", ";", "f_ginv", ".", "cost", "=", "-", "1", ";", "for", "(", "int", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "int", "x", "=", "avr_map", "(", "f", ",", "i", ")", ";", "if", "(", "x", "<=", "7", ")", "{", "x", "=", "avr_map", "(", "ginv", ",", "x", ")", ";", "if", "(", "x", ">", "7", ")", "return", "f_ginv", ";", "}", "f_ginv", ".", "map", "=", "(", "f_ginv", ".", "map", "<<", "4", ")", "+", "x", ";", "}", "if", "(", "avr_map_metric", "(", "f_ginv", ".", "map", ",", "MAP_NONFIXED_0_7", ")", "==", "0", ")", "f_ginv", ".", "cost", "=", "2", "+", "(", "val_used_p", "&&", "!", "val_const_p", ")", ";", "else", "{", "rtx", "xop", "[", "4", "]", ";", "xop", "[", "0", "]", "=", "all_regs_rtx", "[", "24", "]", ";", "xop", "[", "1", "]", "=", "gen_int_mode", "(", "f_ginv", ".", "map", ",", "SImode", ")", ";", "xop", "[", "2", "]", "=", "all_regs_rtx", "[", "25", "]", ";", "xop", "[", "3", "]", "=", "val_used_p", "?", "xop", "[", "0", "]", ":", "const0_rtx", ";", "avr_out_insert_bits", "(", "xop", ",", "&", "f_ginv", ".", "cost", ")", ";", "f_ginv", ".", "cost", "+=", "val_const_p", "&&", "val_used_p", "?", "1", ":", "0", ";", "}", "f_ginv", ".", "cost", "+=", "g", "->", "cost", ";", "if", "(", "avr_log", ".", "builtin", ")", "avr_edump", "(", "\" %s%d=%d\"", ",", "g", "->", "str", ",", "g", "->", "arg", ",", "f_ginv", ".", "cost", ")", ";", "return", "f_ginv", ";", "}", "</s>" ]

[ "Try", "to", "decompose", "F", "as", "F", "=", "(", "F", "o", "G^-1", ")", "o", "G", "as", "described", "above", ".", "The", "result", "is", "a", "struct", "representing", "F", "o", "G^-1", "and", "G.", "If", "result.cost", "<", "0", "then", "such", "a", "decomposition", "does", "not", "exist", "." ]

[ "avr", "0", "1", "7", "0", "7", "7", "4", "0", "2", "4", "0", "24", "1", "2", "25", "3", "0", "1", "0", "\" %s%d=%d\"" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_recurse", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "type", ",", "HOST_WIDE_INT", "startbitpos", ",", "rtx", "rvec", "[", "]", ",", "int", "*", "k", ")", "{", "tree", "f", ";", "for", "(", "f", "=", "TYPE_FIELDS", "(", "type", ")", ";", "f", ";", "f", "=", "TREE_CHAIN", "(", "f", ")", ")", "if", "(", "TREE_CODE", "(", "f", ")", "==", "FIELD_DECL", ")", "{", "HOST_WIDE_INT", "bitpos", "=", "startbitpos", ";", "tree", "ftype", "=", "TREE_TYPE", "(", "f", ")", ";", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "ftype", ")", ";", "if", "(", "DECL_SIZE", "(", "f", ")", "!=", "0", "&&", "host_integerp", "(", "bit_position", "(", "f", ")", ",", "1", ")", ")", "bitpos", "+=", "int_bit_position", "(", "f", ")", ";", "if", "(", "TREE_CODE", "(", "ftype", ")", "==", "RECORD_TYPE", ")", "rs6000_darwin64_record_arg_recurse", "(", "cum", ",", "ftype", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "else", "if", "(", "cum", "->", "named", "&&", "USE_FP_FOR_ARG_P", "(", "cum", ",", "mode", ",", "ftype", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "SCmode", ":", "mode", "=", "SFmode", ";", "break", ";", "case", "DCmode", ":", "mode", "=", "DFmode", ";", "break", ";", "case", "TCmode", ":", "mode", "=", "TFmode", ";", "break", ";", "default", ":", "break", ";", "}", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "if", "(", "mode", "==", "TFmode", ")", "cum", "->", "fregno", "++", ";", "}", "else", "if", "(", "cum", "->", "named", "&&", "USE_ALTIVEC_FOR_ARG_P", "(", "cum", ",", "mode", ",", "ftype", ",", "1", ")", ")", "{", "rs6000_darwin64_record_arg_flush", "(", "cum", ",", "bitpos", ",", "rvec", ",", "k", ")", ";", "rvec", "[", "(", "*", "k", ")", "++", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "vregno", "++", ")", ",", "GEN_INT", "(", "bitpos", "/", "BITS_PER_UNIT", ")", ")", ";", "}", "else", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "cum", "->", "intoffset", "=", "bitpos", ";", "}", "}", "</s>" ]

[ "Recursive", "workhorse", "for", "the", "following", "." ]

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

[]

[ "<s>", "int", "SystemZRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "SystemZ", "SystemZ", "0", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Collect LOH **********\\n\"", "<<", "\"Looking in function \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LOHInfo", "LOHInfos", "[", "N_GPR_REGS", "]", ";", "AArch64FunctionInfo", "&", "AFI", "=", "*", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "const", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "memset", "(", "LOHInfos", ",", "0", ",", "sizeof", "(", "LOHInfos", ")", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "Succ", ":", "MBB", ".", "successors", "(", ")", ")", "{", "for", "(", "const", "auto", "&", "LI", ":", "Succ", "->", "liveins", "(", ")", ")", "{", "int", "RegIdx", "=", "mapRegToGPRIndex", "(", "LI", ".", "PhysReg", ")", ";", "if", "(", "RegIdx", ">=", "0", ")", "LOHInfos", "[", "RegIdx", "]", ".", "OneUser", "=", "true", ";", "}", "}", "for", "(", "const", "MachineInstr", "&", "MI", ":", "instructionsWithoutDebug", "(", "MBB", ".", "instr_rbegin", "(", ")", ",", "MBB", ".", "instr_rend", "(", ")", ")", ")", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "if", "(", "canDefBePartOfLOH", "(", "MI", ")", ")", "{", "const", "MachineOperand", "&", "Def", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "assert", "(", "Def", ".", "isReg", "(", ")", "&&", "Def", ".", "isDef", "(", ")", "&&", "\"Expected reg def\"", ")", ";", "assert", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", "&&", "\"Expected reg use\"", ")", ";", "int", "DefIdx", "=", "mapRegToGPRIndex", "(", "Def", ".", "getReg", "(", ")", ")", ";", "int", "OpIdx", "=", "mapRegToGPRIndex", "(", "Op", ".", "getReg", "(", ")", ")", ";", "if", "(", "DefIdx", ">=", "0", "&&", "OpIdx", ">=", "0", "&&", "handleMiddleInst", "(", "MI", ",", "LOHInfos", "[", "DefIdx", "]", ",", "LOHInfos", "[", "OpIdx", "]", ")", ")", "continue", ";", "}", "break", ";", "case", "AArch64", "::", "ADRP", ":", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "int", "Idx", "=", "mapRegToGPRIndex", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "if", "(", "Idx", ">=", "0", ")", "{", "handleADRP", "(", "MI", ",", "AFI", ",", "LOHInfos", "[", "Idx", "]", ",", "LOHInfos", ")", ";", "continue", ";", "}", "break", ";", "}", "handleNormalInst", "(", "MI", ",", "LOHInfos", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Collect LOH **********\\n\"", "\"Looking in function \"", "AArch64", "AArch64", "0", "0", "AArch64::ADDXri", "AArch64::LDRXui", "AArch64::LDRWui", "0", "1", "\"Expected reg def\"", "\"Expected reg use\"", "0", "0", "AArch64::ADRP", "0", "0" ]

[]

[ "<s>", "void", "xstormy16_expand_arith", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "src0", ",", "rtx", "src1", ")", "{", "int", "num_words", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "BITS_PER_WORD", ";", "int", "i", ";", "int", "firstloop", "=", "1", ";", "if", "(", "code", "==", "NEG", ")", "emit_move_insn", "(", "src0", ",", "const0_rtx", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "num_words", ";", "i", "++", ")", "{", "rtx", "w_src0", ",", "w_src1", ",", "w_dest", ";", "rtx", "insn", ";", "w_src0", "=", "simplify_gen_subreg", "(", "word_mode", ",", "src0", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "w_src1", "=", "simplify_gen_subreg", "(", "word_mode", ",", "src1", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "w_dest", "=", "simplify_gen_subreg", "(", "word_mode", ",", "dest", ",", "mode", ",", "i", "*", "UNITS_PER_WORD", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "if", "(", "firstloop", "&&", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "0", ")", "continue", ";", "if", "(", "firstloop", ")", "insn", "=", "gen_addchi4", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "else", "insn", "=", "gen_addchi5", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "break", ";", "case", "NEG", ":", "case", "MINUS", ":", "case", "COMPARE", ":", "if", "(", "code", "==", "COMPARE", "&&", "i", "==", "num_words", "-", "1", ")", "{", "rtx", "branch", ",", "sub", ",", "clobber", ",", "sub_1", ";", "sub_1", "=", "gen_rtx_MINUS", "(", "HImode", ",", "w_src0", ",", "gen_rtx_ZERO_EXTEND", "(", "HImode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ")", ";", "sub", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "w_dest", ",", "gen_rtx_MINUS", "(", "HImode", ",", "sub_1", ",", "w_src1", ")", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "BImode", ",", "CARRY_REGNUM", ")", ")", ";", "branch", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "HImode", ",", "sub_1", ",", "w_src1", ")", ",", "pc_rtx", ",", "pc_rtx", ")", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "3", ",", "branch", ",", "sub", ",", "clobber", ")", ")", ";", "}", "else", "if", "(", "firstloop", "&&", "code", "!=", "COMPARE", "&&", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "0", ")", "continue", ";", "else", "if", "(", "firstloop", ")", "insn", "=", "gen_subchi4", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "else", "insn", "=", "gen_subchi5", "(", "w_dest", ",", "w_src0", ",", "w_src1", ")", ";", "break", ";", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "if", "(", "CONST_INT_P", "(", "w_src1", ")", "&&", "INTVAL", "(", "w_src1", ")", "==", "-", "(", "code", "==", "AND", ")", ")", "continue", ";", "insn", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "w_dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "w_src0", ",", "w_src1", ")", ")", ";", "break", ";", "case", "NOT", ":", "insn", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "w_dest", ",", "gen_rtx_NOT", "(", "mode", ",", "w_src0", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "firstloop", "=", "0", ";", "emit", "(", "insn", ")", ";", "}", "if", "(", "firstloop", ")", "emit", "(", "gen_nop", "(", ")", ")", ";", "}", "</s>" ]

[ "Expander", "for", "arithmetic", "operations", ";", "emit", "insns", "to", "compute", "(", "set", "DEST", "(", "CODE", ":", "MODE", "SRC0", "SRC1", ")", ")", "using", "CARRY", "as", "a", "temporary", ".", "When", "CODE", "is", "COMPARE", ",", "a", "branch", "template", "is", "generated", "(", "this", "saves", "duplicating", "code", "in", "xstormy16_split_cbranch", ")", "." ]

[ "stormy16", "1", "0", "0", "1", "3", "0", "0" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "getSchedModel", "(", ")", ".", "isOutOfOrder", "(", ")", "&&", "isSwift", "(", ")", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "Hexagon", "\"Hexagon Branch Relaxation\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "WebAssemblyAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "WebAssembly", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_code_sleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "{", "\"fixup_code_sleb128_i64\"", ",", "0", ",", "10", "*", "8", ",", "0", "}", ",", "{", "\"fixup_code_uleb128_i32\"", ",", "0", ",", "5", "*", "8", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::NumTargetFixupKinds", "\"fixup_code_sleb128_i32\"", "0", "5", "8", "0", "\"fixup_code_sleb128_i64\"", "0", "10", "8", "0", "\"fixup_code_uleb128_i32\"", "0", "5", "8", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TD", "=", "Fn", ".", "getTarget", "(", ")", ".", "getTargetData", "(", ")", ";", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "Fn", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "Fn", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "ix86_mode_needed", "(", "int", "entity", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_needed", "(", "insn", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_needed", "(", "insn", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "case", "I387_MASK_PM", ":", "return", "ix86_i387_mode_needed", "(", "entity", ",", "insn", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "needed", "mode", "for", "entity", "in", "optimize_mode_switching", "pass", "." ]

[ "i386", "0" ]

[]

[ "<s>", "bool", "function_resolver", "::", "require_matching_vector_type", "(", "unsigned", "int", "argno", ",", "type_suffix_index", "type", ")", "{", "type_suffix_index", "new_type", "=", "infer_vector_type", "(", "argno", ")", ";", "if", "(", "new_type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "false", ";", "if", "(", "type", "!=", "new_type", ")", "{", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, but\"", "\" previous arguments had type %qT\"", ",", "get_vector_type", "(", "new_type", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "get_vector_type", "(", "type", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Like", "require_vector_type", ",", "but", "TYPE", "is", "inferred", "from", "previous", "arguments", "rather", "than", "being", "a", "fixed", "part", "of", "the", "function", "signature", ".", "This", "changes", "the", "nature", "of", "the", "error", "messages", "." ]

[ "aarch64", "\"passing %qT to argument %d of %qE, but\"", "\" previous arguments had type %qT\"", "1" ]

[]

[ "<s>", "bool", "MBlazeAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "csky_split_ior", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "mask", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "i", ";", "if", "(", "mask", "==", "0", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "return", "true", ";", "}", "if", "(", "mask", "==", "-", "1", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "gen_int_mode", "(", "-", "1", ",", "SImode", ")", ")", ";", "return", "true", ";", "}", "if", "(", "CSKY_ISA_FEATURE", "(", "E2", ")", "&&", "csky_literal_I_operand", "(", "operands", "[", "2", "]", ",", "SImode", ")", ")", "return", "false", ";", "if", "(", "popcount_hwi", "(", "mask", "&", "0xffffffff", ")", "<=", "(", "reload_completed", "&&", "!", "CSKY_ISA_FEATURE", "(", "E2", ")", "?", "1", ":", "2", ")", ")", "{", "rtx", "input", "=", "operands", "[", "1", "]", ";", "if", "(", "!", "CSKY_ISA_FEATURE", "(", "E2", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "input", ")", ";", "input", "=", "operands", "[", "0", "]", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "{", "emit_insn", "(", "gen_bseti", "(", "operands", "[", "0", "]", ",", "input", ",", "GEN_INT", "(", "i", ")", ")", ")", ";", "input", "=", "operands", "[", "0", "]", ";", "}", "return", "true", ";", "}", "if", "(", "reload_completed", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "operands", "[", "2", "]", "=", "operands", "[", "1", "]", ";", "operands", "[", "1", "]", "=", "operands", "[", "0", "]", ";", "}", "else", "operands", "[", "2", "]", "=", "copy_to_mode_reg", "(", "SImode", ",", "operands", "[", "2", "]", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Split", "operands", "for", "an", "IOR", "expression", "when", "OPERANDS", "[", "2", "]", "is", "a", "constant", ".", "Note", "operands", "[", "0", "]", "is", "marked", "earlyclobber", "in", "this", "case", "and", "can", "be", "overwritten", ".", "Return", "true", "if", "``", "DONE", "''", ",", "false", "otherwise", "." ]

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

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "!", "DisableCTRLoops", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCCTRLoops", "(", "getPPCTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "pdp11_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "DImode", "||", "(", "FLOAT_MODE_P", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "!", "TARGET_AC0", ")", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "COMPLEX_MODE_P", "(", "TYPE_MODE", "(", "type", ")", ")", ")", ";", "}", "</s>" ]

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

[ "pdp11" ]

[]

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

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

[ "ARC", "\"ARC Assembly Printer\"" ]

[]

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

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

[ "ia64", "0", "0" ]

[]

[ "<s>", "bool", "X86MCInstrAnalysis", "::", "isDependencyBreaking", "(", "const", "MCSubtargetInfo", "&", "STI", ",", "const", "MCInst", "&", "Inst", ")", "const", "{", "if", "(", "STI", ".", "getCPU", "(", ")", "==", "\"btver2\"", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SBB32rr", ":", "case", "X86", "::", "SBB64rr", ":", "case", "X86", "::", "XOR32rr", ":", "case", "X86", "::", "XOR64rr", ":", "case", "X86", "::", "XORPSrr", ":", "case", "X86", "::", "XORPDrr", ":", "case", "X86", "::", "VXORPSrr", ":", "case", "X86", "::", "VXORPDrr", ":", "case", "X86", "::", "ANDNPSrr", ":", "case", "X86", "::", "VANDNPSrr", ":", "case", "X86", "::", "ANDNPDrr", ":", "case", "X86", "::", "VANDNPDrr", ":", "case", "X86", "::", "PXORrr", ":", "case", "X86", "::", "VPXORrr", ":", "case", "X86", "::", "PANDNrr", ":", "case", "X86", "::", "VPANDNrr", ":", "case", "X86", "::", "PSUBBrr", ":", "case", "X86", "::", "PSUBWrr", ":", "case", "X86", "::", "PSUBDrr", ":", "case", "X86", "::", "PSUBQrr", ":", "case", "X86", "::", "VPSUBBrr", ":", "case", "X86", "::", "VPSUBWrr", ":", "case", "X86", "::", "VPSUBDrr", ":", "case", "X86", "::", "VPSUBQrr", ":", "case", "X86", "::", "PCMPEQBrr", ":", "case", "X86", "::", "PCMPEQWrr", ":", "case", "X86", "::", "PCMPEQDrr", ":", "case", "X86", "::", "PCMPEQQrr", ":", "case", "X86", "::", "VPCMPEQBrr", ":", "case", "X86", "::", "VPCMPEQWrr", ":", "case", "X86", "::", "VPCMPEQDrr", ":", "case", "X86", "::", "VPCMPEQQrr", ":", "case", "X86", "::", "PCMPGTBrr", ":", "case", "X86", "::", "PCMPGTWrr", ":", "case", "X86", "::", "PCMPGTDrr", ":", "case", "X86", "::", "PCMPGTQrr", ":", "case", "X86", "::", "VPCMPGTBrr", ":", "case", "X86", "::", "VPCMPGTWrr", ":", "case", "X86", "::", "VPCMPGTDrr", ":", "case", "X86", "::", "VPCMPGTQrr", ":", "case", "X86", "::", "MMX_PXORirr", ":", "case", "X86", "::", "MMX_PANDNirr", ":", "case", "X86", "::", "MMX_PSUBBirr", ":", "case", "X86", "::", "MMX_PSUBDirr", ":", "case", "X86", "::", "MMX_PSUBQirr", ":", "case", "X86", "::", "MMX_PSUBWirr", ":", "case", "X86", "::", "MMX_PCMPGTBirr", ":", "case", "X86", "::", "MMX_PCMPGTDirr", ":", "case", "X86", "::", "MMX_PCMPGTWirr", ":", "case", "X86", "::", "MMX_PCMPEQBirr", ":", "case", "X86", "::", "MMX_PCMPEQDirr", ":", "case", "X86", "::", "MMX_PCMPEQWirr", ":", "return", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP64rr", ":", "return", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "is", "a", "dependency", "breaking", "instruction", "for", "the", "subtarget", "." ]

[ "X86", "X86", "\"btver2\"", "X86::SUB32rr", "X86::SUB64rr", "X86::SBB32rr", "X86::SBB64rr", "X86::XOR32rr", "X86::XOR64rr", "X86::XORPSrr", "X86::XORPDrr", "X86::VXORPSrr", "X86::VXORPDrr", "X86::ANDNPSrr", "X86::VANDNPSrr", "X86::ANDNPDrr", "X86::VANDNPDrr", "X86::PXORrr", "X86::VPXORrr", "X86::PANDNrr", "X86::VPANDNrr", "X86::PSUBBrr", "X86::PSUBWrr", "X86::PSUBDrr", "X86::PSUBQrr", "X86::VPSUBBrr", "X86::VPSUBWrr", "X86::VPSUBDrr", "X86::VPSUBQrr", "X86::PCMPEQBrr", "X86::PCMPEQWrr", "X86::PCMPEQDrr", "X86::PCMPEQQrr", "X86::VPCMPEQBrr", "X86::VPCMPEQWrr", "X86::VPCMPEQDrr", "X86::VPCMPEQQrr", "X86::PCMPGTBrr", "X86::PCMPGTWrr", "X86::PCMPGTDrr", "X86::PCMPGTQrr", "X86::VPCMPGTBrr", "X86::VPCMPGTWrr", "X86::VPCMPGTDrr", "X86::VPCMPGTQrr", "X86::MMX_PXORirr", "X86::MMX_PANDNirr", "X86::MMX_PSUBBirr", "X86::MMX_PSUBDirr", "X86::MMX_PSUBQirr", "X86::MMX_PSUBWirr", "X86::MMX_PCMPGTBirr", "X86::MMX_PCMPGTDirr", "X86::MMX_PCMPGTWirr", "X86::MMX_PCMPEQBirr", "X86::MMX_PCMPEQDirr", "X86::MMX_PCMPEQWirr", "1", "2", "X86::CMP32rr", "X86::CMP64rr", "0", "1" ]

[]

[ "<s>", "static", "void", "sparc_asm_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_FLAT", ")", "gcc_assert", "(", "sparc_leaf_function_p", "==", "crtl", "->", "uses_only_leaf_regs", ")", ";", "sparc_output_scratch_registers", "(", "file", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "entry", ",", "which", "boils", "down", "to", "emitting", "the", "necessary", ".register", "directives", "." ]

[ "sparc" ]

[]

[ "<s>", "type_suffix_index", "function_resolver", "::", "infer_vector_type", "(", "unsigned", "int", "argno", ")", "{", "return", "infer_vector_or_tuple_type", "(", "argno", ",", "1", ")", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "have", "some", "form", "of", "vector", "type", ".", "Return", "the", "associated", "type", "suffix", "on", "success", ",", "using", "TYPE_SUFFIX_b", "for", "predicates", ".", "Report", "an", "error", "and", "return", "NUM_TYPE_SUFFIXES", "on", "failure", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isFLAT", "(", "FirstLdSt", ")", "&&", "isFLAT", "(", "SecondLdSt", ")", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "}", "else", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "else", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "return", "(", "NumLoads", "*", "(", "RI", ".", "getRegSizeInBits", "(", "*", "DstRC", ")", "/", "8", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16", "8" ]

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "inClass", "(", "BF", "::", "DPRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE32fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "D16RegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE16fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "AnyCCRegClass", ",", "SrcReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "STORE8fi", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "(", "std", "::", "string", "(", "\"Cannot store regclass to stack slot: \"", ")", "+", "RC", "->", "getName", "(", ")", ")", ".", "c_str", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::DPRegClass", "BF::STORE32fi", "0", "BF::D16RegClass", "BF::STORE16fi", "0", "BF::AnyCCRegClass", "BF::STORE8fi", "0", "\"Cannot store regclass to stack slot: \"" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "lowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "lowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "lowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_DWARF_CFA", ":", "return", "lowerEH_DWARF_CFA", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "lowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "lowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::ADDRSPACECAST", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART", "ISD::VAARG", "ISD::VACOPY", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::EH_DWARF_CFA", "ISD::FP_TO_SINT", "ISD::BR_JT" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "microblaze_starting_frame_offset", "(", "void", ")", "{", "return", "(", "crtl", "->", "outgoing_args_size", "+", "FIRST_PARM_OFFSET", "(", "FNDECL", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", "." ]

[ "microblaze" ]

[]

[ "<s>", "bool", "ResourceAssignment", "::", "Schedule", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "isPseudo", "(", "SU", ")", ")", "return", "true", ";", "return", "ScheduleOnSide", "(", "SU", ",", "TMS320C64XInstrInfo", "::", "getSide", "(", "SU", "->", "getInstr", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Schedule", "-", "Order", "nodes", "according", "to", "selected", "style", ",", "filling", "in", "the", "Sequence", "member", "." ]

[ "TMS320C64X", "TMS320C64X" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isCommutativeBinOp", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "AVG", ":", "case", "X86ISD", "::", "PCMPEQ", ":", "case", "X86ISD", "::", "PMULDQ", ":", "case", "X86ISD", "::", "PMULUDQ", ":", "case", "X86ISD", "::", "FMAXC", ":", "case", "X86ISD", "::", "FMINC", ":", "case", "X86ISD", "::", "FAND", ":", "case", "X86ISD", "::", "FOR", ":", "case", "X86ISD", "::", "FXOR", ":", "return", "true", ";", "}", "return", "TargetLoweringBase", "::", "isCommutativeBinOp", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "opcode", "is", "a", "commutative", "binary", "operation", "." ]

[ "X86", "X86", "X86ISD::AVG", "X86ISD::PCMPEQ", "X86ISD::PMULDQ", "X86ISD::PMULUDQ", "X86ISD::FMAXC", "X86ISD::FMINC", "X86ISD::FAND", "X86ISD::FOR", "X86ISD::FXOR" ]

[]

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

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

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

[]

[ "<s>", "static", "void", "reset_origins", "(", "int", "*", "rp", ",", "int", "*", "age", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "rp", "[", "i", "]", "=", "i", ";", "age", "[", "i", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "Helper", "function", "to", "reset", "the", "origins", "in", "RP", "and", "the", "age", "in", "AGE", "for", "all", "registers", "." ]

[ "rl78", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "output_sibcall", "(", "rtx", "insn", ",", "rtx", "call_operand", ")", "{", "rtx", "operands", "[", "1", "]", ";", "gcc_assert", "(", "flag_delayed_branch", ")", ";", "operands", "[", "0", "]", "=", "call_operand", ";", "if", "(", "sparc_leaf_function_p", ")", "{", "gcc_assert", "(", "!", "(", "LEAF_SIBCALL_SLOT_RESERVED_P", "&&", "final_sequence", ")", ")", ";", "if", "(", "final_sequence", ")", "output_asm_insn", "(", "\"sethi\\t%%hi(%a0), %%g1\\n\\tjmp\\t%%g1 + %%lo(%a0)%#\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"or\\t%%o7, %%g0, %%g1\\n\\tcall\\t%a0, 0\\n\\t or\\t%%g1, %%g0, %%o7\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"call\\t%a0, 0\"", ",", "operands", ")", ";", "if", "(", "final_sequence", ")", "{", "rtx", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "gcc_assert", "(", "delay", ")", ";", "output_restore", "(", "PATTERN", "(", "delay", ")", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "else", "output_restore", "(", "NULL_RTX", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "sibling", "call", "." ]

[ "sparc", "1", "0", "\"sethi\\t%%hi(%a0), %%g1\\n\\tjmp\\t%%g1 + %%lo(%a0)%#\"", "\"or\\t%%o7, %%g0, %%g1\\n\\tcall\\t%a0, 0\\n\\t or\\t%%g1, %%g0, %%o7\"", "\"call\\t%a0, 0\"", "1", "\"\"" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InGlue", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "assert", "(", "!", "isVarArg", "&&", "\"Unsupported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_LEG", ")", ";", "for", "(", "auto", "&", "Loc", ":", "RVLocs", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Loc", ".", "getLocReg", "(", ")", ",", "Loc", ".", "getValVT", "(", ")", ",", "InGlue", ")", ".", "getValue", "(", "1", ")", ";", "InGlue", "=", "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", "." ]

[ "LEG", "LEG", "ISD::InputArg", "\"Unsupported\"", "16", "LEG", "1", "2", "0" ]

[]

[ "<s>", "void", "rs6000_xcoff_asm_output_aligned_decl_common", "(", "FILE", "*", "stream", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "unsigned", "HOST_WIDE_INT", "align2", "=", "2", ";", "if", "(", "align", ">", "32", ")", "align2", "=", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ";", "else", "if", "(", "size", ">", "4", ")", "align2", "=", "3", ";", "fputs", "(", "COMMON_ASM_OP", ",", "stream", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "size", ",", "align2", ")", ";", "fputs", "(", "rs6000_xcoff_visibility", "(", "decl", ")", ",", "stream", ")", ";", "putc", "(", "'\\n'", ",", "stream", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "language", "to", "define", "a", "symbol", "as", "COMMON", "from", "a", "DECL", ",", "possibly", "with", "visibility", "." ]

[ "rs6000", "2", "32", "4", "3", "\",\"", "\",\"" ]

[]

[ "<s>", "bool", "ARMFrameInfo", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "12", ")", "-", "1", ")", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "ARM", "1", "12", "1", "2" ]

[]

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

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPostRegAlloc", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "unsigned", "Count", "=", "CSI", ".", "size", "(", ")", ";", "DebugLoc", "DL", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "2", ")", "{", "unsigned", "idx", "=", "Count", "-", "i", "-", "2", ";", "unsigned", "Reg1", "=", "CSI", "[", "idx", "]", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "CSI", "[", "idx", "+", "1", "]", ".", "getReg", "(", ")", ";", "assert", "(", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "+", "1", "==", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "&&", "\"Out of order callee saved regs!\"", ")", ";", "unsigned", "StrOpc", ";", "assert", "(", "(", "Count", "&", "1", ")", "==", "0", "&&", "\"Odd number of callee-saved regs to spill!\"", ")", ";", "assert", "(", "(", "i", "&", "1", ")", "==", "0", "&&", "\"Odd index for callee-saved reg spill!\"", ")", ";", "if", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected GPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPXpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPXi", ";", "}", "else", "if", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg1", ")", ")", "{", "assert", "(", "AArch64", "::", "FPR64RegClass", ".", "contains", "(", "Reg2", ")", "&&", "\"Expected FPR64 callee-saved register pair!\"", ")", ";", "if", "(", "i", "==", "0", ")", "StrOpc", "=", "AArch64", "::", "STPDpre", ";", "else", "StrOpc", "=", "AArch64", "::", "STPDi", ";", "}", "else", "llvm_unreachable", "(", "\"Unexpected callee saved register!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", "<<", "\") -> fi#(\"", "<<", "CSI", "[", "idx", "]", ".", "getFrameIdx", "(", ")", "<<", "\", \"", "<<", "CSI", "[", "idx", "+", "1", "]", ".", "getFrameIdx", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "(", "i", "==", "0", ")", "?", "-", "Count", ":", "i", ";", "assert", "(", "(", "Offset", ">=", "-", "64", "&&", "Offset", "<=", "63", ")", "&&", "\"Offset out of bounds for STP immediate\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "if", "(", "StrOpc", "==", "AArch64", "::", "STPDpre", "||", "StrOpc", "==", "AArch64", "::", "STPXpre", ")", "MIB", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "0", "2", "2", "1", "1", "1", "\"Out of order callee saved regs!\"", "1", "0", "\"Odd number of callee-saved regs to spill!\"", "1", "0", "\"Odd index for callee-saved reg spill!\"", "AArch64::GPR64RegClass", "AArch64::GPR64RegClass", "\"Expected GPR64 callee-saved register pair!\"", "0", "AArch64::STPXpre", "AArch64::STPXi", "AArch64::FPR64RegClass", "AArch64::FPR64RegClass", "\"Expected FPR64 callee-saved register pair!\"", "0", "AArch64::STPDpre", "AArch64::STPDi", "\"Unexpected callee saved register!\"", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "0", "64", "63", "\"Offset out of bounds for STP immediate\"", "AArch64::STPDpre", "AArch64::STPXpre", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "void", "riscv_move_integer", "(", "rtx", "temp", ",", "rtx", "dest", ",", "HOST_WIDE_INT", "value", ")", "{", "struct", "riscv_integer_op", "codes", "[", "RISCV_MAX_INTEGER_OPS", "]", ";", "enum", "machine_mode", "mode", ";", "int", "i", ",", "num_ops", ";", "rtx", "x", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "num_ops", "=", "riscv_build_integer", "(", "codes", ",", "value", ",", "mode", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "num_ops", ">", "2", "&&", "num_ops", ">=", "riscv_split_integer_cost", "(", "value", ")", ")", "x", "=", "riscv_split_integer", "(", "value", ",", "mode", ")", ";", "else", "{", "x", "=", "GEN_INT", "(", "codes", "[", "0", "]", ".", "value", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_ops", ";", "i", "++", ")", "{", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "x", "=", "riscv_emit_set", "(", "temp", ",", "x", ")", ";", "else", "x", "=", "force_reg", "(", "mode", ",", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "codes", "[", "i", "]", ".", "code", ",", "mode", ",", "x", ",", "GEN_INT", "(", "codes", "[", "i", "]", ".", "value", ")", ")", ";", "}", "}", "riscv_emit_set", "(", "dest", ",", "x", ")", ";", "}", "</s>" ]

[ "Load", "VALUE", "into", "DEST", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", "." ]

[ "riscv", "2", "0", "1" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "Size", ",", "1", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "1" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "sparc_compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "int", "leaf_function", ")", "{", "HOST_WIDE_INT", "frame_size", ",", "apparent_frame_size", ";", "int", "args_size", ",", "n_global_fp_regs", "=", "0", ";", "bool", "save_local_in_regs_p", "=", "false", ";", "unsigned", "int", "i", ";", "if", "(", "leaf_function", "&&", "!", "cfun", "->", "calls_alloca", ")", "args_size", "=", "0", ";", "else", "args_size", "=", "crtl", "->", "outgoing_args_size", "+", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", ";", "if", "(", "TARGET_ARCH64", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "+=", "2", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", "||", "save_global_or_fp_reg_p", "(", "i", "+", "1", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "}", "if", "(", "TARGET_FLAT", ")", "for", "(", "i", "=", "16", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "save_local_or_in_reg_p", "(", "i", ",", "leaf_function", ")", ")", "{", "save_local_in_regs_p", "=", "true", ";", "break", ";", "}", "for", "(", "i", "=", "32", ";", "i", "<", "(", "TARGET_V9", "?", "96", ":", "64", ")", ";", "i", "+=", "2", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", "||", "save_global_or_fp_reg_p", "(", "i", "+", "1", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "if", "(", "size", "==", "0", "&&", "n_global_fp_regs", "==", "0", "&&", "args_size", "==", "0", "&&", "!", "save_local_in_regs_p", ")", "frame_size", "=", "apparent_frame_size", "=", "0", ";", "else", "{", "apparent_frame_size", "=", "ROUND_UP", "(", "size", ",", "8", ")", "+", "n_global_fp_regs", "*", "4", ";", "frame_size", "=", "apparent_frame_size", "+", "ROUND_UP", "(", "args_size", ",", "8", ")", ";", "frame_size", "+=", "FIRST_PARM_OFFSET", "(", "cfun", "->", "decl", ")", ";", "frame_size", "=", "SPARC_STACK_ALIGN", "(", "frame_size", ")", ";", "}", "sparc_frame_size", "=", "frame_size", ";", "sparc_apparent_frame_size", "=", "apparent_frame_size", ";", "sparc_n_global_fp_regs", "=", "n_global_fp_regs", ";", "sparc_save_local_in_regs_p", "=", "save_local_in_regs_p", ";", "return", "frame_size", ";", "}", "</s>" ]

[ "Compute", "the", "frame", "size", "required", "by", "the", "function", ".", "This", "function", "is", "called", "during", "the", "reload", "pass", "and", "also", "by", "sparc_expand_prologue", "." ]

[ "sparc", "0", "0", "0", "8", "0", "2", "0", "8", "2", "0", "1", "0", "2", "16", "32", "32", "96", "64", "2", "0", "1", "0", "2", "0", "0", "0", "0", "8", "4", "8" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMBaseInstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "MachineBasicBlock", "::", "iterator", "CallPt", ";", "unsigned", "Opc", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "Opc", "=", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "isThumb", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "MIB", ")", ";", "return", "It", ";", "}", "Opc", "=", "isThumb", "?", "ARM", "::", "tBL", ":", "ARM", "::", "BL", ";", "MachineInstrBuilder", "CallMIB", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ";", "if", "(", "isThumb", ")", "CallMIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "CallMIB", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerNoLRSave", "||", "C", ".", "CallConstructionID", "==", "MachineOutlinerThunk", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "return", "It", ";", "}", "const", "ARMFunctionInfo", "&", "AFI", "=", "*", "C", ".", "getMF", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerRegSave", ")", "{", "unsigned", "Reg", "=", "findRegisterToSaveLRTo", "(", "C", ")", ";", "assert", "(", "Reg", "!=", "0", "&&", "\"No callee-saved register available?\"", ")", ";", "copyPhysReg", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "Reg", ",", "ARM", "::", "LR", ",", "true", ")", ";", "if", "(", "!", "AFI", ".", "isLRSpilled", "(", ")", ")", "emitCFIForLRSaveToReg", "(", "MBB", ",", "It", ",", "Reg", ")", ";", "CallPt", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "copyPhysReg", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "ARM", "::", "LR", ",", "Reg", ",", "true", ")", ";", "if", "(", "!", "AFI", ".", "isLRSpilled", "(", ")", ")", "emitCFIForLRRestoreFromReg", "(", "MBB", ",", "It", ")", ";", "It", "--", ";", "return", "CallPt", ";", "}", "saveLROnStack", "(", "MBB", ",", "It", ")", ";", "if", "(", "!", "AFI", ".", "isLRSpilled", "(", ")", ")", "emitCFIForLRSaveOnStack", "(", "MBB", ",", "It", ")", ";", "CallPt", "=", "MBB", ".", "insert", "(", "It", ",", "CallMIB", ")", ";", "restoreLRFromStack", "(", "MBB", ",", "It", ")", ";", "if", "(", "!", "AFI", ".", "isLRSpilled", "(", ")", ")", "emitCFIForLRRestoreFromStack", "(", "MBB", ",", "It", ")", ";", "It", "--", ";", "return", "CallPt", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "ARM", "ARM", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARM::tBL", "ARM::BL", "ARMCC::AL", "ARM", "ARM", "0", "\"No callee-saved register available?\"", "ARM::LR", "ARM::LR" ]

[]

[ "<s>", "static", "unsigned", "selectBinaryOp", "(", "unsigned", "GenericOpc", ",", "unsigned", "RegBankID", ",", "unsigned", "OpSize", ")", "{", "switch", "(", "RegBankID", ")", "{", "case", "AArch64", "::", "GPRRegBankID", ":", "if", "(", "OpSize", "==", "32", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVWr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVWr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVWr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "else", "if", "(", "OpSize", "==", "64", ")", "{", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "AArch64", "::", "ADDXrr", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "return", "AArch64", "::", "LSLVXr", ";", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "AArch64", "::", "LSRVXr", ";", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "AArch64", "::", "ASRVXr", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "case", "AArch64", "::", "FPRRegBankID", ":", "switch", "(", "OpSize", ")", "{", "case", "32", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDSrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBSrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULSrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVSrr", ";", "default", ":", "return", "GenericOpc", ";", "}", "case", "64", ":", "switch", "(", "GenericOpc", ")", "{", "case", "TargetOpcode", "::", "G_FADD", ":", "return", "AArch64", "::", "FADDDrr", ";", "case", "TargetOpcode", "::", "G_FSUB", ":", "return", "AArch64", "::", "FSUBDrr", ";", "case", "TargetOpcode", "::", "G_FMUL", ":", "return", "AArch64", "::", "FMULDrr", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "AArch64", "::", "FDIVDrr", ";", "case", "TargetOpcode", "::", "G_OR", ":", "return", "AArch64", "::", "ORRv8i8", ";", "default", ":", "return", "GenericOpc", ";", "}", "}", "}", ";", "return", "GenericOpc", ";", "}", "</s>" ]

[ "Select", "and", "emit", "code", "for", "a", "binary", "operator", "instruction", ",", "which", "has", "an", "opcode", "which", "directly", "corresponds", "to", "the", "given", "ISD", "opcode", "." ]

[ "AArch64", "AArch64::GPRRegBankID", "32", "AArch64::LSLVWr", "AArch64::LSRVWr", "AArch64::ASRVWr", "64", "AArch64::ADDXrr", "AArch64::LSLVXr", "AArch64::LSRVXr", "AArch64::ASRVXr", "AArch64::FPRRegBankID", "32", "AArch64::FADDSrr", "AArch64::FSUBSrr", "AArch64::FMULSrr", "AArch64::FDIVSrr", "64", "AArch64::FADDDrr", "AArch64::FSUBDrr", "AArch64::FMULDrr", "AArch64::FDIVDrr", "AArch64::ORRv8i8" ]

[]

[ "<s>", "static", "rtx", "m68k_wrap_symbol", "(", "rtx", "x", ",", "enum", "m68k_reloc", "reloc", ",", "rtx", "base_reg", ",", "rtx", "temp_reg", ")", "{", "bool", "use_x_p", ";", "use_x_p", "=", "(", "base_reg", "==", "pic_offset_table_rtx", ")", "?", "TARGET_XGOT", ":", "TARGET_XTLS", ";", "if", "(", "TARGET_COLDFIRE", "&&", "use_x_p", ")", "{", "x", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "reloc", ")", ")", ",", "UNSPEC_RELOC32", ")", ";", "x", "=", "gen_rtx_CONST", "(", "Pmode", ",", "x", ")", ";", "if", "(", "temp_reg", "==", "NULL", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "temp_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "emit_move_insn", "(", "temp_reg", ",", "x", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "temp_reg", ",", "temp_reg", ",", "base_reg", ")", ")", ";", "x", "=", "temp_reg", ";", "}", "else", "{", "x", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "GEN_INT", "(", "reloc", ")", ")", ",", "UNSPEC_RELOC16", ")", ";", "x", "=", "gen_rtx_CONST", "(", "Pmode", ",", "x", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg", ",", "x", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Wrap", "symbol", "X", "into", "unspec", "representing", "relocation", "RELOC", ".", "BASE_REG", "-", "register", "that", "should", "be", "added", "to", "the", "result", ".", "TEMP_REG", "-", "if", "non-null", ",", "temporary", "register", "." ]

[ "m68k", "2", "2" ]

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "ADJUSTSTACKDOWN", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "-", "Amount", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "Alpha", "::", "ADJUSTSTACKUP", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "Amount", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", ")", "." ]

[ "Alpha", "Alpha", "0", "0", "1", "Alpha::ADJUSTSTACKDOWN", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::ADJUSTSTACKUP", "Alpha::LDA", "Alpha::R30", "Alpha::R30" ]

[]

[ "<s>", "static", "unsigned", "int", "insn_is_store_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "MEM_P", "(", "SET_DEST", "(", "body", ")", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "PARALLEL", ")", "return", "0", ";", "rtx", "set", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "is", "a", "store", "insn", ",", "including", "permuting", "stores", "that", "represent", "an", "stvxd2x", "instruction", ";", "else", "return", "0", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "Intel_OCL_BI", ")", "{", "if", "(", "IsWin64", "&&", "HasAVX", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "Is64Bit", "&&", "HasAVX", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADDE", ":", "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "{", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "return", "Val", ";", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::ADDE", "ISD::SUBE", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::SETCC", "Mips" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "classifyLEAReg", "(", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "Src", ",", "unsigned", "Opc", ",", "bool", "AllowSP", ",", "unsigned", "&", "NewSrc", ",", "bool", "&", "isKill", ",", "MachineOperand", "&", "ImplicitOp", ",", "LiveVariables", "*", "LV", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "AllowSP", ")", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "}", "else", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64_NOSPRegClass", ":", "&", "X86", "::", "GR32_NOSPRegClass", ";", "}", "unsigned", "SrcReg", "=", "Src", ".", "getReg", "(", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "LEA64_32r", ")", "{", "NewSrc", "=", "SrcReg", ";", "isKill", "=", "Src", ".", "isKill", "(", ")", ";", "assert", "(", "!", "Src", ".", "isUndef", "(", ")", "&&", "\"Undef op doesn't need optimization\"", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "NewSrc", ")", "&&", "!", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "NewSrc", ",", "RC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", ")", "{", "ImplicitOp", "=", "Src", ";", "ImplicitOp", ".", "setImplicit", "(", ")", ";", "NewSrc", "=", "getX86SubSuperRegister", "(", "Src", ".", "getReg", "(", ")", ",", "64", ")", ";", "isKill", "=", "Src", ".", "isKill", "(", ")", ";", "assert", "(", "!", "Src", ".", "isUndef", "(", ")", "&&", "\"Undef op doesn't need optimization\"", ")", ";", "}", "else", "{", "NewSrc", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "MachineInstr", "*", "Copy", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ".", "addReg", "(", "NewSrc", ",", "RegState", "::", "Define", "|", "RegState", "::", "Undef", ",", "X86", "::", "sub_32bit", ")", ".", "add", "(", "Src", ")", ";", "isKill", "=", "true", ";", "if", "(", "LV", ")", "LV", "->", "replaceKillInstruction", "(", "SrcReg", ",", "MI", ",", "*", "Copy", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "operand", "within", "a", "MachineInstr", ",", "insert", "preceding", "code", "to", "put", "it", "into", "the", "right", "format", "for", "a", "particular", "kind", "of", "LEA", "instruction", "." ]

[ "X86", "X86", "X86::LEA32r", "X86::GR64RegClass", "X86::GR32RegClass", "X86::LEA32r", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "X86::LEA64_32r", "\"Undef op doesn't need optimization\"", "X86", "64", "\"Undef op doesn't need optimization\"", "X86::sub_32bit" ]

[]

[ "<s>", "void", "Thumb2RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "t2LDRpci", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "(", "int64_t", ")", "ARMCC", "::", "AL", ")", ".", "addReg", "(", "0", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::t2LDRpci", "ARMCC::AL", "0" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "int", "incoming", ")", "{", "cum", "->", "arg_words", "=", "0", ";", "cum", "->", "incoming", "=", "incoming", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "xtensa", "0" ]

[]

[ "<s>", "void", "PPCHazardRecognizer970", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "SDNode", "*", "Node", "=", "SU", "->", "getNode", "(", ")", "->", "getFlaggedMachineNode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Node", "->", "getOpcode", "(", ")", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "PPC", "::", "MTCTR", ")", "HasCTRSet", "=", "true", ";", "if", "(", "isStore", ")", "{", "unsigned", "ThisStoreSize", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown store instruction!\"", ")", ";", "case", "PPC", "::", "STB", ":", "case", "PPC", "::", "STB8", ":", "case", "PPC", "::", "STBU", ":", "case", "PPC", "::", "STBU8", ":", "case", "PPC", "::", "STBX", ":", "case", "PPC", "::", "STBX8", ":", "case", "PPC", "::", "STVEBX", ":", "ThisStoreSize", "=", "1", ";", "break", ";", "case", "PPC", "::", "STH", ":", "case", "PPC", "::", "STH8", ":", "case", "PPC", "::", "STHU", ":", "case", "PPC", "::", "STHU8", ":", "case", "PPC", "::", "STHX", ":", "case", "PPC", "::", "STHX8", ":", "case", "PPC", "::", "STVEHX", ":", "case", "PPC", "::", "STHBRX", ":", "ThisStoreSize", "=", "2", ";", "break", ";", "case", "PPC", "::", "STFS", ":", "case", "PPC", "::", "STFSU", ":", "case", "PPC", "::", "STFSX", ":", "case", "PPC", "::", "STWX", ":", "case", "PPC", "::", "STWX8", ":", "case", "PPC", "::", "STWUX", ":", "case", "PPC", "::", "STW", ":", "case", "PPC", "::", "STW8", ":", "case", "PPC", "::", "STWU", ":", "case", "PPC", "::", "STVEWX", ":", "case", "PPC", "::", "STFIWX", ":", "case", "PPC", "::", "STWBRX", ":", "ThisStoreSize", "=", "4", ";", "break", ";", "case", "PPC", "::", "STD_32", ":", "case", "PPC", "::", "STDX_32", ":", "case", "PPC", "::", "STD", ":", "case", "PPC", "::", "STDU", ":", "case", "PPC", "::", "STFD", ":", "case", "PPC", "::", "STFDX", ":", "case", "PPC", "::", "STDX", ":", "case", "PPC", "::", "STDUX", ":", "ThisStoreSize", "=", "8", ";", "break", ";", "case", "PPC", "::", "STVX", ":", "case", "PPC", "::", "STVXL", ":", "ThisStoreSize", "=", "16", ";", "break", ";", "}", "StoreSize", "[", "NumStores", "]", "=", "ThisStoreSize", ";", "StorePtr1", "[", "NumStores", "]", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "StorePtr2", "[", "NumStores", "]", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "++", "NumStores", ";", "}", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_BRU", "||", "isSingle", ")", "NumIssued", "=", "4", ";", "++", "NumIssued", ";", "if", "(", "isCracked", ")", "++", "NumIssued", ";", "if", "(", "NumIssued", "==", "5", ")", "EndDispatchGroup", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "PPC::MTCTR", "\"Unknown store instruction!\"", "PPC::STB", "PPC::STB8", "PPC::STBU", "PPC::STBU8", "PPC::STBX", "PPC::STBX8", "PPC::STVEBX", "1", "PPC::STH", "PPC::STH8", "PPC::STHU", "PPC::STHU8", "PPC::STHX", "PPC::STHX8", "PPC::STVEHX", "PPC::STHBRX", "2", "PPC::STFS", "PPC::STFSU", "PPC::STFSX", "PPC::STWX", "PPC::STWX8", "PPC::STWUX", "PPC::STW", "PPC::STW8", "PPC::STWU", "PPC::STVEWX", "PPC::STFIWX", "PPC::STWBRX", "4", "PPC::STD_32", "PPC::STDX_32", "PPC::STD", "PPC::STDU", "PPC::STFD", "PPC::STFDX", "PPC::STDX", "PPC::STDUX", "8", "PPC::STVX", "PPC::STVXL", "16", "1", "2", "PPCII::PPC970_BRU", "4", "5" ]

[]

[ "<s>", "void", "X86TTI", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "if", "(", "!", "UsePartialUnrolling", ")", "return", ";", "unsigned", "MaxBranches", ",", "MaxOps", ";", "if", "(", "PartialUnrollingThreshold", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "{", "MaxBranches", "=", "PartialUnrollingMaxBranches", ";", "MaxOps", "=", "PartialUnrollingThreshold", ";", "}", "else", "if", "(", "ST", "->", "isAtom", "(", ")", ")", "{", "MaxBranches", "=", "2", ";", "MaxOps", "=", "10", ";", "}", "else", "if", "(", "ST", "->", "hasFSGSBase", "(", ")", "&&", "ST", "->", "hasXOP", "(", ")", ")", "{", "MaxBranches", "=", "16", ";", "MaxOps", "=", "40", ";", "}", "else", "if", "(", "ST", "->", "hasFMA4", "(", ")", ")", "{", "return", ";", "}", "else", "if", "(", "ST", "->", "hasAVX", "(", ")", "||", "ST", "->", "hasSSE42", "(", ")", ")", "{", "MaxBranches", "=", "8", ";", "MaxOps", "=", "28", ";", "}", "else", "if", "(", "ST", "->", "hasSSSE3", "(", ")", ")", "{", "MaxBranches", "=", "4", ";", "MaxOps", "=", "18", ";", "}", "else", "{", "return", ";", "}", "unsigned", "MaxDepth", "=", "0", ";", "for", "(", "df_iterator", "<", "BasicBlock", "*", ">", "DI", "=", "df_begin", "(", "L", "->", "getHeader", "(", ")", ")", ",", "DE", "=", "df_end", "(", "L", "->", "getHeader", "(", ")", ")", ";", "DI", "!=", "DE", ";", ")", "{", "if", "(", "!", "L", "->", "contains", "(", "*", "DI", ")", ")", "{", "DI", ".", "skipChildren", "(", ")", ";", "continue", ";", "}", "MaxDepth", "=", "std", "::", "max", "(", "MaxDepth", ",", "DI", ".", "getPathLength", "(", ")", ")", ";", "if", "(", "MaxDepth", ">", "MaxBranches", ")", "return", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "DI", "->", "begin", "(", ")", ",", "IE", "=", "DI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "++", "DI", ";", "}", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "UP", ".", "PartialOptSizeThreshold", "=", "MaxOps", ";", "if", "(", "MaxDepth", ">", "1", ")", "UP", ".", "MaxCount", "=", "(", "MaxBranches", "-", "1", ")", "/", "(", "MaxDepth", "-", "1", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "2", "10", "16", "40", "8", "28", "4", "18", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "enum", "rtx_code", "ix86_prepare_sse_fp_compare_args", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "*", "pop0", ",", "rtx", "*", "pop1", ")", "{", "rtx", "tmp", ";", "switch", "(", "code", ")", "{", "case", "LTGT", ":", "case", "UNEQ", ":", "return", "UNKNOWN", ";", "case", "LT", ":", "case", "LE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "break", ";", "case", "EQ", ":", "case", "NE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "if", "(", "!", "dest", "||", "!", "rtx_equal_p", "(", "dest", ",", "*", "pop1", ")", ")", "break", ";", "case", "GE", ":", "case", "GT", ":", "case", "UNLE", ":", "case", "UNLT", ":", "tmp", "=", "*", "pop0", ";", "*", "pop0", "=", "*", "pop1", ";", "*", "pop1", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "code", ";", "}", "</s>" ]

[ "Swap", ",", "force", "into", "registers", ",", "or", "otherwise", "massage", "the", "two", "operands", "to", "an", "sse", "comparison", "with", "a", "mask", "result", ".", "Thus", "we", "differ", "a", "bit", "from", "ix86_prepare_fp_compare_args", "which", "expects", "to", "produce", "a", "flags", "result", ".", "The", "DEST", "operand", "exists", "to", "help", "determine", "whether", "to", "commute", "commutative", "operators", ".", "The", "POP0/POP1", "operands", "are", "updated", "in", "place", ".", "The", "new", "comparison", "code", "is", "returned", ",", "or", "UNKNOWN", "if", "not", "implementable", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "prevent_branch_around_nothing", "(", "void", ")", "{", "rtx_insn", "*", "seen_label", "=", "NULL", ";", "for", "(", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", "&&", "condjump_p", "(", "insn", ")", ")", "{", "seen_label", "=", "label_ref_label", "(", "nvptx_condjump_label", "(", "insn", ",", "false", ")", ")", ";", "continue", ";", "}", "if", "(", "seen_label", "==", "NULL", ")", "continue", ";", "if", "(", "NOTE_P", "(", "insn", ")", "||", "DEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_nvptx_fork", ":", "case", "CODE_FOR_nvptx_forked", ":", "case", "CODE_FOR_nvptx_joining", ":", "case", "CODE_FOR_nvptx_join", ":", "case", "CODE_FOR_nop", ":", "continue", ";", "case", "-", "1", ":", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_INPUT", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "ASM_OPERANDS", "||", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", ">=", "0", ")", ")", "continue", ";", "default", ":", "seen_label", "=", "NULL", ";", "continue", ";", "}", "if", "(", "LABEL_P", "(", "insn", ")", "&&", "insn", "==", "seen_label", ")", "emit_insn_before", "(", "gen_fake_nop", "(", ")", ",", "insn", ")", ";", "seen_label", "=", "NULL", ";", "}", "}", "</s>" ]

[ "Insert", "a", "dummy", "ptx", "insn", "when", "encountering", "a", "branch", "to", "a", "label", "with", "no", "ptx", "insn", "inbetween", "the", "branch", "and", "the", "label", ".", "This", "works", "around", "a", "JIT", "bug", "observed", "at", "driver", "version", "384.111", ",", "at", "-O0", "for", "sm_50", "." ]

[ "nvptx", "1", "0" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "return", "true", ";", "case", "MVT", "::", "f128", ":", "return", "Subtarget", ".", "hasVectorEnhancements1", "(", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "SystemZ", "SystemZ", "MVT::f32", "MVT::f64", "MVT::f128" ]

[]

[ "<s>", "bool", "M680x0InstrInfo", "::", "ExpandMOVSZX_RM", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "isSigned", ",", "const", "MCInstrDesc", "&", "Desc", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to LOAD and \"", ")", ";", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubDst", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "MVTSrc", "==", "MVT", "::", "i8", "?", "M680x0", "::", "MxSubRegIndex8Lo", ":", "M680x0", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "SubDst", "&&", "\"No viable SUB register available\"", ")", ";", "MIB", "->", "setDesc", "(", "Desc", ")", ";", "MIB", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "SubDst", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "memory", "and", "extend", "." ]

[ "M680x0", "M680x0", "\"Expand \"", "\" to LOAD and \"", "0", "MVT::i8", "M680x0::MxSubRegIndex8Lo", "M680x0::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "0", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "int", "proper_comparison_operator", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "enum", "rtx_code", "code", ";", "if", "(", "!", "COMPARISON_P", "(", "op", ")", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "CCZNmode", ")", "return", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "CCZNCmode", ")", "return", "(", "code", "==", "EQ", "||", "code", "==", "NE", "||", "code", "==", "LTU", "||", "code", "==", "GEU", "||", "code", "==", "GTU", "||", "code", "==", "LEU", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "comparison", "operator", "valid", "for", "the", "mode", "of", "CC", ".", "This", "allows", "the", "use", "of", "MATCH_OPERATOR", "to", "recognize", "all", "the", "branch", "insns", ".", "Some", "insns", "only", "set", "a", "few", "bits", "in", "the", "condition", "code", ".", "So", "only", "allow", "those", "comparisons", "that", "use", "the", "bits", "that", "are", "valid", "." ]

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

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasByValOrInAllocaAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "4", ">", "SplitRegs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "SplitRegs", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "ArgInfos", ",", "MF", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "SplitRegs", ".", "push_back", "(", "Reg", ")", ";", "}", ")", ";", "if", "(", "!", "SplitRegs", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", ",", "SplitRegs", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "4", "0" ]

[]

[ "<s>", "static", "void", "aarch64_add_offset_1", "(", "scalar_int_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "offset", ",", "rtx", "temp1", ",", "bool", "frame_related_p", ",", "bool", "emit_move_imm", ")", "{", "gcc_assert", "(", "emit_move_imm", "||", "temp1", "!=", "NULL_RTX", ")", ";", "gcc_assert", "(", "temp1", "==", "NULL_RTX", "||", "!", "reg_overlap_mentioned_p", "(", "temp1", ",", "src", ")", ")", ";", "HOST_WIDE_INT", "moffset", "=", "abs_hwi", "(", "offset", ")", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "moffset", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "src", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "}", "return", ";", "}", "if", "(", "aarch64_uimm12_shift", "(", "moffset", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "src", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "return", ";", "}", "if", "(", "moffset", "<", "0x1000000", "&&", "(", "(", "!", "temp1", "&&", "!", "can_create_pseudo_p", "(", ")", ")", "||", "!", "aarch64_move_imm", "(", "moffset", ",", "mode", ")", ")", ")", "{", "HOST_WIDE_INT", "low_off", "=", "moffset", "&", "0xfff", ";", "low_off", "=", "offset", "<", "0", "?", "-", "low_off", ":", "low_off", ";", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "src", ",", "GEN_INT", "(", "low_off", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "insn", "=", "emit_insn", "(", "gen_add2_insn", "(", "dest", ",", "GEN_INT", "(", "offset", "-", "low_off", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "return", ";", "}", "if", "(", "emit_move_imm", ")", "{", "gcc_assert", "(", "temp1", "!=", "NULL_RTX", "||", "can_create_pseudo_p", "(", ")", ")", ";", "temp1", "=", "aarch64_force_temporary", "(", "mode", ",", "temp1", ",", "GEN_INT", "(", "moffset", ")", ")", ";", "}", "insn", "=", "emit_insn", "(", "offset", "<", "0", "?", "gen_sub3_insn", "(", "dest", ",", "src", ",", "temp1", ")", ":", "gen_add3_insn", "(", "dest", ",", "src", ",", "temp1", ")", ")", ";", "if", "(", "frame_related_p", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "rtx", "adj", "=", "plus_constant", "(", "mode", ",", "src", ",", "offset", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "dest", ",", "adj", ")", ")", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "aarch64_add_offset", ".", "Set", "DEST", "to", "SRC", "+", "OFFSET", "for", "a", "non-polynomial", "OFFSET", ".", "MODE", "is", "the", "mode", "of", "the", "addition", ".", "FRAME_RELATED_P", "is", "true", "if", "the", "RTX_FRAME_RELATED", "flag", "should", "be", "set", "and", "CFA", "adjustments", "added", "to", "the", "generated", "instructions", ".", "TEMP1", ",", "if", "nonnull", ",", "is", "a", "register", "of", "mode", "MODE", "that", "can", "be", "used", "as", "a", "temporary", "if", "register", "allocation", "is", "already", "complete", ".", "This", "temporary", "register", "may", "overlap", "DEST", "but", "must", "not", "overlap", "SRC", ".", "If", "TEMP1", "is", "known", "to", "hold", "abs", "(", "OFFSET", ")", ",", "EMIT_MOVE_IMM", "can", "be", "set", "to", "false", "to", "avoid", "emitting", "the", "immediate", "again", ".", "Since", "this", "function", "may", "be", "used", "to", "adjust", "the", "stack", "pointer", ",", "we", "must", "ensure", "that", "it", "can", "not", "cause", "transient", "stack", "deallocation", "(", "for", "example", "by", "first", "incrementing", "SP", "and", "then", "decrementing", "when", "adjusting", "by", "a", "large", "immediate", ")", "." ]

[ "aarch64", "0x1000000", "0xfff", "0", "0" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "!", "isSafeToFold", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "unsigned", "OpSize", "=", "TII", "->", "getOpSize", "(", "MI", ",", "1", ")", ";", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "FoldingImm", "&&", "!", "TII", "->", "isInlineConstant", "(", "OpToFold", ",", "OpSize", ")", "&&", "!", "MRI", ".", "hasOneUse", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "(", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", "||", "OpToFold", ".", "getSubReg", "(", ")", ")", ")", "continue", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "CopiesToReplace", ";", "std", "::", "vector", "<", "FoldCandidate", ">", "FoldList", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "Use", "=", "MRI", ".", "use_begin", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ",", "E", "=", "MRI", ".", "use_end", "(", ")", ";", "Use", "!=", "E", ";", "++", "Use", ")", "{", "MachineInstr", "*", "UseMI", "=", "Use", "->", "getParent", "(", ")", ";", "foldOperand", "(", "OpToFold", ",", "UseMI", ",", "Use", ".", "getOperandNo", "(", ")", ",", "FoldList", ",", "CopiesToReplace", ",", "TII", ",", "TRI", ",", "MRI", ")", ";", "}", "for", "(", "MachineInstr", "*", "Copy", ":", "CopiesToReplace", ")", "Copy", "->", "addImplicitDefUseOperands", "(", "MF", ")", ";", "for", "(", "FoldCandidate", "&", "Fold", ":", "FoldList", ")", "{", "if", "(", "updateOperand", "(", "Fold", ",", "TRI", ")", ")", "{", "if", "(", "!", "Fold", ".", "isImm", "(", ")", ")", "{", "assert", "(", "Fold", ".", "OpToFold", "&&", "Fold", ".", "OpToFold", "->", "isReg", "(", ")", ")", ";", "Fold", ".", "OpToFold", "->", "setIsKill", "(", "false", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Folded source from \"", "<<", "MI", "<<", "\" into OpNo \"", "<<", "Fold", ".", "UseOpNo", "<<", "\" of \"", "<<", "*", "Fold", ".", "UseMI", "<<", "'\\n'", ")", ";", "}", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "1", "0", "4", "0", "\"Folded source from \"", "\" into OpNo \"", "\" of \"" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "HexagonMCInstrInfo", "::", "isVector", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "const", "uint64_t", "F", "=", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "MCI", ")", ".", "TSFlags", ";", "return", "(", "F", ">>", "HexagonII", "::", "isCVIPos", ")", "&", "HexagonII", "::", "isCVIMask", ";", "}", "</s>" ]

[ "Vector", "instructions", "are", "instructions", "that", "must", "fill", "all", "instruction", "slots", "within", "an", "instruction", "group", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "HexagonII::isCVIPos", "HexagonII::isCVIMask" ]

[]

[ "<s>", "static", "void", "rs6000_emit_prologue_components", "(", "sbitmap", "components", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "machine_mode", "reg_mode", "=", "Pmode", ";", "int", "reg_size", "=", "TARGET_32BIT", "?", "4", ":", "8", ";", "machine_mode", "fp_reg_mode", "=", "TARGET_HARD_FLOAT", "?", "DFmode", ":", "SFmode", ";", "int", "fp_reg_size", "=", "8", ";", "if", "(", "bitmap_bit_p", "(", "components", ",", "0", ")", ")", "{", "rtx", "lr", "=", "gen_rtx_REG", "(", "reg_mode", ",", "LR_REGNO", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "0", ")", ";", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "reg", ",", "lr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "gen_rtx_SET", "(", "reg", ",", "lr", ")", ")", ";", "int", "offset", "=", "info", "->", "lr_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "mem", "=", "copy_rtx", "(", "SET_DEST", "(", "single_set", "(", "insn", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "lr", ")", ")", ";", "}", "if", "(", "bitmap_bit_p", "(", "components", ",", "2", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "TOC_REGNUM", ")", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "sp_reg", ",", "RS6000_TOC_SAVE_SLOT", ")", ")", ";", "}", "int", "offset", "=", "info", "->", "gp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_gp_reg_save", ";", "i", "<", "32", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "reg_size", ";", "}", "offset", "=", "info", "->", "fp_save_offset", ";", "if", "(", "info", "->", "push_p", ")", "offset", "+=", "info", "->", "total_size", ";", "for", "(", "int", "i", "=", "info", "->", "first_fp_reg_save", ";", "i", "<", "64", ";", "i", "++", ")", "{", "if", "(", "bitmap_bit_p", "(", "components", ",", "i", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "fp_reg_mode", ",", "i", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "ptr_reg", ",", "offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "rtx", "set", "=", "copy_rtx", "(", "single_set", "(", "insn", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "}", "offset", "+=", "fp_reg_size", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS", "." ]

[ "rs6000", "4", "8", "8", "0", "0", "1", "1", "2", "32", "1", "64", "1" ]

[]

[ "<s>", "bool", "toc_hasher", "::", "equal", "(", "toc_hash_struct", "*", "h1", ",", "toc_hash_struct", "*", "h2", ")", "{", "rtx", "r1", "=", "h1", "->", "key", ";", "rtx", "r2", "=", "h2", "->", "key", ";", "if", "(", "h1", "->", "key_mode", "!=", "h2", "->", "key_mode", ")", "return", "0", ";", "return", "rtx_equal_p", "(", "r1", ",", "r2", ")", ";", "}", "</s>" ]

[ "Compare", "H1", "and", "H2", "for", "equivalence", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "ARCOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "AST", "=", "&", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ";", "AII", "=", "AST", "->", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Changed", "|=", "processBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "loadStackInputValue", "(", "SelectionDAG", "&", "DAG", ",", "EVT", "VT", ",", "const", "SDLoc", "&", "SL", ",", "int64_t", "Offset", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "getOrCreateFixedStackObject", "(", "MFI", ",", "VT", ".", "getStoreSize", "(", ")", ",", "Offset", ")", ";", "auto", "SrcPtrInfo", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "SDValue", "Ptr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "return", "DAG", ".", "getLoad", "(", "VT", ",", "SL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "Ptr", ",", "SrcPtrInfo", ",", "4", ",", "MachineMemOperand", "::", "MODereferenceable", "|", "MachineMemOperand", "::", "MOInvariant", ")", ";", "}", "</s>" ]

[ "Similar", "to", "CreateLiveInRegister", ",", "except", "value", "maybe", "loaded", "from", "a", "stack", "slot", "rather", "than", "passed", "in", "a", "register", "." ]

[ "AMDGPU", "AMDGPU", "MVT::i32", "4" ]

[]

[ "<s>", "void", "NVPTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Unexpected\"", "1", "1" ]

[]

[ "<s>", "void", "i386_pe_declare_function_type", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "int", "pub", ")", "{", "fprintf", "(", "file", ",", "\"\\t.def\\t\"", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\";\\t.scl\\t%d;\\t.type\\t%d;\\t.endef\\n\"", ",", "pub", "?", "(", "int", ")", "C_EXT", ":", "(", "int", ")", "C_STAT", ",", "(", "int", ")", "DT_FCN", "<<", "N_BTSHFT", ")", ";", "}", "</s>" ]

[ "Mark", "a", "function", "appropriately", ".", "This", "should", "only", "be", "called", "for", "functions", "for", "which", "we", "are", "not", "emitting", "COFF", "debugging", "information", ".", "FILE", "is", "the", "assembler", "output", "file", ",", "NAME", "is", "the", "name", "of", "the", "function", ",", "and", "PUBLIC", "is", "nonzero", "if", "the", "function", "is", "globally", "visible", "." ]

[ "i386", "\"\\t.def\\t\"", "\";\\t.scl\\t%d;\\t.type\\t%d;\\t.endef\\n\"" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+dx10-clamp,+load-store-opt,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-address-space,+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", ";", "if", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "FullFS", "+=", "\"+fp64-fp16-denormals,\"", ";", "}", "else", "{", "FullFS", "+=", "\"-fp32-denormals,\"", ";", "}", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "FullFS", ")", ";", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", ")", "{", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSize", "==", "0", ")", "WavefrontSize", "=", "64", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "256", "\"+promote-alloca,+dx10-clamp,+load-store-opt,\"", "\"+flat-address-space,+flat-for-global,+unaligned-buffer-access,+trap-handler,\"", "AMDGPU", "\"+fp64-fp16-denormals,\"", "\"-fp32-denormals,\"", "\"+enable-prt-strict-null,\"", "AMDGPU", "\"flat-for-global\"", "0", "4", "0", "32", "0", "32768", "0", "64", "AMDGPU" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "TMS320C64X" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "int", "DataWidth", "=", "ScalarTy", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "(", "DataWidth", ">=", "32", "&&", "ST", "->", "hasAVX2", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Patmos", "\"Patmos Single-Path Mark (machine code)\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ")", "{", "int", "regno", ";", "HOST_WIDE_INT", "total_size", ";", "HOST_WIDE_INT", "var_size", ";", "HOST_WIDE_INT", "args_size", ";", "int", "link_debug_size", ";", "HOST_WIDE_INT", "gp_reg_size", ";", "long", "mask", ";", "interrupt_handler", "=", "microblaze_interrupt_function_p", "(", "current_function_decl", ")", ";", "break_handler", "=", "microblaze_break_function_p", "(", "current_function_decl", ")", ";", "fast_interrupt", "=", "microblaze_fast_interrupt_function_p", "(", "current_function_decl", ")", ";", "save_volatiles", "=", "microblaze_save_volatiles", "(", "current_function_decl", ")", ";", "if", "(", "break_handler", ")", "interrupt_handler", "=", "break_handler", ";", "gp_reg_size", "=", "0", ";", "mask", "=", "0", ";", "var_size", "=", "size", ";", "args_size", "=", "crtl", "->", "outgoing_args_size", ";", "if", "(", "(", "args_size", "==", "0", ")", "&&", "cfun", "->", "calls_alloca", ")", "args_size", "=", "NUM_OF_ARGS", "*", "UNITS_PER_WORD", ";", "total_size", "=", "var_size", "+", "args_size", ";", "if", "(", "flag_pic", "==", "2", ")", "df_set_regs_ever_live", "(", "MB_ABI_PIC_ADDR_REGNUM", ",", "true", ")", ";", "for", "(", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "{", "if", "(", "microblaze_must_save_register", "(", "regno", ")", ")", "{", "if", "(", "regno", "!=", "MB_ABI_SUB_RETURN_ADDR_REGNUM", ")", "gp_reg_size", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "mask", "|=", "(", "1L", "<<", "(", "regno", "-", "GP_REG_FIRST", ")", ")", ";", "}", "}", "total_size", "+=", "gp_reg_size", ";", "if", "(", "microblaze_is_interrupt_variant", "(", ")", ")", "total_size", "+=", "4", ";", "if", "(", "total_size", "==", "0", "&&", "crtl", "->", "is_leaf", ")", "link_debug_size", "=", "0", ";", "else", "link_debug_size", "=", "UNITS_PER_WORD", ";", "total_size", "+=", "link_debug_size", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "gp_reg_size", "=", "gp_reg_size", ";", "current_frame_info", ".", "mask", "=", "mask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "current_frame_info", ".", "num_gp", "=", "gp_reg_size", "/", "UNITS_PER_WORD", ";", "current_frame_info", ".", "link_debug_size", "=", "link_debug_size", ";", "if", "(", "mask", ")", "current_frame_info", ".", "gp_offset", "=", "(", "total_size", "-", "gp_reg_size", ")", ";", "else", "current_frame_info", ".", "gp_offset", "=", "0", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "microblaze", "0", "0", "0", "2", "1L", "4", "0", "0", "0" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "return", ";", "unsigned", "Flags", "=", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", "|", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_PAC", ";", "if", "(", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "\"branch-target-enforcement\"", ")", ";", "}", ")", ")", "{", "Flags", "&=", "~", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ";", "}", "if", "(", "(", "Flags", "&", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_BTI", ")", "==", "0", "&&", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "F", ".", "hasFnAttribute", "(", "\"branch-target-enforcement\"", ")", ";", "}", ")", ")", "{", "errs", "(", ")", "<<", "\"warning: some functions compiled with BTI and some compiled \"", "\"without BTI\\n\"", "<<", "\"warning: not setting BTI in feature flags\\n\"", ";", "}", "if", "(", "any_of", "(", "M", ",", "[", "]", "(", "const", "Function", "&", "F", ")", "{", "if", "(", "F", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "Attribute", "A", "=", "F", ".", "getFnAttribute", "(", "\"sign-return-address\"", ")", ";", "return", "!", "A", ".", "isStringAttribute", "(", ")", "||", "A", ".", "getValueAsString", "(", ")", "==", "\"none\"", ";", "}", ")", ")", "{", "Flags", "&=", "~", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_PAC", ";", "}", "if", "(", "Flags", "==", "0", ")", "return", ";", "MCSection", "*", "Cur", "=", "OutStreamer", "->", "getCurrentSectionOnly", "(", ")", ";", "MCSection", "*", "Nt", "=", "MMI", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".note.gnu.property\"", ",", "ELF", "::", "SHT_NOTE", ",", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Nt", ")", ";", "emitAlignment", "(", "Align", "(", "8", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", "*", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "NT_GNU_PROPERTY_TYPE_0", ",", "4", ")", ";", "OutStreamer", "->", "emitBytes", "(", "StringRef", "(", "\"GNU\"", ",", "4", ")", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "ELF", "::", "GNU_PROPERTY_AARCH64_FEATURE_1_AND", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "4", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "Flags", ",", "4", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "0", ",", "4", ")", ";", "OutStreamer", "->", "endSection", "(", "Nt", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Cur", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AArch64", "AArch64", "\"branch-target-enforcement\"", "0", "\"branch-target-enforcement\"", "\"warning: some functions compiled with BTI and some compiled \"", "\"without BTI\\n\"", "\"warning: not setting BTI in feature flags\\n\"", "\"sign-return-address\"", "\"none\"", "0", "\".note.gnu.property\"", "8", "4", "4", "4", "4", "4", "4", "\"GNU\"", "4", "4", "4", "4", "4", "0", "4" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "HexagonMCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "const", "char", "startPacket", "=", "'{'", ",", "endPacket", "=", "'}'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "assert", "(", "MI", "->", "isPacketEnd", "(", ")", "&&", "\"Loop-end must also end the packet\"", ")", ";", "if", "(", "MI", "->", "isPacketBegin", "(", ")", ")", "{", "HexagonMCInst", "Nop", "(", "Hexagon", "::", "NOP", ")", ";", "StringRef", "NoAnnot", ";", "Nop", ".", "setPacketBegin", "(", "MI", "->", "isPacketBegin", "(", ")", ")", ";", "printInst", "(", "&", "Nop", ",", "O", ",", "NoAnnot", ")", ";", "}", "if", "(", "MI", "->", "isPacketEnd", "(", ")", ")", "O", "<<", "PacketPadding", "<<", "endPacket", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "else", "{", "if", "(", "MI", "->", "isPacketBegin", "(", ")", ")", "O", "<<", "PacketPadding", "<<", "startPacket", "<<", "'\\n'", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "if", "(", "MI", "->", "isPacketEnd", "(", ")", ")", "O", "<<", "'\\n'", "<<", "PacketPadding", "<<", "endPacket", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ENDLOOP0", "\"Loop-end must also end the packet\"", "Hexagon", "Hexagon::NOP" ]

[]

[ "<s>", "void", "LM32TargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "Size", ",", "unsigned", "Align", ")", "const", "{", "static", "const", "uint16_t", "ArgRegList", "[", "]", "=", "{", "LM32", "::", "R1", ",", "LM32", "::", "R2", ",", "LM32", "::", "R3", ",", "LM32", "::", "R4", ",", "LM32", "::", "R5", ",", "LM32", "::", "R6", ",", "LM32", "::", "R7", ",", "LM32", "::", "R8", "}", ";", "unsigned", "NumWords", "=", "(", "Size", "+", "3", ")", "/", "4", ";", "unsigned", "NewSize", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumWords", ";", "++", "i", ")", "{", "if", "(", "!", "State", "->", "AllocateReg", "(", "ArgRegList", ",", "8", ")", ")", "{", "NewSize", "=", "NumWords", "*", "4", ";", "break", ";", "}", "}", "Size", "=", "NewSize", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "LM32", "LM32", "LM32::R1", "LM32::R2", "LM32::R3", "LM32::R4", "LM32::R5", "LM32::R6", "LM32::R7", "LM32::R8", "3", "4", "0", "0", "8", "4" ]

[]

[ "<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", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Encoding bundle\\n\"", ";", ")", ";", "*", "Addend", "=", "0", ";", "*", "Extended", "=", "false", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "*", "CurrentIndex", "=", "0", ";", "size_t", "Last", "=", "HexagonMCInstrInfo", "::", "bundleSize", "(", "HMB", ")", "-", "1", ";", "for", "(", "auto", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "HMB", ")", ")", "{", "MCInst", "&", "HMI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "*", "I", ".", "getInst", "(", ")", ")", ";", "verifyInstructionPredicates", "(", "HMI", ",", "computeAvailableFeatures", "(", "STI", ".", "getFeatureBits", "(", ")", ")", ")", ";", "EncodeSingleInstruction", "(", "HMI", ",", "OS", ",", "Fixups", ",", "STI", ",", "parseBits", "(", "Last", ",", "HMB", ",", "HMI", ")", ")", ";", "*", "Extended", "=", "HexagonMCInstrInfo", "::", "isImmext", "(", "HMI", ")", ";", "*", "Addend", "+=", "HEXAGON_INSTR_SIZE", ";", "++", "*", "CurrentIndex", ";", "}", "return", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "insn_is_swap_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "SET", ")", "return", "0", ";", "rtx", "rhs", "=", "SET_SRC", "(", "body", ")", ";", "if", "(", "GET_CODE", "(", "rhs", ")", "!=", "VEC_SELECT", ")", "return", "0", ";", "rtx", "parallel", "=", "XEXP", "(", "rhs", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "parallel", ")", "!=", "PARALLEL", ")", "return", "0", ";", "unsigned", "int", "len", "=", "XVECLEN", "(", "parallel", ",", "0", ")", ";", "if", "(", "len", "!=", "2", "&&", "len", "!=", "4", "&&", "len", "!=", "8", "&&", "len", "!=", "16", ")", "return", "0", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "len", "/", "2", ";", "++", "i", ")", "{", "rtx", "op", "=", "XVECEXP", "(", "parallel", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op", ")", "!=", "len", "/", "2", "+", "i", ")", "return", "0", ";", "}", "for", "(", "unsigned", "int", "i", "=", "len", "/", "2", ";", "i", "<", "len", ";", "++", "i", ")", "{", "rtx", "op", "=", "XVECEXP", "(", "parallel", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op", ")", "!=", "i", "-", "len", "/", "2", ")", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "swaps", "doublewords", ".", "This", "may", "be", "a", "reg-reg", "swap", ",", "a", "permuting", "load", ",", "or", "a", "permuting", "store", "." ]

[ "rs6000", "0", "0", "1", "0", "0", "2", "4", "8", "16", "0", "0", "2", "0", "2", "0", "2", "0", "2", "0", "1" ]

[]

[ "<s>", "bool", "R600ClauseMergePass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "R600Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "BB_E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "BB_E", ";", "++", "BB", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BB", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "LatestCFAlu", "=", "E", ";", "while", "(", "I", "!=", "E", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", "++", ";", "if", "(", "(", "!", "TII", "->", "canBeConsideredALU", "(", "MI", ")", "&&", "!", "isCFAlu", "(", "MI", ")", ")", "||", "TII", "->", "mustBeLastInClause", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "LatestCFAlu", "=", "E", ";", "if", "(", "!", "isCFAlu", "(", "MI", ")", ")", "continue", ";", "cleanPotentialDisabledCFAlu", "(", "MI", ")", ";", "if", "(", "LatestCFAlu", "!=", "E", "&&", "mergeIfPossible", "(", "*", "LatestCFAlu", ",", "MI", ")", ")", "{", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "{", "assert", "(", "MI", ".", "getOperand", "(", "8", ")", ".", "getImm", "(", ")", "&&", "\"CF ALU instruction disabled\"", ")", ";", "LatestCFAlu", "=", "MI", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "8", "\"CF ALU instruction disabled\"" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "&", "TRI", "=", "TII", "->", "getRegisterInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "AllSGPRSpilledToVGPRs", "=", "false", ";", "if", "(", "TRI", ".", "spillSGPRToVGPR", "(", ")", "&&", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", "{", "AllSGPRSpilledToVGPRs", "=", "true", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "{", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "bool", "Spilled", "=", "TRI", ".", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "RS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "}", "else", "AllSGPRSpilledToVGPRs", "=", "false", ";", "}", "}", "}", "FuncInfo", "->", "removeSGPRToVGPRFrameIndices", "(", "MFI", ")", ";", "}", "if", "(", "FuncInfo", "->", "hasNonSpillStackObjects", "(", ")", "||", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "||", "!", "AllSGPRSpilledToVGPRs", "||", "!", "allStackObjectsAreDead", "(", "MFI", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "int", "ScavengeFI", "=", "MFI", ".", "CreateFixedObject", "(", "TRI", ".", "getSpillSize", "(", "AMDGPU", "::", "SGPR_32RegClass", ")", ",", "0", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::OpName", "\"failed to spill SGPR to VGPR when allocated\"", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "emit_nop_after", "(", "int", "cycles", ",", "rtx_insn", "*", "after", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "cycles", "==", "10", ")", "cycles", "--", ";", "gcc_assert", "(", "cycles", "<", "10", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_nop_count", "(", "GEN_INT", "(", "cycles", ")", ")", ",", "after", ")", ";", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Emit", "a", "NOP", "instruction", "for", "CYCLES", "cycles", "after", "insn", "AFTER", ".", "Return", "it", "." ]

[ "c6x", "10", "10" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::AND", "ISD::OR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "CAHP" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "&", "FirstLdSt", ",", "MachineInstr", "&", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "return", "(", "NumLoads", "*", "DstRC", "->", "getSize", "(", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16" ]

[]

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "ARM" ]

[]

[ "<s>", "SDValue", "ARCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "ARC", "ARC", "ISD::GlobalAddress", "ISD::FRAMEADDR", "ISD::SELECT_CC", "ISD::BR_CC", "ISD::SIGN_EXTEND_INREG", "ISD::JumpTable", "ISD::VASTART", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "static_cast", "<", "const", "AArch64FrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ",", "true", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "=", "TFI", "->", "resolveFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "if", "(", "rewriteAArch64FrameIndex", "(", "MI", ",", "FIOperandNum", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ")", "return", ";", "assert", "(", "(", "!", "RS", "||", "!", "RS", "->", "isScavengingFrameIndex", "(", "FrameIndex", ")", ")", "&&", "\"Emergency spill slot is out of reach\"", ")", ";", "unsigned", "ScratchReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "AArch64", "::", "GPR64RegClass", ")", ";", "emitFrameOffset", "(", "MBB", ",", "II", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "ScratchReg", ",", "FrameReg", ",", "Offset", ",", "TII", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "ScratchReg", ",", "false", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"Unexpected\"", "AArch64", "AArch64", "AArch64", "AArch64", "1", "1", "AArch64", "\"Emergency spill slot is out of reach\"", "AArch64::GPR64RegClass" ]

[]