Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "AArch64" ]

[]

[ "<s>", "bool", "nds32_can_use_bclr_p", "(", "HOST_WIDE_INT", "ival", ")", "{", "int", "one_bit_count", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "SImode", ")", ";", "one_bit_count", "=", "popcount_hwi", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "~", "ival", ")", "&", "mask", ")", ";", "return", "(", "TARGET_EXT_PERF", "&&", "(", "one_bit_count", "==", "1", ")", ")", ";", "}", "</s>" ]

[ "Function", "to", "check", "if", "'bclr", "'", "instruction", "can", "be", "used", "with", "IVAL", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "break", ";", "if", "(", "!", "getBranchInfo", "(", "*", "I", ")", ".", "hasMBBTarget", "(", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "SystemZ", "SystemZ", "\"code size not handled\"", "0" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Node", "->", "getMachineOpcode", "(", ")", ")", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "if", "(", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "R600", "SI", "SI", "SI" ]

[]

[ "<s>", "static", "void", "h8300_push_pop", "(", "int", "regno", ",", "int", "nregs", ",", "bool", "pop_p", ",", "bool", "return_p", ")", "{", "int", "i", ",", "j", ";", "rtvec", "vec", ";", "rtx", "sp", ",", "offset", ",", "x", ";", "if", "(", "!", "return_p", "&&", "nregs", "==", "1", ")", "{", "if", "(", "pop_p", ")", "pop", "(", "regno", ")", ";", "else", "push", "(", "regno", ",", "false", ")", ";", "return", ";", "}", "vec", "=", "rtvec_alloc", "(", "(", "return_p", "?", "1", ":", "0", ")", "+", "nregs", "+", "1", ")", ";", "sp", "=", "stack_pointer_rtx", ";", "i", "=", "0", ";", "if", "(", "return_p", ")", "{", "RTVEC_ELT", "(", "vec", ",", "i", ")", "=", "ret_rtx", ";", "i", "++", ";", "}", "for", "(", "j", "=", "0", ";", "j", "<", "nregs", ";", "j", "++", ")", "{", "rtx", "lhs", ",", "rhs", ";", "if", "(", "pop_p", ")", "{", "lhs", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "j", ")", ";", "rhs", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "sp", ",", "(", "nregs", "-", "j", "-", "1", ")", "*", "4", ")", ")", ";", "}", "else", "{", "lhs", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "sp", ",", "(", "j", "+", "1", ")", "*", "-", "4", ")", ")", ";", "rhs", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", "+", "j", ")", ";", "}", "RTVEC_ELT", "(", "vec", ",", "i", "+", "j", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "lhs", ",", "rhs", ")", ";", "}", "offset", "=", "GEN_INT", "(", "(", "pop_p", "?", "nregs", ":", "-", "nregs", ")", "*", "4", ")", ";", "RTVEC_ELT", "(", "vec", ",", "i", "+", "j", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "sp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sp", ",", "offset", ")", ")", ";", "x", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "if", "(", "!", "pop_p", ")", "x", "=", "Fpa", "(", "x", ")", ";", "if", "(", "return_p", ")", "emit_jump_insn", "(", "x", ")", ";", "else", "emit_insn", "(", "x", ")", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "to", "push", "or", "pop", "NREGS", "consecutive", "registers", "starting", "at", "register", "REGNO", ".", "POP_P", "selects", "a", "pop", "rather", "than", "a", "push", "and", "RETURN_P", "is", "true", "if", "the", "instruction", "should", "return", ".", "It", "must", "be", "possible", "to", "do", "the", "requested", "operation", "in", "a", "single", "instruction", ".", "If", "NREGS", "==", "1", "&", "&", "!", "RETURN_P", ",", "use", "a", "normal", "push", "or", "pop", "insn", ".", "Otherwise", "emit", "a", "parallel", "of", "the", "form", ":", "(", "parallel", "[", "(", "return", ")", ";", ";", "if", "RETURN_P", "(", "save", "or", "restore", "REGNO", ")", "(", "save", "or", "restore", "REGNO", "+", "1", ")", "...", "(", "save", "or", "restore", "REGNO", "+", "NREGS", "-", "1", ")", "(", "set", "sp", "(", "plus", "sp", "(", "const_int", "adjust", ")", ")", ")", "]" ]

[ "h8300", "1", "1", "0", "1", "0", "0", "1", "4", "1", "4", "4" ]

[]

[ "<s>", "static", "bool", "nios2_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'.'", "||", "code", "==", "'!'", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_PUNCT_VALID_P", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "bool", "ix86_cannot_force_const_mem", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "case", "CONST_WIDE_INT", ":", "case", "CONST_DOUBLE", ":", "case", "CONST_VECTOR", ":", "return", "false", ";", "default", ":", "break", ";", "}", "return", "!", "ix86_legitimate_constant_p", "(", "mode", ",", "x", ")", ";", "}", "</s>" ]

[ "Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", ".", "This", "is", "not", "possible", "for", "the", "address", "of", "thread-local", "symbols", ",", "which", "is", "checked", "above", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "rl78_compute_frame_info", "(", "void", ")", "{", "int", "i", ";", "cfun", "->", "machine", "->", "computed", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "=", "0", ";", "cfun", "->", "machine", "->", "framesize_locals", "=", "get_frame_size", "(", ")", ";", "cfun", "->", "machine", "->", "framesize_outgoing", "=", "crtl", "->", "outgoing_args_size", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "need_to_save", "(", "i", "*", "2", ")", "||", "need_to_save", "(", "i", "*", "2", "+", "1", ")", ")", "{", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "+=", "2", ";", "}", "else", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", "=", "0", ";", "if", "(", "(", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "&", "1", ")", "cfun", "->", "machine", "->", "framesize_locals", "++", ";", "cfun", "->", "machine", "->", "framesize", "=", "(", "cfun", "->", "machine", "->", "framesize_regs", "+", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", ";", "}", "</s>" ]

[ "Compute", "all", "the", "frame-related", "fields", "in", "our", "machine_function", "structure", "." ]

[ "rl78", "1", "0", "0", "16", "2", "2", "1", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "if", "(", "Inst", ".", "getNumOperands", "(", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "isConditionalBranch", "(", "Inst", ")", "&&", "!", "isUnconditionalBranch", "(", "Inst", ")", "&&", "!", "isCall", "(", "Inst", ")", ")", "return", "false", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_PCREL", ")", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Size", "+", "Imm", ";", "return", "true", ";", "}", "else", "{", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Imm", "==", "0", ")", "return", "false", ";", "Target", "=", "Imm", ";", "return", "true", ";", "}", "}", "</s>" ]

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

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

[]

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

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

[ "Mips" ]

[]

[ "<s>", "void", "rs6000_emit_popcount", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "rtx", "tmp1", ",", "tmp2", ";", "if", "(", "TARGET_POPCNTD", ")", "{", "if", "(", "mode", "==", "SImode", ")", "emit_insn", "(", "gen_popcntdsi2", "(", "dst", ",", "src", ")", ")", ";", "else", "emit_insn", "(", "gen_popcntddi2", "(", "dst", ",", "src", ")", ")", ";", "return", ";", "}", "tmp1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_popcntbsi2", "(", "tmp1", ",", "src", ")", ")", ";", "tmp2", "=", "expand_mult", "(", "SImode", ",", "tmp1", ",", "GEN_INT", "(", "0x01010101", ")", ",", "NULL_RTX", ",", "0", ")", ";", "tmp2", "=", "force_reg", "(", "SImode", ",", "tmp2", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "dst", ",", "tmp2", ",", "GEN_INT", "(", "24", ")", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_popcntbdi2", "(", "tmp1", ",", "src", ")", ")", ";", "tmp2", "=", "expand_mult", "(", "DImode", ",", "tmp1", ",", "GEN_INT", "(", "(", "HOST_WIDE_INT", ")", "0x01010101", "<<", "32", "|", "0x01010101", ")", ",", "NULL_RTX", ",", "0", ")", ";", "tmp2", "=", "force_reg", "(", "DImode", ",", "tmp2", ")", ";", "emit_insn", "(", "gen_lshrdi3", "(", "dst", ",", "tmp2", ",", "GEN_INT", "(", "56", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "popcount", "intrinsic", "on", "TARGET_POPCNTB", "(", "Power5", ")", "and", "TARGET_POPCNTD", "(", "Power7", ")", "targets", ".", "DST", "is", "the", "target", ",", "and", "SRC", "is", "the", "argument", "operand", "." ]

[ "powerpcspe", "0x01010101", "0", "24", "0x01010101", "32", "0x01010101", "0", "56" ]

[]

[ "<s>", "bool", "s390_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_VX", "&&", "VECTOR_NOFP_REGNO_P", "(", "regno", ")", ")", "return", "false", ";", "switch", "(", "REGNO_REG_CLASS", "(", "regno", ")", ")", "{", "case", "VEC_REGS", ":", "return", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "VEC_REGS", ",", "mode", ")", "==", "1", ")", "||", "mode", "==", "DFmode", "||", "(", "TARGET_VXE", "&&", "mode", "==", "SFmode", ")", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ";", "break", ";", "case", "FP_REGS", ":", "if", "(", "TARGET_VX", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "s390_class_max_nregs", "(", "FP_REGS", ",", "mode", ")", "==", "1", ")", "||", "mode", "==", "DFmode", "||", "s390_vector_mode_supported_p", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_FLOAT", ")", "return", "true", ";", "}", "break", ";", "case", "ADDR_REGS", ":", "if", "(", "FRAME_REGNO_P", "(", "regno", ")", "&&", "mode", "==", "Pmode", ")", "return", "true", ";", "case", "GENERAL_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "TARGET_ZARCH", "||", "(", "mode", "!=", "TFmode", "&&", "mode", "!=", "TCmode", "&&", "mode", "!=", "TDmode", ")", ")", "return", "true", ";", "}", "break", ";", "case", "CC_REGS", ":", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "true", ";", "break", ";", "case", "ACCESS_REGS", ":", "if", "(", "REGNO_PAIR_OK", "(", "regno", ",", "mode", ")", ")", "{", "if", "(", "mode", "==", "SImode", "||", "mode", "==", "Pmode", ")", "return", "true", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "legal", "to", "put", "a", "value", "with", "MODE", "into", "REGNO", "." ]

[ "s390", "1", "1" ]

[]

[ "<s>", "bool", "AlphaTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createAlphaBranchSelectionPass", "(", ")", ")", ";", "PM", ".", "add", "(", "createAlphaLLRPPass", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha", "Alpha" ]

[]

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

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

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

[]

[ "<s>", "static", "inline", "CSKYTargetStreamer", "::", "SymbolIndex", "getTombstoneKey", "(", ")", "{", "return", "{", "nullptr", ",", "CSKYMCExpr", "::", "VK_CSKY_Invalid", "}", ";", "}", "</s>" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

[ "CSKY", "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix SGPR live ranges\"", ";", "}", "</s>" ]

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

[ "R600", "\"SI Fix SGPR live ranges\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNodeBidrectional", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "SUnit", "*", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picked only Bottom\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "SU", ";", "}", "if", "(", "SUnit", "*", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Picked only Top\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "SU", ";", "}", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "BotResult", "==", "SingleExcess", "||", "BotResult", "==", "SingleCritical", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom Node\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "if", "(", "TopResult", "==", "SingleExcess", "||", "TopResult", "==", "SingleCritical", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "BotResult", "==", "SingleMax", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom Node SingleMax\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "if", "(", "TopResult", "==", "SingleMax", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node SingleMax\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "if", "(", "TopCand", ".", "SCost", ">", "BotCand", ".", "SCost", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Top Node Cost\\n\"", ")", ";", "IsTopNode", "=", "true", ";", "return", "TopCand", ".", "SU", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Prefered Bottom in Node order\\n\"", ")", ";", "IsTopNode", "=", "false", ";", "return", "BotCand", ".", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "best", "candidate", "node", "from", "either", "the", "top", "or", "bottom", "queue", "." ]

[ "Hexagon", "\"Picked only Bottom\\n\"", "\"Picked only Top\\n\"", "\"failed to find the first candidate\"", "\"Prefered Bottom Node\\n\"", "\"failed to find the first candidate\"", "\"Prefered Top Node\\n\"", "\"Prefered Bottom Node SingleMax\\n\"", "\"Prefered Top Node SingleMax\\n\"", "\"Prefered Top Node Cost\\n\"", "\"Prefered Bottom in Node order\\n\"" ]

[]

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

[ "If", "we", "are", "using", "indirect", "thunks", ",", "we", "need", "to", "expand", "indirectbr", "to", "avoid", "it", "lowering", "to", "an", "actual", "indirect", "jump", "." ]

[ "X86" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "const", "TargetRegisterClass", "*", "UseRC", "=", "(", "RC", "==", "&", "PPC", "::", "GPRCRegClass", "?", "&", "PPC", "::", "GPRC_and_GPRC_NOR0RegClass", ":", "(", "RC", "==", "&", "PPC", "::", "G8RCRegClass", "?", "&", "PPC", "::", "G8RC_and_G8RC_NOX0RegClass", ":", "RC", ")", ")", ";", "return", "FastISel", "::", "fastEmitInst_rr", "(", "MachineInstOpcode", ",", "UseRC", ",", "Op0", ",", "Op1", ")", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "two", "register", "operands", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

[ "PowerPC", "PPC", "PPC::GPRCRegClass", "PPC::GPRC_and_GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_and_G8RC_NOX0RegClass" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isAssociativeAndCommutative", "(", "const", "MachineInstr", "&", "Inst", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FADDDrr", ":", "case", "AArch64", "::", "FADDSrr", ":", "case", "AArch64", "::", "FADDv2f32", ":", "case", "AArch64", "::", "FADDv2f64", ":", "case", "AArch64", "::", "FADDv4f32", ":", "case", "AArch64", "::", "FMULDrr", ":", "case", "AArch64", "::", "FMULSrr", ":", "case", "AArch64", "::", "FMULX32", ":", "case", "AArch64", "::", "FMULX64", ":", "case", "AArch64", "::", "FMULXv2f32", ":", "case", "AArch64", "::", "FMULXv2f64", ":", "case", "AArch64", "::", "FMULXv4f32", ":", "case", "AArch64", "::", "FMULv2f32", ":", "case", "AArch64", "::", "FMULv2f64", ":", "case", "AArch64", "::", "FMULv4f32", ":", "return", "Inst", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "is", "both", "associative", "and", "commutative", "." ]

[ "AArch64", "AArch64", "AArch64::FADDDrr", "AArch64::FADDSrr", "AArch64::FADDv2f32", "AArch64::FADDv2f64", "AArch64::FADDv4f32", "AArch64::FMULDrr", "AArch64::FMULSrr", "AArch64::FMULX32", "AArch64::FMULX64", "AArch64::FMULXv2f32", "AArch64::FMULXv2f64", "AArch64::FMULXv4f32", "AArch64::FMULv2f32", "AArch64::FMULv2f64", "AArch64::FMULv4f32" ]

[]

[ "<s>", "bool", "isTarget64BitILP32", "(", ")", "const", "{", "if", "(", "NaClDontBreakABI", ")", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", ")", ";", "}", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", "||", "TargetTriple", ".", "isOSNaCl", "(", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "ILP32", "programming", "model", "(", "x32", "ABI", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "aarch64_expand_sve_const_pred", "(", "rtx", "target", ",", "rtx_vector_builder", "&", "builder", ")", "{", "if", "(", "rtx", "res", "=", "aarch64_expand_sve_const_pred_1", "(", "target", ",", "builder", ",", "true", ")", ")", "return", "res", ";", "if", "(", "builder", ".", "full_nelts", "(", ")", ".", "is_constant", "(", ")", ")", "if", "(", "rtx", "mem", "=", "force_const_mem", "(", "VNx16BImode", ",", "builder", ".", "build", "(", ")", ")", ")", "{", "target", "=", "aarch64_target_reg", "(", "target", ",", "VNx16BImode", ")", ";", "emit_move_insn", "(", "target", ",", "mem", ")", ";", "return", "target", ";", "}", "rtx_vector_builder", "int_builder", "(", "VNx16QImode", ",", "builder", ".", "npatterns", "(", ")", ",", "builder", ".", "nelts_per_pattern", "(", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "builder", ".", "encoded_nelts", "(", ")", ";", "++", "i", ")", "int_builder", ".", "quick_push", "(", "INTVAL", "(", "builder", ".", "elt", "(", "i", ")", ")", "?", "constm1_rtx", ":", "const0_rtx", ")", ";", "return", "aarch64_convert_sve_data_to_pred", "(", "target", ",", "VNx16BImode", ",", "int_builder", ".", "build", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "SVE", "predicate", "register", "that", "contains", "the", "VNx16BImode", "constant", "in", "BUILDER", ",", "without", "going", "through", "the", "move", "expanders", ".", "The", "returned", "register", "can", "have", "whatever", "mode", "seems", "most", "natural", "given", "the", "contents", "of", "BUILDER", ".", "Use", "TARGET", "for", "the", "result", "if", "convenient", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "SystemZInstPrinter", "::", "printAddress", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getReg", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "getImm", "(", ")", ",", "MI", "->", "getOperand", "(", "OpNo", "+", "2", ")", ".", "getReg", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "1", "2" ]

[]

[ "<s>", "static", "bool", "mips_in_small_data_p", "(", "tree", "decl", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "TARGET_ABICALLS", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "0", ")", "{", "const", "char", "*", "name", ";", "name", "=", "TREE_STRING_POINTER", "(", "DECL_SECTION_NAME", "(", "decl", ")", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\".sdata\"", ")", "!=", "0", "&&", "strcmp", "(", "name", ",", "\".sbss\"", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "else", "if", "(", "TARGET_EMBEDDED_DATA", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")", ")", ")", "return", "false", ";", "}", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "return", "(", "size", ">", "0", "&&", "size", "<=", "mips_section_threshold", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_IN_SMALL_DATA_P", ".", "Return", "true", "if", "it", "would", "be", "safe", "to", "access", "DECL", "using", "%", "gp_rel", "(", "...", ")", "(", "$", "gp", ")", "." ]

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

[]

[ "<s>", "unsigned", "SystemZTTIImpl", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "{", "if", "(", "!", "Vector", ")", "return", "14", ";", "if", "(", "ST", "->", "hasVector", "(", ")", ")", "return", "32", ";", "return", "0", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "SystemZ", "SystemZ", "14", "32", "0" ]

[]

[ "<s>", "bool", "HexagonBranchRelaxation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"****** Hexagon Branch Relaxation ******\\n\"", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "Changed", "=", "relaxBranches", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SNESFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "SNES", "SNES" ]

[]

[ "<s>", "static", "int", "vfp_emit_fstmd", "(", "int", "base_reg", ",", "int", "count", ")", "{", "rtx", "par", ";", "rtx", "dwarf", ";", "rtx", "tmp", ",", "reg", ";", "int", "i", ";", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "{", "if", "(", "base_reg", "==", "LAST_VFP_REGNUM", "-", "3", ")", "base_reg", "-=", "2", ";", "count", "++", ";", "}", "if", "(", "count", ">", "16", ")", "{", "int", "saved", ";", "saved", "=", "vfp_emit_fstmd", "(", "base_reg", "+", "32", ",", "count", "-", "16", ")", ";", "saved", "+=", "vfp_emit_fstmd", "(", "base_reg", ",", "16", ")", ";", "return", "saved", ";", "}", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "1", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "8", ")", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "8", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "DFmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", "=", "tmp", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", ";", "i", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "gen_frame_mem", "(", "DFmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "8", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "i", "+", "1", ")", "=", "tmp", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "add_reg_note", "(", "par", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "return", "count", "*", "8", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "save", "block", "of", "VFP", "register", "pairs", "to", "the", "stack", ".", "Returns", "the", "number", "of", "bytes", "pushed", "." ]

[ "arm", "2", "3", "2", "16", "32", "16", "16", "1", "2", "0", "0", "8", "1", "8", "1", "0", "0", "1", "0", "1", "1", "2", "0", "8", "1", "0", "1", "1", "8" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "Changed", "|=", "SimplifyInstructionsInBlock", "(", "&", "BB", ")", ";", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getType", "(", ")", ")", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "Changed", "|=", "optimiseAddress", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "Changed", "|=", "optimiseAddress", "(", "II", "->", "getArgOperand", "(", "1", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Gathers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Gathers", "[", "i", "]", ";", "Value", "*", "L", "=", "lowerGather", "(", "I", ")", ";", "if", "(", "L", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "L", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Scatters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Scatters", "[", "i", "]", ";", "Value", "*", "S", "=", "lowerScatter", "(", "I", ")", ";", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "S", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "Intrinsic::masked_gather", "0", "Intrinsic::masked_scatter", "0", "1", "0", "0" ]

[]

[ "<s>", "VESubtarget", "&", "VESubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "EnableVPU", "=", "false", ";", "std", "::", "string", "CPUName", "=", "std", "::", "string", "(", "CPU", ")", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "VE", "VE", "VE", "\"generic\"" ]

[]

[ "<s>", "bool", "ARCPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createARCISelDag", "(", "getARCTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "machine_mode", "rx_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "funtype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", ")", "{", "if", "(", "for_return", "!=", "1", "||", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "||", "COMPLEX_MODE_P", "(", "mode", ")", "||", "VECTOR_MODE_P", "(", "mode", ")", "||", "VECTOR_TYPE_P", "(", "type", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", "<", "1", ")", "return", "mode", ";", "return", "SImode", ";", "}", "</s>" ]

[ "TARGET_PROMOTE_FUNCTION_MODE", "must", "behave", "in", "the", "same", "way", "with", "regard", "to", "function", "returns", "as", "does", "TARGET_FUNCTION_VALUE", "." ]

[ "rx", "1", "4", "1" ]

[]

[ "<s>", "static", "void", "ix86_emit_move_max", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "ix86_emit_cmove", "(", "dst", ",", "src", ",", "LTU", ",", "dst", ",", "src", ")", ";", "}", "</s>" ]

[ "Choose", "max", "of", "DST", "and", "SRC", "and", "put", "it", "to", "DST", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "RISCVInstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "if", "(", "Opt", "==", "\"no-aliases\"", ")", "{", "NoAliases", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"numeric\"", ")", "{", "ArchRegNames", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "." ]

[ "RISCV", "RISCV", "\"no-aliases\"", "\"numeric\"" ]

[]

[ "<s>", "static", "bool", "alpha_vector_mode_supported_p", "(", "enum", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V8QImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V2SImode", ";", "}", "</s>" ]

[ "Alpha", "implements", "a", "couple", "of", "integer", "vector", "mode", "operations", "when", "TARGET_MAX", "is", "enabled", ".", "We", "do", "not", "check", "TARGET_MAX", "here", ",", "however", ",", "which", "allows", "the", "vectorizer", "to", "operate", "on", "e.g", ".", "move", "instructions", ",", "or", "when", "expand_vector_operations", "can", "do", "something", "useful", "." ]

[ "alpha" ]

[]

[ "<s>", "static", "bool", "c6x_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "size", "=", "-", "1", ";", "if", "(", "arg", ".", "type", ")", "size", "=", "int_size_in_bytes", "(", "arg", ".", "type", ")", ";", "else", "if", "(", "arg", ".", "mode", "!=", "VOIDmode", ")", "size", "=", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", "||", "size", "==", "-", "1", ";", "}", "</s>" ]

[ "Types", "larger", "than", "64", "bit", ",", "and", "variable", "sized", "types", ",", "are", "passed", "by", "reference", ".", "The", "callee", "must", "copy", "them", ";", "see", "c6x_callee_copies", "." ]

[ "c6x", "1", "2", "1" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "IF", ")", "NODE_NAME_CASE", "(", "ELSE", ")", "NODE_NAME_CASE", "(", "LOOP", ")", "NODE_NAME_CASE", "(", "CALL", ")", "NODE_NAME_CASE", "(", "TRAP", ")", "NODE_NAME_CASE", "(", "RET_FLAG", ")", "NODE_NAME_CASE", "(", "RETURN_TO_EPILOG", ")", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "SETREG", ")", "NODE_NAME_CASE", "(", "FMA_W_CHAIN", ")", "NODE_NAME_CASE", "(", "FMUL_W_CHAIN", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "FMAD_FTZ", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MULHI_U24", ")", "NODE_NAME_CASE", "(", "MULHI_I24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_U24", ")", "NODE_NAME_CASE", "(", "MUL_LOHI_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "EXPORT_DONE", ")", "NODE_NAME_CASE", "(", "R600_EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "CVT_PKRTZ_F16_F32", ")", "NODE_NAME_CASE", "(", "FP_TO_FP16", ")", "NODE_NAME_CASE", "(", "FP16_ZEXT", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "KILL", ")", "NODE_NAME_CASE", "(", "DUMMY_CHAIN", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "INIT_EXEC", ")", "NODE_NAME_CASE", "(", "INIT_EXEC_FROM_INPUT", ")", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "SENDMSGHALT", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT_X3", ")", "NODE_NAME_CASE", "(", "TBUFFER_LOAD_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD", ")", "NODE_NAME_CASE", "(", "BUFFER_LOAD_FORMAT", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "R600", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "unsigned", "int", "rs6000_cost_data", "::", "determine_suggested_unroll_factor", "(", "loop_vec_info", "loop_vinfo", ")", "{", "class", "loop", "*", "loop", "=", "LOOP_VINFO_LOOP", "(", "loop_vinfo", ")", ";", "if", "(", "loop", "->", "unroll", "==", "1", "||", "(", "OPTION_SET_P", "(", "flag_unroll_loops", ")", "&&", "!", "flag_unroll_loops", ")", "||", "(", "OPTION_SET_P", "(", "flag_unroll_all_loops", ")", "&&", "!", "flag_unroll_all_loops", ")", ")", "return", "1", ";", "unsigned", "int", "nstmts_nonldst", "=", "m_nstmts", "-", "m_nloads", "-", "m_nstores", ";", "if", "(", "nstmts_nonldst", "==", "0", ")", "return", "1", ";", "unsigned", "int", "reduc_factor", "=", "m_reduc_factor", ">", "1", "?", "m_reduc_factor", ":", "1", ";", "unsigned", "int", "issue_width", "=", "rs6000_vect_unroll_issue", ";", "unsigned", "int", "uf", "=", "CEIL", "(", "reduc_factor", "*", "issue_width", ",", "nstmts_nonldst", ")", ";", "uf", "=", "MIN", "(", "(", "unsigned", "int", ")", "rs6000_vect_unroll_limit", ",", "uf", ")", ";", "uf", "=", "1", "<<", "ceil_log2", "(", "uf", ")", ";", "if", "(", "LOOP_VINFO_NITERS_KNOWN_P", "(", "loop_vinfo", ")", ")", "return", "uf", ";", "if", "(", "reduc_factor", ">", "(", "unsigned", "int", ")", "rs6000_vect_unroll_reduc_threshold", "||", "m_gather_load", ")", "return", "uf", ";", "HOST_WIDE_INT", "est_niter", "=", "get_estimated_loop_iterations_int", "(", "loop", ")", ";", "unsigned", "int", "vf", "=", "vect_vf_for_cost", "(", "loop_vinfo", ")", ";", "unsigned", "int", "unrolled_vf", "=", "vf", "*", "uf", ";", "if", "(", "est_niter", "==", "-", "1", "||", "est_niter", "<", "unrolled_vf", ")", "return", "1", ";", "else", "{", "unsigned", "int", "epil_niter_unr", "=", "est_niter", "%", "unrolled_vf", ";", "unsigned", "int", "epil_niter", "=", "est_niter", "%", "vf", ";", "if", "(", "LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P", "(", "loop_vinfo", ")", "&&", "epil_niter_unr", "<=", "vf", ")", "return", "uf", ";", "else", "if", "(", "!", "LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P", "(", "loop_vinfo", ")", "&&", "epil_niter_unr", "<=", "epil_niter", ")", "return", "uf", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "suggested", "unroll", "factor", "by", "considering", "some", "below", "factors", ":", "-", "unroll", "option/pragma", "which", "can", "disable", "unrolling", "for", "this", "loop", ";", "-", "simple", "hardware", "resource", "model", "for", "non", "memory", "vector", "insns", ";", "-", "aggressive", "heuristics", "when", "iteration", "count", "is", "unknown", ":", "-", "reduction", "case", "to", "break", "cross", "iteration", "dependency", ";", "-", "emulated", "gather", "load", ";", "-", "estimated", "iteration", "count", "when", "iteration", "count", "is", "unknown", ";" ]

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

[]

[ "<s>", "static", "bool", "loongarch_valid_base_register_p", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "SUBREG_P", "(", "x", ")", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "loongarch_regno_mode_ok_for_base_p", "(", "REGNO", "(", "x", ")", ",", "mode", ",", "strict_p", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "base", "register", "for", "mode", "MODE", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "auto", "Changed", "=", "false", ";", "auto", "NvvmMetadata", "=", "M", ".", "getNamedMetadata", "(", "\"nvvm.annotations\"", ")", ";", "assert", "(", "NvvmMetadata", "&&", "\"IR compiled to PTX must have nvvm.annotations\"", ")", ";", "for", "(", "auto", "MetadataNode", ":", "NvvmMetadata", "->", "operands", "(", ")", ")", "{", "if", "(", "MetadataNode", "->", "getNumOperands", "(", ")", "!=", "3", ")", "continue", ";", "const", "MDOperand", "&", "TypeOperand", "=", "MetadataNode", "->", "getOperand", "(", "1", ")", ";", "auto", "Type", "=", "dyn_cast", "<", "MDString", ">", "(", "TypeOperand", ")", ";", "if", "(", "!", "Type", ")", "continue", ";", "if", "(", "Type", "->", "getString", "(", ")", "!=", "\"kernel\"", ")", "continue", ";", "const", "MDOperand", "&", "FuncOperand", "=", "MetadataNode", "->", "getOperand", "(", "0", ")", ";", "auto", "FuncConstant", "=", "dyn_cast", "<", "ConstantAsMetadata", ">", "(", "FuncOperand", ")", ";", "if", "(", "!", "FuncConstant", ")", "continue", ";", "auto", "Func", "=", "dyn_cast", "<", "Function", ">", "(", "FuncConstant", "->", "getValue", "(", ")", ")", ";", "if", "(", "!", "Func", ")", "continue", ";", "auto", "NewFunc", "=", "this", "->", "ProcessFunction", "(", "M", ",", "Func", ")", ";", "if", "(", "NewFunc", ")", "{", "Changed", "=", "true", ";", "MetadataNode", "->", "replaceOperandWith", "(", "0", ",", "llvm", "::", "ConstantAsMetadata", "::", "get", "(", "NewFunc", ")", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "\"nvvm.annotations\"", "\"IR compiled to PTX must have nvvm.annotations\"", "3", "1", "\"kernel\"", "0", "0" ]

[]

[ "<s>", "static", "void", "emit_load_locked", "(", "machine_mode", "mode", ",", "rtx", "reg", ",", "rtx", "mem", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ")", "=", "NULL", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "fn", "=", "gen_load_lockedqi", ";", "break", ";", "case", "HImode", ":", "fn", "=", "gen_load_lockedhi", ";", "break", ";", "case", "SImode", ":", "if", "(", "GET_MODE", "(", "mem", ")", "==", "QImode", ")", "fn", "=", "gen_load_lockedqi_si", ";", "else", "if", "(", "GET_MODE", "(", "mem", ")", "==", "HImode", ")", "fn", "=", "gen_load_lockedhi_si", ";", "else", "fn", "=", "gen_load_lockedsi", ";", "break", ";", "case", "DImode", ":", "fn", "=", "gen_load_lockeddi", ";", "break", ";", "case", "TImode", ":", "fn", "=", "gen_load_lockedti", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "fn", "(", "reg", ",", "mem", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "load-locked", "instruction", "in", "MODE", ".", "For", "QI/HImode", ",", "possibly", "use", "a", "pattern", "than", "includes", "the", "zero_extend", "operation", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "Z80oldDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "if", "(", "!", "SelectMem", "(", "Op", ",", "Op0", ")", ")", "{", "return", "true", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "return", "false", ";", "case", "InlineAsm", "::", "Constraint_o", ":", "if", "(", "!", "SelectOff", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "return", "true", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "}", "</s>" ]

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

[ "Z80old", "Z80old", "\"Unexpected asm memory constraint\"" ]

[]

[ "<s>", "static", "rtx", "frv_expand_mwtacc_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "0", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "MWTACC", "and", "MWTACCG", ".", "These", "builtins", "take", "an", "accumulator", "or", "accumulator", "guard", "as", "their", "first", "argument", "and", "an", "SImode", "value", "as", "their", "second", "." ]

[ "frv", "0", "1" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isGPRCopy", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "(", "AArch64", "::", "GPR32RegClass", ".", "contains", "(", "DstReg", ")", "||", "AArch64", "::", "GPR64RegClass", ".", "contains", "(", "DstReg", ")", ")", ";", "}", "case", "AArch64", "::", "ORRXrs", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "4", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid ORRrs operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "case", "AArch64", "::", "ADDXri", ":", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "4", "&&", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid ADDXri operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "a", "GPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::GPR32RegClass", "AArch64::GPR64RegClass", "AArch64::ORRXrs", "1", "AArch64::XZR", "4", "3", "0", "\"invalid ORRrs operands\"", "AArch64::ADDXri", "2", "0", "4", "3", "0", "\"invalid ADDXri operands\"" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "BitVector", "X86RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "RSP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ESP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "RIP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "EIP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "IP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "X86", "::", "RBP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "EBP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BP", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "BPL", ")", ";", "}", "Reserved", ".", "set", "(", "X86", "::", "ST0", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST1", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST2", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST3", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST4", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST5", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST6", ")", ";", "Reserved", ".", "set", "(", "X86", "::", "ST7", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::RSP", "X86::ESP", "X86::SP", "X86::SPL", "X86::RIP", "X86::EIP", "X86::IP", "X86::RBP", "X86::EBP", "X86::BP", "X86::BPL", "X86::ST0", "X86::ST1", "X86::ST2", "X86::ST3", "X86::ST4", "X86::ST5", "X86::ST6", "X86::ST7" ]

[]

[ "<s>", "int", "getIORegRAMPZ", "(", "void", ")", "const", "{", "return", "hasELPM", "(", ")", "?", "0x3b", ":", "-", "1", ";", "}", "</s>" ]

[ "Get", "I/O", "register", "addresses", "." ]

[ "AVR", "0x3b", "1" ]

[]

[ "<s>", "CCAssignFn", "*", "AMDGPUCallLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "return", "CC_AMDGPU_Kernel", ";", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_LS", ":", "return", "CC_AMDGPU", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "Cold", ":", "return", "CC_AMDGPU_Func", ";", "default", ":", "report_fatal_error", "(", "\"Unsupported calling convention.\"", ")", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"Unsupported calling convention.\"" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "GlobalBaseReg", "=", "0", ";", "PPCSubTarget", "=", "&", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "PPCLowering", "=", "Subtarget", "->", "getTargetLowering", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "section", "*", "rx_select_rtx_section", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "rx_small_data_limit", ">", "0", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "rx_small_data_limit", "&&", "align", "<=", "(", "unsigned", "HOST_WIDE_INT", ")", "rx_small_data_limit", "*", "BITS_PER_UNIT", ")", "return", "sdata_section", ";", "return", "default_elf_select_rtx_section", "(", "mode", ",", "x", ",", "align", ")", ";", "}", "</s>" ]

[ "Return", "a", "section", "for", "X", ".", "The", "only", "special", "thing", "we", "do", "here", "is", "to", "honor", "small", "data", "." ]

[ "rx", "0" ]

[]

[ "<s>", "static", "int", "current_file_function_operand", "(", "rtx", "sym_ref", ")", "{", "if", "(", "ENCODED_SHORT_CALL_ATTR_P", "(", "XSTR", "(", "sym_ref", ",", "0", ")", ")", ")", "return", "1", ";", "if", "(", "sym_ref", "==", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", "&&", "!", "DECL_WEAK", "(", "current_function_decl", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "operand", "is", "a", "SYMBOL_REF", "for", "a", "function", "known", "to", "be", "in", "this", "file", "and", "the", "function", "is", "not", "weakly", "defined", "." ]

[ "arm", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Plus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "char", "*", "NewOpcode", "=", "new", "char", "[", "Name", ".", "size", "(", ")", "+", "1", "]", ";", "memcpy", "(", "NewOpcode", ",", "Name", ".", "data", "(", ")", ",", "Name", ".", "size", "(", ")", ")", ";", "NewOpcode", "[", "Name", ".", "size", "(", ")", "]", "=", "'+'", ";", "Name", "=", "StringRef", "(", "NewOpcode", ",", "Name", ".", "size", "(", ")", "+", "1", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "char", "*", "NewOpcode", "=", "new", "char", "[", "Name", ".", "size", "(", ")", "+", "1", "]", ";", "memcpy", "(", "NewOpcode", ",", "Name", ".", "data", "(", ")", ",", "Name", ".", "size", "(", ")", ")", ";", "NewOpcode", "[", "Name", ".", "size", "(", ")", "]", "=", "'-'", ";", "Name", "=", "StringRef", "(", "NewOpcode", ",", "Name", ".", "size", "(", ")", "+", "1", ")", ";", "}", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Dot", ")", ";", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "if", "(", "Dot", "!=", "StringRef", "::", "npos", ")", "{", "SMLoc", "DotLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Dot", ")", ";", "StringRef", "DotStr", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "1", "1", "1", "0", "PPC", "PPC", "PPC", "PPC" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "bool", "Result", "=", "PPCAsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "auto", "setCsectAlignment", "=", "[", "this", "]", "(", "const", "GlobalObject", "*", "GO", ")", "{", "if", "(", "GO", "->", "isDeclarationForLinker", "(", ")", ")", "return", ";", "SectionKind", "GOKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GO", ",", "TM", ")", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GO", ",", "GOKind", ",", "TM", ")", ")", ";", "Align", "GOAlign", "=", "getGVAlignment", "(", "GO", ",", "GO", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "if", "(", "GOAlign", ">", "Csect", "->", "getAlignment", "(", ")", ")", "Csect", "->", "setAlignment", "(", "GOAlign", ")", ";", "}", ";", "for", "(", "const", "auto", "&", "G", ":", "M", ".", "globals", "(", ")", ")", "{", "if", "(", "isSpecialLLVMGlobalArrayToSkip", "(", "&", "G", ")", ")", "continue", ";", "setCsectAlignment", "(", "&", "G", ")", ";", "}", "for", "(", "const", "auto", "&", "F", ":", "M", ")", "setCsectAlignment", "(", "&", "F", ")", ";", "for", "(", "const", "auto", "&", "Alias", ":", "M", ".", "aliases", "(", ")", ")", "{", "const", "GlobalObject", "*", "Base", "=", "Alias", ".", "getBaseObject", "(", ")", ";", "if", "(", "!", "Base", ")", "report_fatal_error", "(", "\"alias without a base object is not yet supported on AIX\"", ")", ";", "GOAliasMap", "[", "Base", "]", ".", "push_back", "(", "&", "Alias", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"alias without a base object is not yet supported on AIX\"" ]

[]

[ "<s>", "unsigned", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "override", "{", "return", "4U", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "TL45", "4U" ]

[]

[ "<s>", "void", "PPCELFStreamer", "::", "emitLabel", "(", "MCSymbol", "*", "Symbol", ",", "SMLoc", "Loc", ")", "{", "LastLabel", "=", "Symbol", ";", "LastLabelLoc", "=", "Loc", ";", "MCELFStreamer", "::", "emitLabel", "(", "Symbol", ")", ";", "}", "</s>" ]

[ "Emit", "a", "label", "for", "Symbol", "into", "the", "current", "section", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getFrameOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "unsigned", "int", "execute", "(", "function", "*", ")", "{", "return", "nds32_fp_as_gp", "(", ")", ";", "}", "</s>" ]

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

[ "nds32" ]

[]

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

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

[ "SystemZ", "SystemZ::NumTargetFixupKinds" ]

[]

[ "<s>", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "GCNMinRegScheduler", "::", "schedule", "(", "ArrayRef", "<", "const", "SUnit", "*", ">", "TopRoots", ",", "const", "ScheduleDAG", "&", "DAG", ")", "{", "const", "auto", "&", "SUnits", "=", "DAG", ".", "SUnits", ";", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "Schedule", ";", "Schedule", ".", "reserve", "(", "SUnits", ".", "size", "(", ")", ")", ";", "initNumPreds", "(", "SUnits", ")", ";", "int", "StepNo", "=", "0", ";", "for", "(", "auto", "SU", ":", "TopRoots", ")", "{", "RQ", ".", "push_back", "(", "*", "new", "(", "Alloc", ".", "Allocate", "(", ")", ")", "Candidate", "(", "SU", ",", "StepNo", ")", ")", ";", "}", "releaseSuccessors", "(", "&", "DAG", ".", "EntrySU", ",", "StepNo", ")", ";", "while", "(", "!", "RQ", ".", "empty", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n=== Picking candidate, Step = \"", "<<", "StepNo", "<<", "\"\\n\"", "\"Ready queue:\"", ";", "for", "(", "auto", "&", "C", ":", "RQ", ")", "dbgs", "(", ")", "<<", "' '", "<<", "C", ".", "SU", "->", "NodeNum", "<<", "\"(P\"", "<<", "C", ".", "Priority", "<<", "')'", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", ")", ";", "auto", "C", "=", "pickCandidate", "(", ")", ";", "assert", "(", "C", ")", ";", "RQ", ".", "remove", "(", "*", "C", ")", ";", "auto", "SU", "=", "C", "->", "SU", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selected \"", ";", "SU", "->", "dump", "(", "&", "DAG", ")", ")", ";", "releaseSuccessors", "(", "SU", ",", "StepNo", ")", ";", "Schedule", ".", "push_back", "(", "SU", ")", ";", "setIsScheduled", "(", "SU", ")", ";", "if", "(", "getReadySuccessors", "(", "SU", ")", "==", "0", ")", "bumpPredsPriority", "(", "SU", ",", "StepNo", ")", ";", "++", "StepNo", ";", "}", "assert", "(", "SUnits", ".", "size", "(", ")", "==", "Schedule", ".", "size", "(", ")", ")", ";", "return", "Schedule", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "AMDGPU", "0", "\"\\n=== Picking candidate, Step = \"", "\"\\n\"", "\"Ready queue:\"", "\"(P\"", "\"Selected \"", "0" ]

[]

[ "<s>", "void", "TOYFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "computeStackSize", "(", "MF", ")", ";", "if", "(", "!", "StackSize", ")", "{", "return", ";", "}", "unsigned", "StackReg", "=", "TOY", "::", "SP", ";", "unsigned", "OffsetReg", "=", "materializeOffset", "(", "MF", ",", "MBB", ",", "MBBI", ",", "(", "unsigned", ")", "StackSize", ")", ";", "if", "(", "OffsetReg", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "SUBrr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "SUBri", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ")", ".", "addImm", "(", "StackSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY::SP", "TOY::SUBrr", "TOY::SUBri" ]

[]

[ "<s>", "static", "void", "mips_start_ll_sc_sync_block", "(", "void", ")", "{", "if", "(", "!", "ISA_HAS_LL_SC", ")", "{", "output_asm_insn", "(", "\".set\\tpush\"", ",", "0", ")", ";", "if", "(", "TARGET_64BIT", ")", "output_asm_insn", "(", "\".set\\tmips3\"", ",", "0", ")", ";", "else", "output_asm_insn", "(", "\".set\\tmips2\"", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Start", "a", "block", "of", "code", "that", "needs", "access", "to", "the", "LL", ",", "SC", "and", "SYNC", "instructions", "." ]

[ "mips", "\".set\\tpush\"", "0", "\".set\\tmips3\"", "0", "\".set\\tmips2\"", "0" ]

[]

[ "<s>", "static", "int", "m32c_leaf_function_p", "(", "void", ")", "{", "rtx", "saved_first", ",", "saved_last", ";", "struct", "sequence_stack", "*", "seq", ";", "int", "rv", ";", "saved_first", "=", "cfun", "->", "emit", "->", "x_first_insn", ";", "saved_last", "=", "cfun", "->", "emit", "->", "x_last_insn", ";", "for", "(", "seq", "=", "cfun", "->", "emit", "->", "sequence_stack", ";", "seq", "&&", "seq", "->", "next", ";", "seq", "=", "seq", "->", "next", ")", ";", "if", "(", "seq", ")", "{", "cfun", "->", "emit", "->", "x_first_insn", "=", "seq", "->", "first", ";", "cfun", "->", "emit", "->", "x_last_insn", "=", "seq", "->", "last", ";", "}", "rv", "=", "leaf_function_p", "(", ")", ";", "cfun", "->", "emit", "->", "x_first_insn", "=", "saved_first", ";", "cfun", "->", "emit", "->", "x_last_insn", "=", "saved_last", ";", "return", "rv", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "the", "current", "function", "is", "a", "leaf", ",", "and", "thus", "we", "can", "determine", "which", "registers", "an", "interrupt", "function", "really", "needs", "to", "save", ".", "The", "logic", "below", "is", "mostly", "about", "finding", "the", "insn", "sequence", "that", "'s", "the", "function", ",", "versus", "any", "sequence", "that", "might", "be", "open", "for", "the", "current", "insn", "." ]

[ "m32c" ]

[]

[ "<s>", "static", "enum", "reg_class", "init_unavailable", "(", "tag_insn_info", "*", "insn_info", ",", "tag_map_t", "&", "tag_map", ",", "du_head_p", "head", ",", "HARD_REG_SET", "*", "unavailable", ")", "{", "unsigned", "dest", "=", "head", "->", "regno", ";", "enum", "reg_class", "super_class", "=", "NO_REGS", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "insn_info", "->", "dest", ")", ";", "CLEAR_HARD_REG_SET", "(", "*", "unavailable", ")", ";", "for", "(", "struct", "du_chain", "*", "tmp", "=", "head", "->", "first", ";", "tmp", ";", "tmp", "=", "tmp", "->", "next_use", ")", "{", "if", "(", "DEBUG_INSN_P", "(", "tmp", "->", "insn", ")", ")", "continue", ";", "IOR_COMPL_HARD_REG_SET", "(", "*", "unavailable", ",", "reg_class_contents", "[", "tmp", "->", "cl", "]", ")", ";", "super_class", "=", "reg_class_superunion", "[", "(", "int", ")", "super_class", "]", "[", "(", "int", ")", "tmp", "->", "cl", "]", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "fixed_regs", "[", "i", "]", "||", "global_regs", "[", "i", "]", ")", "add_to_hard_reg_set", "(", "unavailable", ",", "mode", ",", "i", ")", ";", "arg_pair_t", "arg", "=", "arg_pair_t", "(", "insn_info", ",", "unavailable", ")", ";", "tag_map", ".", "traverse", "<", "arg_pair_t", "*", ",", "check_colliding_tags", ">", "(", "&", "arg", ")", ";", "ignore_all_aliases", "(", "unavailable", ",", "mode", ",", "dest", "&", "0xf", ")", ";", "return", "super_class", ";", "}", "</s>" ]

[ "Initialize", "and", "build", "a", "set", "of", "hard", "register", "numbers", "UNAVAILABLE", "to", "avoid", "for", "renaming", ".", "INSN_INFO", "is", "the", "original", "insn", ",", "TAG_MAP", "is", "the", "map", "of", "the", "list", "of", "insns", "indexed", "by", "their", "tags", ",", "HEAD", "is", "the", "def/use", "chain", "head", "of", "the", "destination", "register", "of", "the", "original", "insn", ".", "The", "routine", "returns", "the", "super", "class", "of", "register", "classes", "that", "may", "be", "used", "during", "the", "renaming", "." ]

[ "aarch64", "0", "0xf" ]

[]

[ "<s>", "unsigned", "MipsABIInfo", "::", "GetCalleeAllocdArgSizeInBytes", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "CC", "!=", "CallingConv", "::", "Fast", "?", "16", ":", "0", ";", "if", "(", "IsN32", "(", ")", "||", "IsN64", "(", ")", ")", "return", "0", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "Obtain", "the", "size", "of", "the", "area", "allocated", "by", "the", "callee", "for", "arguments", "." ]

[ "Mips", "Mips", "16", "0", "0", "\"Unhandled ABI\"" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_call_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_op", ")", "{", "bool", "direct_p", "=", "constant_call_address_operand", "(", "call_op", ",", "VOIDmode", ")", ";", "bool", "output_indirect_p", "=", "(", "!", "TARGET_SEH", "&&", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_keep", ")", ";", "bool", "seh_nop_p", "=", "false", ";", "const", "char", "*", "xasm", ";", "if", "(", "SIBLING_CALL_P", "(", "insn", ")", ")", "{", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "{", "direct_p", "=", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"{%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "}", "else", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"{%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "else", "xasm", "=", "\"%!jmp\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "}", "}", "else", "xasm", "=", "\"%!jmp\\t%P0\"", ";", "}", "else", "if", "(", "TARGET_SEH", ")", "xasm", "=", "\"%!rex.W jmp\\t%A0\"", ";", "else", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"%0\"", ";", "else", "xasm", "=", "\"%!jmp\\t%A0\"", ";", "}", "if", "(", "output_indirect_p", "&&", "!", "direct_p", ")", "ix86_output_indirect_branch", "(", "call_op", ",", "xasm", ",", "true", ")", ";", "else", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "return", "\"\"", ";", "}", "if", "(", "TARGET_SEH", ")", "{", "rtx_insn", "*", "i", ";", "for", "(", "i", "=", "NEXT_INSN", "(", "insn", ")", ";", "i", ";", "i", "=", "NEXT_INSN", "(", "i", ")", ")", "{", "if", "(", "JUMP_P", "(", "i", ")", "&&", "CROSSING_JUMP_P", "(", "i", ")", ")", "{", "seh_nop_p", "=", "true", ";", "break", ";", "}", "if", "(", "INSN_P", "(", "i", ")", ")", "break", ";", "if", "(", "NOTE_P", "(", "i", ")", "&&", "NOTE_KIND", "(", "i", ")", "==", "NOTE_INSN_EPILOGUE_BEG", "&&", "!", "flag_non_call_exceptions", "&&", "!", "can_throw_internal", "(", "insn", ")", ")", "{", "seh_nop_p", "=", "true", ";", "break", ";", "}", "}", "if", "(", "i", "==", "NULL", ")", "seh_nop_p", "=", "true", ";", "}", "if", "(", "direct_p", ")", "{", "if", "(", "ix86_nopic_noplt_attribute_p", "(", "call_op", ")", ")", "{", "direct_p", "=", "false", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"{%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "else", "xasm", "=", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", ";", "}", "else", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"{%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "else", "xasm", "=", "\"%!call\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", ";", "}", "}", "else", "xasm", "=", "\"%!call\\t%P0\"", ";", "}", "else", "{", "if", "(", "output_indirect_p", ")", "xasm", "=", "\"%0\"", ";", "else", "xasm", "=", "\"%!call\\t%A0\"", ";", "}", "if", "(", "output_indirect_p", "&&", "!", "direct_p", ")", "ix86_output_indirect_branch", "(", "call_op", ",", "xasm", ",", "false", ")", ";", "else", "output_asm_insn", "(", "xasm", ",", "&", "call_op", ")", ";", "if", "(", "seh_nop_p", ")", "return", "\"nop\"", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "for", "a", "call", "instruction", "." ]

[ "i386", "\"{%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!jmp\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"{%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!jmp\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!jmp\\t%P0\"", "\"%!rex.W jmp\\t%A0\"", "\"%0\"", "\"%!jmp\\t%A0\"", "\"\"", "\"{%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"%!call\\t{*%p0@GOTPCREL(%%rip)|[QWORD PTR %p0@GOTPCREL[rip]]}\"", "\"{%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!call\\t{*%p0@GOT|[DWORD PTR %p0@GOT]}\"", "\"%!call\\t%P0\"", "\"%0\"", "\"%!call\\t%A0\"", "\"nop\"", "\"\"" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "unsigned", "RemovedSize", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "{", "I", "=", "Next", ";", "continue", ";", "}", "RemovedSize", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "++", "Count", ";", "I", "=", "Next", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "RemovedSize", ";", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "AMDGPU", "SI", "0", "0", "AMDGPU::SI_MASK_BRANCH" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "if", "(", "!", "TargetLoweringBase", "::", "shouldReduceLoadWidth", "(", "Load", ",", "ExtTy", ",", "NewVT", ")", ")", "return", "false", ";", "if", "(", "ExtTy", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "true", ";", "MemSDNode", "*", "Mem", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "Load", ")", ";", "assert", "(", "Mem", ")", ";", "const", "SDValue", "&", "Base", "=", "Mem", "->", "getBasePtr", "(", ")", ";", "if", "(", "Base", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "hasOneUse", "(", ")", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "{", "uint64_t", "ShiftAmount", "=", "Base", ".", "getOperand", "(", "1", ")", ".", "getConstantOperandVal", "(", "1", ")", ";", "uint64_t", "LoadBytes", "=", "Mem", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "if", "(", "ShiftAmount", "==", "Log2_32", "(", "LoadBytes", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "AArch64", "AArch64", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::ADD", "1", "ISD::SHL", "1", "1", "1", "ISD::Constant", "1", "1", "8" ]

[]

[ "<s>", "static", "bool", "originalEVTTypeIsVectorFloat", "(", "EVT", "Ty", ")", "{", "if", "(", "Ty", ".", "isVector", "(", ")", "&&", "Ty", ".", "getVectorElementType", "(", ")", ".", "isFloatingPoint", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "original", "type", "was", "vXfXX", "." ]

[ "Mips" ]

[]

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

[ "Return", "true", "if", "the", "target", "supports", "swifterror", "attribute", "." ]

[ "ARM" ]

[]

[ "<s>", "const", "uint16_t", "*", "MipsRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "CSR_SingleFloatOnly_SaveList", ";", "else", "if", "(", "!", "Subtarget", ".", "hasMips64", "(", ")", ")", "return", "CSR_O32_SaveList", ";", "else", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "CSR_N32_SaveList", ";", "assert", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", ";", "return", "CSR_N64_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "seh_emit_push", "(", "FILE", "*", "f", ",", "struct", "seh_frame_state", "*", "seh", ",", "rtx", "reg", ")", "{", "const", "unsigned", "int", "regno", "=", "REGNO", "(", "reg", ")", ";", "gcc_checking_assert", "(", "GENERAL_REGNO_P", "(", "regno", ")", ")", ";", "seh", "->", "sp_offset", "+=", "UNITS_PER_WORD", ";", "seh", "->", "reg_offset", "[", "regno", "]", "=", "seh", "->", "sp_offset", ";", "if", "(", "seh", "->", "cfa_reg", "==", "stack_pointer_rtx", ")", "seh", "->", "cfa_offset", "+=", "UNITS_PER_WORD", ";", "fputs", "(", "\"\\t.seh_pushreg\\t\"", ",", "f", ")", ";", "print_reg", "(", "reg", ",", "0", ",", "f", ")", ";", "fputc", "(", "'\\n'", ",", "f", ")", ";", "}", "</s>" ]

[ "Emit", "an", "assembler", "directive", "to", "save", "REG", "via", "a", "PUSH", "." ]

[ "i386", "\"\\t.seh_pushreg\\t\"", "0" ]

[]

[ "<s>", "void", "MMIXFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SavedRegs", ".", "set", "(", "MMIX", "::", "r253", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "MMIX", "MMIX", "MMIX::r253" ]

[]

[ "<s>", "void", "TPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "addPass", "(", "createTPCLutCacheCounter", "(", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "addPass", "(", "createTPCPacketizer", "(", ")", ",", "false", ")", ";", "}", "addPass", "(", "createTPCUnHardwareLoops", "(", ")", ")", ";", "addPass", "(", "createTPCLatencyResolver", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCPipelineRegs", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCCostModelEmitter", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCInstrCompress", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCRegisterCounter", "(", ")", ",", "false", ")", ";", "addPass", "(", "createTPCElfSpecSet", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "cris_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "mem", ";", "emit_block_move", "(", "m_tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "10", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "16", ")", ";", "emit_move_insn", "(", "mem", ",", "fnaddr", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_TRAMPOLINE_INIT", "." ]

[ "cris", "0", "10", "16" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "HII", "->", "isPredicated", "(", "*", "MI", ")", "||", "!", "HII", "->", "isPredicable", "(", "*", "MI", ")", ")", "return", "false", ";", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "bool", "HasDef", "=", "false", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", ")", "continue", ";", "if", "(", "HasDef", ")", "return", "false", ";", "HasDef", "=", "true", ";", "}", "for", "(", "auto", "&", "Mo", ":", "MI", "->", "memoperands", "(", ")", ")", "if", "(", "Mo", "->", "isVolatile", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "convertSelectOfConstantsToMath", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "select", "of", "constants", "(", "select", "Cond", ",", "C1", ",", "C2", ")", "should", "be", "transformed", "into", "simple", "math", "ops", "with", "the", "condition", "value", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "int", "xs_hi_nonmemory_operand", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "&&", "(", "(", "INTVAL", "(", "x", ")", ">=", "32768", ")", "||", "(", "INTVAL", "(", "x", ")", "<", "-", "32768", ")", ")", ")", "error", "(", "\"constant arithmetic operand out of range\"", ")", ";", "return", "nonmemory_operand", "(", "x", ",", "mode", ")", ";", "}", "</s>" ]

[ "Detect", "and", "error", "out", "on", "out-of-range", "constants", "for", "addhi", "and", "subhi", "." ]

[ "stormy16", "32768", "32768", "\"constant arithmetic operand out of range\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyLocalReference", "(", "const", "GlobalValue", "*", "GV", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "&&", "(", "GV", "->", "isDeclarationForLinker", "(", ")", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "return", "X86II", "::", "MO_GOTOFF", ";", "}", "</s>" ]

[ "Classify", "a", "global", "variable", "reference", "for", "the", "current", "subtarget", "according", "to", "how", "we", "should", "reference", "it", "in", "a", "non-pcrel", "context", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_GOTOFF" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "return", "5", "-", "HasFP", ";", "}", "case", "ARM", "::", "GPRRegClassID", ":", "{", "bool", "HasFP", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "isMaxCallFrameSizeComputed", "(", ")", "?", "TFI", "->", "hasFP", "(", "MF", ")", ":", "true", ";", "bool", "IsPagerando", "=", "MF", ".", "getFunction", "(", ")", ".", "isPagerando", "(", ")", ";", "return", "10", "-", "HasFP", "-", "(", "STI", ".", "isR9Reserved", "(", ")", "||", "IsPagerando", "?", "1", ":", "0", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "32", "-", "10", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "0", "ARM::tGPRRegClassID", "5", "ARM::GPRRegClassID", "10", "1", "0", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "32", "10" ]

[]

[ "<s>", "static", "rtx", "frv_expand_voidbinop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "enum", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", "{", "rtx", "reg", "=", "op0", ";", "if", "(", "!", "offsettable_address_p", "(", "0", ",", "mode0", ",", "op0", ")", ")", "{", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "op0", ")", ")", ";", "}", "op0", "=", "gen_rtx_MEM", "(", "SImode", ",", "reg", ")", ";", "}", "addr", "=", "XEXP", "(", "op0", ",", "0", ")", ";", "if", "(", "!", "offsettable_address_p", "(", "0", ",", "mode0", ",", "addr", ")", ")", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ";", "op0", "=", "change_address", "(", "op0", ",", "V4SImode", ",", "addr", ")", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "operands", ",", "the", "first", "operand", "being", "a", "pointer", "to", "ints", "and", "return", "void", "." ]

[ "frv", "0", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Atom pad short functions\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Atom pad short functions\"" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "LoopInfo", "&", "LI", "=", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", ")", "Gathers", ".", "push_back", "(", "II", ")", ";", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", ")", "Scatters", ".", "push_back", "(", "II", ")", ";", "}", "}", "bool", "Changed", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Gathers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Gathers", "[", "i", "]", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "I", "->", "getArgOperand", "(", "0", ")", ")", ")", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "I", "->", "getArgOperand", "(", "0", ")", ")", "->", "getOperand", "(", "1", ")", ",", "I", "->", "getParent", "(", ")", ",", "&", "LI", ")", ";", "Value", "*", "L", "=", "lowerGather", "(", "I", ")", ";", "if", "(", "L", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "L", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Scatters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Scatters", "[", "i", "]", ";", "if", "(", "isa", "<", "GetElementPtrInst", ">", "(", "I", "->", "getArgOperand", "(", "1", ")", ")", ")", "optimiseOffsets", "(", "cast", "<", "Instruction", ">", "(", "I", "->", "getArgOperand", "(", "1", ")", ")", "->", "getOperand", "(", "1", ")", ",", "I", "->", "getParent", "(", ")", ",", "&", "LI", ")", ";", "Value", "*", "S", "=", "lowerScatter", "(", "I", ")", ";", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "cast", "<", "Instruction", ">", "(", "S", ")", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "Intrinsic::masked_gather", "Intrinsic::masked_scatter", "0", "0", "0", "1", "0", "1", "1", "1" ]

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "UseMulOps", "(", "UseFusedMulOps", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "ARMCallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "ARMLegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "ARMRegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createARMInstructionSelector", "(", "*", "static_cast", "<", "const", "ARMBaseTargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "int", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "const", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "uint64_t", "ArgumentPopSize", "=", "0", ";", "if", "(", "RetOpcode", "==", "AArch64", "::", "TCRETURNdi", "||", "RetOpcode", "==", "AArch64", "::", "TCRETURNri", ")", "{", "MachineOperand", "&", "StackAdjust", "=", "MBBI", "->", "getOperand", "(", "1", ")", ";", "ArgumentPopSize", "=", "StackAdjust", ".", "getImm", "(", ")", ";", "}", "else", "{", "ArgumentPopSize", "=", "AFI", "->", "getArgumentStackToRestore", "(", ")", ";", "}", "NumBytes", "+=", "ArgumentPopSize", ";", "unsigned", "NumRestores", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "LastPopI", "=", "MBBI", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "if", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "do", "{", "++", "NumRestores", ";", "--", "LastPopI", ";", "}", "while", "(", "LastPopI", "!=", "MBB", ".", "begin", "(", ")", "&&", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", ";", "if", "(", "!", "isCSRestore", "(", "LastPopI", ",", "CSRegs", ")", ")", "{", "++", "LastPopI", ";", "--", "NumRestores", ";", "}", "}", "NumBytes", "-=", "NumRestores", "*", "16", ";", "assert", "(", "NumBytes", ">=", "0", "&&", "\"Negative stack allocation size!?\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "!", "canUseRedZone", "(", "MF", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "NumBytes", ",", "TII", ")", ";", "return", ";", "}", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "emitFrameOffset", "(", "MBB", ",", "LastPopI", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "FP", ",", "-", "(", "NumRestores", "-", "1", ")", "*", "16", ",", "TII", ",", "MachineInstr", "::", "NoFlags", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Can only insert epilog into returning blocks\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "0", "AArch64::TCRETURNdi", "AArch64::TCRETURNri", "1", "0", "16", "0", "\"Negative stack allocation size!?\"", "AArch64::SP", "AArch64::SP", "AArch64::SP", "AArch64::FP", "1", "16" ]

[]

[ "<s>", "static", "unsigned", "getSize", "(", "unsigned", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "return", "4", ";", "case", "RISCV", "::", "fixup_riscv_rvc_jump", ":", "case", "RISCV", "::", "fixup_riscv_rvc_branch", ":", "return", "2", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

[ "RISCV", "4", "RISCV::fixup_riscv_rvc_jump", "RISCV::fixup_riscv_rvc_branch", "2" ]

[]

[ "<s>", "bool", "MSP430InstrInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::POP16r" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TGSI Control Flow Graph structurizer Pass\"", ";", "}", "</s>" ]

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

[ "TGSI", "\"TGSI Control Flow Graph structurizer Pass\"" ]

[]

[ "<s>", "iterator", "end", "(", ")", "const", "{", "return", "SubExceptions", ".", "end", "(", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "SDValue", "SystemZDAGToDAGISel", "::", "getUNDEF", "(", "const", "SDLoc", "&", "DL", ",", "EVT", "VT", ")", "const", "{", "SDNode", "*", "N", "=", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "DL", ",", "VT", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "an", "UNDEF", "node", ".", "UNDEF", "does", "not", "have", "a", "useful", "SDLoc", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "SI_ADDR64_RSRC", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "SuperReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubRegLo", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "SubRegHi", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "unsigned", "SubRegHiHi", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ";", "unsigned", "SubRegHiLo", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "SubRegLo", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "SubRegHiLo", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "SubRegHiHi", ")", ".", "addImm", "(", "RSRC_DATA_FORMAT", ">>", "32", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "SubRegHi", ")", ".", "addReg", "(", "SubRegHiLo", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "SubRegHiHi", ")", ".", "addImm", "(", "AMDGPU", "::", "sub1", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "SuperReg", ")", ".", "addReg", "(", "SubRegLo", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0_sub1", ")", ".", "addReg", "(", "SubRegHi", ")", ".", "addImm", "(", "AMDGPU", "::", "sub2_sub3", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "R600", "SI", "SI", "SI", "SI", "0", "1", "0", "32" ]

[]

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

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

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

[]

[ "<s>", "void", "BPFInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "PPCTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"wc\"", "&&", "type", "->", "isIntegerTy", "(", "1", ")", ")", "return", "CW_Register", ";", "else", "if", "(", "(", "StringRef", "(", "constraint", ")", "==", "\"wa\"", "||", "StringRef", "(", "constraint", ")", "==", "\"wd\"", "||", "StringRef", "(", "constraint", ")", "==", "\"wf\"", ")", "&&", "type", "->", "isVectorTy", "(", ")", ")", "return", "CW_Register", ";", "else", "if", "(", "StringRef", "(", "constraint", ")", "==", "\"ws\"", "&&", "type", "->", "isDoubleTy", "(", ")", ")", "return", "CW_Register", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'b'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'d'", ":", "if", "(", "type", "->", "isDoubleTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'v'", ":", "if", "(", "type", "->", "isVectorTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'y'", ":", "weight", "=", "CW_Register", ";", "break", ";", "case", "'Z'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "PowerPC", "PPC", "\"wc\"", "1", "\"wa\"", "\"wd\"", "\"wf\"", "\"ws\"" ]

[]

[ "<s>", "static", "unsigned", "long", "csky_isr_value", "(", "tree", "argument", ")", "{", "const", "isr_attribute_entry", "*", "ptr", ";", "const", "char", "*", "arg", ";", "if", "(", "argument", "==", "NULL_TREE", ")", "return", "CSKY_FT_ISR", ";", "if", "(", "TREE_VALUE", "(", "argument", ")", "==", "NULL_TREE", "||", "TREE_CODE", "(", "TREE_VALUE", "(", "argument", ")", ")", "!=", "STRING_CST", ")", "return", "CSKY_FT_UNKNOWN", ";", "arg", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "argument", ")", ")", ";", "for", "(", "ptr", "=", "isr_attribute_map", ";", "ptr", "->", "arg", "!=", "NULL", ";", "ptr", "++", ")", "if", "(", "strcmp", "(", "arg", ",", "ptr", "->", "arg", ")", "==", "0", ")", "return", "ptr", "->", "return_value", ";", "return", "CSKY_FT_UNKNOWN", ";", "}", "</s>" ]

[ "Returns", "the", "(", "interrupt", ")", "function", "type", "of", "the", "current", "function", ",", "or", "CSKY_FT_UNKNOWN", "if", "the", "type", "can", "not", "be", "determined", "." ]

[ "csky", "0" ]

[]

[ "<s>", "sh_extending_set_of_reg", "sh_find_extending_set_of_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "curr_insn", ")", "{", "if", "(", "reg", "==", "NULL", ")", "return", "sh_extending_set_of_reg", "(", "curr_insn", ")", ";", "if", "(", "SUBREG_P", "(", "reg", ")", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "sh_extending_set_of_reg", "(", "curr_insn", ")", ";", "sh_extending_set_of_reg", "result", "=", "sh_find_set_of_reg", "(", "reg", ",", "curr_insn", ",", "prev_nonnote_nondebug_insn_bb", ",", "true", ")", ";", "if", "(", "result", ".", "set_src", "!=", "NULL", ")", "{", "if", "(", "GET_CODE", "(", "result", ".", "set_src", ")", "==", "SIGN_EXTEND", "||", "GET_CODE", "(", "result", ".", "set_src", ")", "==", "ZERO_EXTEND", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"explicitly sign/zero extended in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "INSN_UID", "(", "result", ".", "insn", ")", ")", ";", "result", ".", "from_mode", "=", "GET_MODE", "(", "XEXP", "(", "result", ".", "set_src", ",", "0", ")", ")", ";", "result", ".", "ext_code", "=", "GET_CODE", "(", "result", ".", "set_src", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "result", ".", "set_src", ")", "&&", "(", "GET_MODE", "(", "result", ".", "set_src", ")", "==", "QImode", "||", "GET_MODE", "(", "result", ".", "set_src", ")", "==", "HImode", ")", "&&", "!", "sh_unspec_insn_p", "(", "result", ".", "insn", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"implicitly sign extended in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "INSN_UID", "(", "result", ".", "insn", ")", ")", ";", "result", ".", "from_mode", "=", "GET_MODE", "(", "result", ".", "set_src", ")", ";", "result", ".", "ext_code", "=", "SIGN_EXTEND", ";", "}", "}", "return", "result", ";", "}", "</s>" ]

[ "Given", "a", "reg", "and", "the", "current", "insn", ",", "see", "if", "the", "value", "of", "the", "reg", "originated", "from", "a", "sign", "or", "zero", "extension", "and", "return", "the", "discovered", "information", "." ]

[ "sh", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"explicitly sign/zero extended in insn %d\\n\"", "0", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"implicitly sign extended in insn %d\\n\"" ]

[]