Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "ARCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARCInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "ObjSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int", "LocalFrameSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getLocalFrameSize", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MI", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ObjSize : \"", "<<", "ObjSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LocalFrameSize : \"", "<<", "LocalFrameSize", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "LocalFrameSize", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Offset", "=", "StackSize", "+", "Offset", ";", "if", "(", "FrameIndex", ">=", "0", ")", "assert", "(", "(", "Offset", ">=", "0", "&&", "Offset", "<", "StackSize", ")", "&&", "\"SP Offset not in bounds.\"", ")", ";", "}", "else", "{", "if", "(", "FrameIndex", ">=", "0", ")", "{", "assert", "(", "(", "Offset", "<", "0", "&&", "-", "Offset", "<=", "StackSize", ")", "&&", "\"FP Offset not in bounds.\"", ")", ";", "}", "}", "replaceFrameIndex", "(", "II", ",", "TII", ",", "Reg", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ",", "StackSize", ",", "ObjSize", ",", "RS", ",", "SPAdj", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "0", "\"Unexpected\"", "ARC", "ARC", "ARC", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"ObjSize : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "\"LocalFrameSize : \"", "\"\\n\"", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0", "ARC::GPR32RegClass", "\"Unexpected register operand\"", "0", "0", "\"SP Offset not in bounds.\"", "0", "0", "\"FP Offset not in bounds.\"" ]

[]

[ "<s>", "bool", "isThumb", "(", ")", "const", "{", "return", "InThumbMode", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "is", "Thumb", "(", "little", "and", "big", "endian", ")", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "ARMDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_i", ":", "LLVM_FALLTHROUGH", ";", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_Um", ":", "case", "InlineAsm", "::", "Constraint_Un", ":", "case", "InlineAsm", "::", "Constraint_Uq", ":", "case", "InlineAsm", "::", "Constraint_Us", ":", "case", "InlineAsm", "::", "Constraint_Ut", ":", "case", "InlineAsm", "::", "Constraint_Uv", ":", "case", "InlineAsm", "::", "Constraint_Uy", ":", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "recombine_lvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "auto_vec", "<", "rtx_insn", "*", ">", "and_insns", ";", "auto_vec", "<", "rtx", ">", "and_ops", ";", "bool", "is_any_def_and", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ",", "&", "and_insns", ",", "&", "and_ops", ")", ";", "if", "(", "is_any_def_and", ")", "{", "gcc_assert", "(", "and_insns", ".", "length", "(", ")", "==", "and_ops", ".", "length", "(", ")", ")", ";", "df_ref", "def", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "rtx", "new_reg", "=", "0", ";", "rtx", "and_mask", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "and_insns", ".", "length", "(", ")", ";", "i", "++", ")", "{", "rtx_insn", "*", "and_insn", "=", "and_insns", "[", "i", "]", ";", "rtx", "and_op", "=", "and_ops", "[", "i", "]", ";", "rtx", "and_base", "=", "XEXP", "(", "and_op", ",", "0", ")", ";", "if", "(", "!", "new_reg", ")", "{", "new_reg", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "and_base", ")", ")", ";", "and_mask", "=", "XEXP", "(", "and_op", ",", "1", ")", ";", "}", "rtx", "copy", "=", "gen_rtx_SET", "(", "new_reg", ",", "and_base", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_after", "(", "copy", ",", "and_insn", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "and_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "}", "XEXP", "(", "mem", ",", "0", ")", "=", "gen_rtx_AND", "(", "GET_MODE", "(", "new_reg", ")", ",", "new_reg", ",", "and_mask", ")", ";", "SET_SRC", "(", "body", ")", "=", "mem", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"lvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "load", "for", "an", "lvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "0", "1", "0", "1", "\"lvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "}", "</s>" ]

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

[ "MSP430" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "getFixupKind", "(", "StringRef", "Name", ")", "const", "override", "{", "return", "StringSwitch", "<", "Optional", "<", "MCFixupKind", ">>", "(", "Name", ")", ".", "Case", "(", "\"dir32\"", ",", "FK_Data_4", ")", ".", "Case", "(", "\"secrel32\"", ",", "FK_SecRel_4", ")", ".", "Case", "(", "\"secidx\"", ",", "FK_SecRel_2", ")", ".", "Default", "(", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "X86", "\"dir32\"", "\"secrel32\"", "\"secidx\"" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_decl_end", "(", "void", ")", "{", "if", "(", "init_frag", ".", "offset", ")", "nvptx_assemble_value", "(", "0", ",", "init_frag", ".", "size", "-", "init_frag", ".", "offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "init_frag", ".", "started", "?", "\" };\\n\"", ":", "\";\\n\"", ")", ";", "}", "</s>" ]

[ "Called", "when", "the", "initializer", "for", "a", "decl", "has", "been", "completely", "output", "through", "combinations", "of", "the", "three", "functions", "above", "." ]

[ "nvptx", "0", "\" };\\n\"", "\";\\n\"" ]

[]

[ "<s>", "static", "rtx", "gen_push", "(", "rtx", "arg", ")", "{", "return", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PRE_DEC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ",", "arg", ")", ";", "}", "</s>" ]

[ "Code", "to", "generate", "prologue", "and", "epilogue", "sequences" ]

[ "i386" ]

[]

[ "<s>", "rtx", "ix86_expand_adjust_ufix_to_sfix_si", "(", "rtx", "val", ",", "rtx", "*", "xorp", ")", "{", "REAL_VALUE_TYPE", "TWO31r", ";", "rtx", "two31r", ",", "tmp", "[", "4", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "val", ")", ";", "machine_mode", "scalarmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "machine_mode", "intmode", "=", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", "?", "V8SImode", ":", "V4SImode", ";", "rtx", "(", "*", "cmp", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "tmp", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "real_ldexp", "(", "&", "TWO31r", ",", "&", "dconst1", ",", "31", ")", ";", "two31r", "=", "const_double_from_real_value", "(", "TWO31r", ",", "scalarmode", ")", ";", "two31r", "=", "ix86_build_const_vector", "(", "mode", ",", "1", ",", "two31r", ")", ";", "two31r", "=", "force_reg", "(", "mode", ",", "two31r", ")", ";", "switch", "(", "mode", ")", "{", "case", "V8SFmode", ":", "cmp", "=", "gen_avx_maskcmpv8sf3", ";", "break", ";", "case", "V4SFmode", ":", "cmp", "=", "gen_sse_maskcmpv4sf3", ";", "break", ";", "case", "V4DFmode", ":", "cmp", "=", "gen_avx_maskcmpv4df3", ";", "break", ";", "case", "V2DFmode", ":", "cmp", "=", "gen_sse2_maskcmpv2df3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "[", "3", "]", "=", "gen_rtx_LE", "(", "mode", ",", "two31r", ",", "val", ")", ";", "emit_insn", "(", "cmp", "(", "tmp", "[", "0", "]", ",", "two31r", ",", "val", ",", "tmp", "[", "3", "]", ")", ")", ";", "tmp", "[", "1", "]", "=", "expand_simple_binop", "(", "mode", ",", "AND", ",", "tmp", "[", "0", "]", ",", "two31r", ",", "tmp", "[", "1", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "intmode", "==", "V4SImode", "||", "TARGET_AVX2", ")", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "ASHIFT", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "GEN_INT", "(", "31", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "else", "{", "rtx", "two31", "=", "GEN_INT", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "31", ")", ";", "two31", "=", "ix86_build_const_vector", "(", "intmode", ",", "1", ",", "two31", ")", ";", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "AND", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "two31", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "return", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "val", ",", "tmp", "[", "1", "]", ",", "tmp", "[", "2", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "</s>" ]

[ "Adjust", "a", "V", "*", "SFmode/V", "*", "DFmode", "value", "VAL", "so", "that", "*", "sfix_trunc", "*", "resp", ".", "fix_trunc", "*", "pattern", "can", "be", "used", "on", "it", "instead", "of", "fixuns_trunc", "*", ".", "This", "is", "done", "by", "doing", "just", "signed", "conversion", "if", "<", "0x1p31", ",", "and", "otherwise", "by", "subtracting", "0x1p31", "first", "and", "xoring", "in", "0x80000000", "from", "*", "XORP", "afterwards", "." ]

[ "i386", "4", "32", "0", "3", "31", "1", "3", "0", "3", "1", "0", "1", "0", "0", "31", "0", "1", "31", "1", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "bool", "TMS320C64XAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "outputStream", ")", "{", "llvm_unreachable_internal", "(", "\"Unimplemented func PrintAsmMemoryOperand\"", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X", "TMS320C64X", "\"Unimplemented func PrintAsmMemoryOperand\"" ]

[]

[ "<s>", "const", "Function", "*", "PatmosSPMark", "::", "getCallTarget", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "2", ")", ";", "const", "Function", "*", "Target", "=", "NULL", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "Target", "=", "dyn_cast", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "const", "char", "*", "TargetName", "=", "MO", ".", "getSymbolName", "(", ")", ";", "const", "Module", "*", "M", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getParent", "(", ")", ";", "Target", "=", "M", "->", "getFunction", "(", "TargetName", ")", ";", "}", "return", "Target", ";", "}", "</s>" ]

[ "Return", "the", "target", "of", "the", "underlying", "call", "." ]

[ "Patmos", "Patmos", "2" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "isPredicated", "(", "*", "I", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugInstr", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", ")", "{", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "2", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "*", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "instr_end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "{", "if", "(", "AllowModify", "&&", "!", "isPredicated", "(", "MBB", ".", "back", "(", ")", ")", "&&", "isUncondBranchOpcode", "(", "MBB", ".", "back", "(", ")", ".", "getOpcode", "(", ")", ")", "&&", "TBB", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TBB", ")", ")", "removeBranch", "(", "MBB", ")", ";", "return", "true", ";", "}", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"FBB should have been null.\"", "0", "1", "2" ]

[]

[ "<s>", "SDNode", "*", "PIC16DAGToDAGISel", "::", "Select", "(", "SDValue", "N", ")", "{", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "N", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "uint64_t", "ValSize", "=", "VA", ".", "getValVT", "(", ")", ".", "getFixedSizeInBits", "(", ")", ";", "uint64_t", "LocSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getFixedSizeInBits", "(", ")", ";", "assert", "(", "ValSize", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "LocSize", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "markPhysRegUsed", "(", "PhysReg", ")", ";", "if", "(", "ValSize", "==", "LocSize", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "else", "{", "assert", "(", "ValSize", "<", "LocSize", "&&", "\"Extensions not supported\"", ")", ";", "auto", "PhysRegToVReg", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "LocSize", ")", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "PhysRegToVReg", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"", "\"Extensions not supported\"" ]

[]

[ "<s>", "static", "unsigned", "int", "compute_vrsave_mask", "(", "void", ")", "{", "unsigned", "int", "i", ",", "mask", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "crtl", "->", "calls_eh_return", "&&", "!", "TARGET_ALTIVEC", ")", "mask", "|=", "0xFFF", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "df_regs_ever_live_p", "(", "i", ")", ")", "mask", "|=", "ALTIVEC_REG_BIT", "(", "i", ")", ";", "if", "(", "mask", "==", "0", ")", "return", "mask", ";", "for", "(", "i", "=", "ALTIVEC_ARG_MIN_REG", ";", "i", "<", "(", "unsigned", ")", "crtl", "->", "args", ".", "info", ".", "vregno", ";", "i", "++", ")", "mask", "&=", "~", "ALTIVEC_REG_BIT", "(", "i", ")", ";", "{", "bool", "yes", "=", "false", ";", "diddle_return_value", "(", "is_altivec_return_reg", ",", "&", "yes", ")", ";", "if", "(", "yes", ")", "mask", "&=", "~", "ALTIVEC_REG_BIT", "(", "ALTIVEC_ARG_RETURN", ")", ";", "}", "return", "mask", ";", "}", "</s>" ]

[ "Return", "a", "32-bit", "mask", "of", "the", "AltiVec", "registers", "we", "need", "to", "set", "in", "VRSAVE", ".", "Bit", "n", "of", "the", "return", "value", "is", "1", "if", "Vn", "is", "live", ".", "The", "MSB", "in", "the", "32-bit", "word", "is", "0", "." ]

[ "powerpcspe", "0", "0xFFF", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Post Select Optimizer\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Post Select Optimizer\"" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Wasn't expecting to be able to lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "lowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "lowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "SDLoc", "(", "Op", ")", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Wasn't expecting to be able to lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SETCC", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::VASTART", "PPC", "ISD::VAARG", "PPC", "ISD::VACOPY", "PPC", "ISD::STACKRESTORE", "PPC", "ISD::DYNAMIC_STACKALLOC", "PPC", "ISD::EH_SJLJ_SETJMP", "ISD::EH_SJLJ_LONGJMP", "ISD::LOAD", "ISD::STORE", "ISD::TRUNCATE", "ISD::SELECT_CC", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "ISD::UINT_TO_FP", "ISD::SINT_TO_FP", "ISD::FLT_ROUNDS_", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SCALAR_TO_VECTOR", "ISD::MUL", "ISD::INTRINSIC_W_CHAIN", "ISD::RETURNADDR", "ISD::FRAMEADDR" ]

[]

[ "<s>", "bool", "nds32_naked_function_p", "(", "tree", "func", ")", "{", "tree", "t_naked", ";", "tree", "t_no_prologue", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "abort", "(", ")", ";", "t_naked", "=", "lookup_attribute", "(", "\"naked\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "t_no_prologue", "=", "lookup_attribute", "(", "\"no_prologue\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "(", "(", "t_naked", "!=", "NULL_TREE", ")", "||", "(", "t_no_prologue", "!=", "NULL_TREE", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUNC", "is", "a", "naked", "function", "." ]

[ "nds32", "\"naked\"", "\"no_prologue\"" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "if", "(", "F", ".", "getName", "(", ")", "==", "NVVM_REFLECT_FUNCTION", ")", "{", "assert", "(", "F", ".", "isDeclaration", "(", ")", "&&", "\"_reflect function should not have a body\"", ")", ";", "assert", "(", "F", ".", "getReturnType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"_reflect's return type should be integer\"", ")", ";", "return", "false", ";", "}", "SmallVector", "<", "Instruction", "*", ",", "4", ">", "ToRemove", ";", "for", "(", "Instruction", "&", "I", ":", "instructions", "(", "F", ")", ")", "{", "CallInst", "*", "Call", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "Call", ")", "continue", ";", "Function", "*", "Callee", "=", "Call", "->", "getCalledFunction", "(", ")", ";", "if", "(", "!", "Callee", "||", "(", "Callee", "->", "getName", "(", ")", "!=", "NVVM_REFLECT_FUNCTION", "&&", "Callee", "->", "getIntrinsicID", "(", ")", "!=", "Intrinsic", "::", "nvvm_reflect", ")", ")", "continue", ";", "assert", "(", "Call", "->", "getNumOperands", "(", ")", "==", "2", "&&", "\"Wrong number of operands to __nvvm_reflect function\"", ")", ";", "const", "Value", "*", "Str", "=", "Call", "->", "getArgOperand", "(", "0", ")", ";", "if", "(", "const", "CallInst", "*", "ConvCall", "=", "dyn_cast", "<", "CallInst", ">", "(", "Str", ")", ")", "{", "Str", "=", "ConvCall", "->", "getArgOperand", "(", "0", ")", ";", "}", "assert", "(", "isa", "<", "ConstantExpr", ">", "(", "Str", ")", "&&", "\"Format of __nvvm__reflect function not recognized\"", ")", ";", "const", "ConstantExpr", "*", "GEP", "=", "cast", "<", "ConstantExpr", ">", "(", "Str", ")", ";", "const", "Value", "*", "Sym", "=", "GEP", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "Constant", ">", "(", "Sym", ")", "&&", "\"Format of __nvvm_reflect function not recognized\"", ")", ";", "const", "Value", "*", "Operand", "=", "cast", "<", "Constant", ">", "(", "Sym", ")", "->", "getOperand", "(", "0", ")", ";", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Operand", ")", ")", "{", "assert", "(", "GV", "->", "hasInitializer", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "Constant", "*", "Initializer", "=", "GV", "->", "getInitializer", "(", ")", ";", "Operand", "=", "Initializer", ";", "}", "assert", "(", "isa", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "assert", "(", "cast", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "->", "isCString", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "StringRef", "ReflectArg", "=", "cast", "<", "ConstantDataSequential", ">", "(", "Operand", ")", "->", "getAsString", "(", ")", ";", "ReflectArg", "=", "ReflectArg", ".", "substr", "(", "0", ",", "ReflectArg", ".", "size", "(", ")", "-", "1", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg of _reflect : \"", "<<", "ReflectArg", "<<", "\"\\n\"", ")", ";", "int", "ReflectVal", "=", "0", ";", "if", "(", "ReflectArg", "==", "\"__CUDA_FTZ\"", ")", "{", "if", "(", "auto", "*", "Flag", "=", "mdconst", "::", "extract_or_null", "<", "ConstantInt", ">", "(", "F", ".", "getParent", "(", ")", "->", "getModuleFlag", "(", "\"nvvm-reflect-ftz\"", ")", ")", ")", "ReflectVal", "=", "Flag", "->", "getSExtValue", "(", ")", ";", "}", "else", "if", "(", "ReflectArg", "==", "\"__CUDA_ARCH\"", ")", "{", "ReflectVal", "=", "SmVersion", "*", "10", ";", "}", "Call", "->", "replaceAllUsesWith", "(", "ConstantInt", "::", "get", "(", "Call", "->", "getType", "(", ")", ",", "ReflectVal", ")", ")", ";", "ToRemove", ".", "push_back", "(", "Call", ")", ";", "}", "for", "(", "Instruction", "*", "I", ":", "ToRemove", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "ToRemove", ".", "size", "(", ")", ">", "0", ";", "}", "</s>" ]

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

[ "NVPTX", "\"_reflect function should not have a body\"", "\"_reflect's return type should be integer\"", "4", "Intrinsic::nvvm_reflect", "2", "\"Wrong number of operands to __nvvm_reflect function\"", "0", "0", "\"Format of __nvvm__reflect function not recognized\"", "0", "\"Format of __nvvm_reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "\"Format of _reflect function not recognized\"", "\"Format of _reflect function not recognized\"", "0", "1", "\"Arg of _reflect : \"", "\"\\n\"", "0", "\"__CUDA_FTZ\"", "\"nvvm-reflect-ftz\"", "\"__CUDA_ARCH\"", "10", "0" ]

[]

[ "<s>", "static", "bool", "mips_hard_regno_mode_ok_uncached", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "CCV2mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "2", "==", "0", ")", ";", "if", "(", "mode", "==", "CCV4mode", ")", "return", "(", "ISA_HAS_8CC", "&&", "ST_REG_P", "(", "regno", ")", "&&", "(", "regno", "-", "ST_REG_FIRST", ")", "%", "4", "==", "0", ")", ";", "if", "(", "mode", "==", "CCmode", ")", "return", "ISA_HAS_8CC", "?", "ST_REG_P", "(", "regno", ")", ":", "regno", "==", "FPSW_REGNUM", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "mode", "!=", "CCFmode", "&&", "!", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "1", ")", "==", "0", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "(", "(", "(", "regno", "-", "FP_REG_FIRST", ")", "%", "MAX_FPRS_PER_FMT", ")", "==", "0", "||", "(", "MIN_FPRS_PER_FMT", "==", "1", "&&", "size", "<=", "UNITS_PER_FPREG", ")", ")", ")", "{", "if", "(", "TARGET_O32_FP64A_ABI", "&&", "size", "<=", "4", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", "return", "false", ";", "if", "(", "mode", "==", "CCFmode", ")", "return", "!", "(", "TARGET_FLOATXX", "&&", "(", "regno", "&", "1", ")", "!=", "0", ")", ";", "if", "(", "TARGET_LOONGSON_VECTORS", "&&", "(", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "DImode", ")", ")", "return", "true", ";", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "if", "(", "ACC_REG_P", "(", "regno", ")", "&&", "!", "VECTOR_MODE_P", "(", "mode", ")", "&&", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "||", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", ")", "{", "if", "(", "MD_REG_P", "(", "regno", ")", ")", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", ")", "return", "regno", "==", "(", "size", "<=", "UNITS_PER_WORD", "?", "LO_REGNUM", ":", "MD_REG_FIRST", ")", ";", "}", "else", "{", "if", "(", "size", "<=", "UNITS_PER_WORD", ")", "return", "true", ";", "if", "(", "size", "<=", "UNITS_PER_WORD", "*", "2", "&&", "(", "(", "regno", "-", "DSP_ACC_REG_FIRST", ")", "&", "1", ")", "==", "0", ")", "return", "true", ";", "}", "}", "if", "(", "ALL_COP_REG_P", "(", "regno", ")", ")", "return", "mclass", "==", "MODE_INT", "&&", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "regno", "==", "GOT_VERSION_REGNUM", ")", "return", "mode", "==", "SImode", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "mips_hard_regno_mode_ok", "." ]

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

[]

[ "<s>", "static", "void", "store_reg", "(", "int", "reg", ",", "HOST_WIDE_INT", "disp", ",", "int", "base", ")", "{", "rtx", "insn", ",", "dest", ",", "src", ",", "basereg", ";", "src", "=", "gen_rtx_REG", "(", "word_mode", ",", "reg", ")", ";", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "if", "(", "VAL_14_BITS_P", "(", "disp", ")", ")", "{", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "basereg", ",", "disp", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", "&&", "!", "VAL_32_BITS_P", "(", "disp", ")", ")", "{", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "delta", ")", ";", "insn", "=", "emit_move_insn", "(", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "tmpreg", ",", "basereg", ")", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "tmpreg", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "delta", ")", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "tmpreg", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "}", "else", "{", "rtx", "delta", "=", "GEN_INT", "(", "disp", ")", ";", "rtx", "high", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "basereg", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "delta", ")", ")", ";", "rtx", "tmpreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "tmpreg", ",", "high", ")", ";", "dest", "=", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "tmpreg", ",", "delta", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "dest", ",", "src", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "{", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "word_mode", ",", "gen_rtx_PLUS", "(", "word_mode", ",", "basereg", ",", "delta", ")", ")", ",", "src", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "}", "if", "(", "DO_FRAME_NOTES", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "store", "REG", "at", "the", "memory", "location", "specified", "by", "BASE+DISP", ".", "Handle", "case", "where", "DISP", ">", "8k", "by", "using", "the", "add_high_const", "patterns", ".", "Note", "in", "DISP", ">", "8k", "case", ",", "we", "will", "leave", "the", "high", "part", "of", "the", "address", "in", "%", "r1", ".", "There", "is", "code", "in", "expand_hppa_", "{", "prologue", ",", "epilogue", "}", "that", "knows", "this", "." ]

[ "pa", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "ft32_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "type", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "true", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "size", ">", "4", "*", "6", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "function", "argument", "described", "by", "TYPE", "is", "to", "be", "passed", "by", "reference", "." ]

[ "ft32", "4", "6" ]

[]

[ "<s>", "static", "int", "cris_address_cost", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "cris_base_or_autoincr_p", "(", "x", ",", "false", ")", ")", "return", "0", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "return", "(", "2", "+", "4", ")", "/", "2", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "2", "+", "4", ")", "/", "2", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "tem1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "tem2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "tem1", ")", "&&", "GET_CODE", "(", "tem1", ")", "!=", "MULT", ")", "tem1", "=", "tem2", ",", "tem2", "=", "XEXP", "(", "x", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "tem1", ")", "||", "GET_CODE", "(", "tem1", ")", "==", "MULT", ")", ";", "if", "(", "(", "GET_CODE", "(", "tem1", ")", "==", "MULT", "&&", "cris_biap_index_p", "(", "tem1", ",", "false", ")", ")", "||", "REG_P", "(", "tem2", ")", ")", "return", "2", "/", "2", ";", "if", "(", "CONST_INT_P", "(", "tem2", ")", "&&", "INTVAL", "(", "tem2", ")", "<", "128", "&&", "INTVAL", "(", "tem2", ")", ">=", "-", "128", ")", "return", "2", "/", "2", ";", "if", "(", "satisfies_constraint_L", "(", "tem2", ")", ")", "return", "(", "2", "+", "2", ")", "/", "2", ";", "if", "(", "CONSTANT_P", "(", "tem2", ")", ")", "return", "(", "2", "+", "2", "+", "2", ")", "/", "2", ";", "return", "(", "2", "+", "2", "+", "2", ")", "/", "2", ";", "}", "return", "10", ";", "}", "</s>" ]

[ "The", "ADDRESS_COST", "worker", "." ]

[ "cris", "0", "2", "4", "2", "2", "4", "2", "0", "1", "0", "2", "2", "128", "128", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "2", "10" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "SVT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "SVT", ")", "||", "isSHUFPMask", "(", "M", ",", "SVT", ")", "||", "isPSHUFDMask", "(", "M", ",", "SVT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isPSHUFLWMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isPALIGNRMask", "(", "M", ",", "SVT", ",", "Subtarget", ")", "||", "isUNPCKLMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKHMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "64", "2", "0" ]

[]

[ "<s>", "void", "riscv_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"floatAbi\"", ",", "riscv_d_handle_target_float_abi", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_REGISTER_CPU_TARGET_INFO", "." ]

[ "riscv", "\"floatAbi\"" ]

[]

[ "<s>", "static", "rtx", "aarch64_expand_sve_const_vector_sel", "(", "rtx", "target", ",", "rtx", "src", ")", "{", "gcc_assert", "(", "CONST_VECTOR_NELTS_PER_PATTERN", "(", "src", ")", "==", "2", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "machine_mode", "pred_mode", "=", "aarch64_sve_pred_mode", "(", "mode", ")", ";", "unsigned", "int", "npatterns", "=", "CONST_VECTOR_NPATTERNS", "(", "src", ")", ";", "if", "(", "aarch64_svpattern_for_vl", "(", "pred_mode", ",", "npatterns", ")", "==", "AARCH64_NUM_SVPATTERNS", ")", "return", "NULL_RTX", ";", "rtx_vector_builder", "pred_builder", "(", "pred_mode", ",", "npatterns", ",", "2", ")", ";", "rtx_vector_builder", "true_builder", "(", "mode", ",", "npatterns", ",", "1", ")", ";", "rtx_vector_builder", "false_builder", "(", "mode", ",", "npatterns", ",", "1", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "npatterns", ";", "++", "i", ")", "{", "true_builder", ".", "quick_push", "(", "CONST_VECTOR_ENCODED_ELT", "(", "src", ",", "i", ")", ")", ";", "pred_builder", ".", "quick_push", "(", "CONST1_RTX", "(", "BImode", ")", ")", ";", "}", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "npatterns", ";", "++", "i", ")", "{", "false_builder", ".", "quick_push", "(", "CONST_VECTOR_ENCODED_ELT", "(", "src", ",", "i", "+", "npatterns", ")", ")", ";", "pred_builder", ".", "quick_push", "(", "CONST0_RTX", "(", "BImode", ")", ")", ";", "}", "expand_operand", "ops", "[", "4", "]", ";", "create_output_operand", "(", "&", "ops", "[", "0", "]", ",", "target", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "1", "]", ",", "true_builder", ".", "build", "(", ")", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "2", "]", ",", "false_builder", ".", "build", "(", ")", ",", "mode", ")", ";", "create_input_operand", "(", "&", "ops", "[", "3", "]", ",", "pred_builder", ".", "build", "(", ")", ",", "pred_mode", ")", ";", "expand_insn", "(", "code_for_vcond_mask", "(", "mode", ",", "mode", ")", ",", "4", ",", "ops", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "SRC", "is", "an", "SVE", "CONST_VECTOR", "that", "contains", "N", "``", "foreground", "''", "values", "followed", "by", "N", "``", "background", "''", "values", ".", "Try", "to", "move", "it", "into", "TARGET", "using", ":", "PTRUE", "PRED.", "<", "T", ">", ",", "VL", "<", "N", ">", "MOV", "TRUE.", "<", "T", ">", ",", "#", "<", "foreground", ">", "MOV", "FALSE.", "<", "T", ">", ",", "#", "<", "background", ">", "SEL", "TARGET.", "<", "T", ">", ",", "PRED.", "<", "T", ">", ",", "TRUE.", "<", "T", ">", ",", "FALSE.", "<", "T", ">", "The", "PTRUE", "is", "always", "a", "single", "instruction", "but", "the", "MOVs", "might", "need", "a", "longer", "sequence", ".", "If", "the", "background", "value", "is", "zero", "(", "as", "it", "often", "is", ")", ",", "the", "sequence", "can", "sometimes", "collapse", "to", "a", "PTRUE", "followed", "by", "a", "zero-predicated", "move", ".", "Return", "the", "target", "on", "success", ",", "otherwise", "return", "null", "." ]

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

[]

[ "<s>", "bool", "hasNullExportTarget", "(", ")", "const", "{", "return", "!", "GFX11Insts", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "'s", "EXP", "instruction", "supports", "the", "NULL", "export", "target", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasAVX512", "(", ")", "||", "ST", ".", "hasFastPartialYMMWrite", "(", ")", ")", "return", "false", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "IsX86INTR", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_INTR", ";", "bool", "FnHasLiveInYmm", "=", "checkFnHasLiveInYmm", "(", "MRI", ")", ";", "bool", "YMMUsed", "=", "FnHasLiveInYmm", ";", "if", "(", "!", "YMMUsed", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MBB", ")", ";", "if", "(", "FnHasLiveInYmm", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

[ "<s>", "static", "void", "make_cpu_type_builtin", "(", "const", "char", "*", "name", ",", "int", "code", ",", "enum", "ix86_builtin_func_type", "ftype", ",", "bool", "is_const", ")", "{", "tree", "decl", ";", "tree", "type", ";", "type", "=", "ix86_get_builtin_func_type", "(", "ftype", ")", ";", "decl", "=", "add_builtin_function", "(", "name", ",", "type", ",", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "gcc_assert", "(", "decl", "!=", "NULL_TREE", ")", ";", "ix86_builtins", "[", "(", "int", ")", "code", "]", "=", "decl", ";", "TREE_READONLY", "(", "decl", ")", "=", "is_const", ";", "}", "</s>" ]

[ "Make", "builtins", "to", "detect", "cpu", "type", "and", "features", "supported", ".", "NAME", "is", "the", "builtin", "name", ",", "CODE", "is", "the", "builtin", "code", ",", "and", "FTYPE", "is", "the", "function", "type", "of", "the", "builtin", "." ]

[ "i386" ]

[]

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

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

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

[]

[ "<s>", "bool", "XCoreFrameInfo", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "AtStart", "=", "MI", "==", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "BeforeI", "=", "MI", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "it", "->", "getReg", "(", ")", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "if", "(", "AtStart", ")", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "MI", "=", "BeforeI", ";", "++", "MI", ";", "}", "}", "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", "(", ")", "." ]

[ "XCore", "XCore", "\"loadRegFromStackSlot didn't insert any code!\"" ]

[]

[ "<s>", "static", "bool", "mep_get_move_insn", "(", "int", "intrinsic", ",", "const", "struct", "cgen_insn", "*", "*", "cgen_insn", ")", "{", "size_t", "i", ";", "if", "(", "intrinsic", "==", "mep_cmov", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mep_cmov_insns", ")", ";", "i", "++", ")", "if", "(", "mep_get_intrinsic_insn", "(", "mep_cmov_insns", "[", "i", "]", ",", "cgen_insn", ")", ")", "return", "true", ";", "return", "false", ";", "}", "return", "mep_get_intrinsic_insn", "(", "intrinsic", ",", "cgen_insn", ")", ";", "}", "</s>" ]

[ "Like", "mep_get_intrinsic_insn", ",", "but", "with", "extra", "handling", "for", "moves", ".", "If", "INTRINSIC", "is", "mep_cmov", ",", "but", "there", "is", "no", "pure", "CR", "<", "-", "CR", "move", "insn", ",", "try", "using", "a", "work-alike", "instead", ".", "In", "this", "case", ",", "the", "returned", "insn", "may", "have", "three", "operands", "rather", "than", "two", "." ]

[ "mep", "0" ]

[]

[ "<s>", "bool", "F2003fPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createF2003fISelDag", "(", "getF2003fTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003f", "F2003f" ]

[]

[ "<s>", "void", "rs6000_secondary_reload_gpr", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "scratch", ",", "bool", "store_p", ")", "{", "int", "regno", "=", "true_regnum", "(", "reg", ")", ";", "enum", "reg_class", "rclass", ";", "rtx", "addr", ";", "rtx", "scratch_or_premodify", "=", "scratch", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", ",", "store_p", "?", "\"store\"", ":", "\"load\"", ")", ";", "fprintf", "(", "stderr", ",", "\"reg:\\n\"", ")", ";", "debug_rtx", "(", "reg", ")", ";", "fprintf", "(", "stderr", ",", "\"mem:\\n\"", ")", ";", "debug_rtx", "(", "mem", ")", ";", "fprintf", "(", "stderr", ",", "\"scratch:\\n\"", ")", ";", "debug_rtx", "(", "scratch", ")", ";", "}", "gcc_assert", "(", "regno", ">=", "0", "&&", "HARD_REGISTER_NUM_P", "(", "regno", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "rclass", "=", "REGNO_REG_CLASS", "(", "regno", ")", ";", "gcc_assert", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "BASE_REGS", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_MODIFY", ")", "{", "gcc_assert", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "PLUS", "&&", "XEXP", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", "==", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "scratch_or_premodify", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", ";", "rs6000_emit_move", "(", "scratch_or_premodify", ",", "addr", ",", "Pmode", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "scratch_or_premodify", ")", ";", "if", "(", "store_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "return", ";", "}", "</s>" ]

[ "Convert", "reloads", "involving", "64-bit", "gprs", "and", "misaligned", "offset", "addressing", ",", "or", "multiple", "32-bit", "gprs", "and", "offsets", "that", "are", "too", "large", ",", "to", "use", "indirect", "addressing", "." ]

[ "rs6000", "\"\\nrs6000_secondary_reload_gpr, type = %s\\n\"", "\"store\"", "\"load\"", "\"reg:\\n\"", "\"mem:\\n\"", "\"scratch:\\n\"", "0", "0", "0", "1", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "ValueMapping", "*", "AMDGPURegisterBankInfo", "::", "getValueMappingForPtr", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "Register", "PtrReg", ")", "const", "{", "LLT", "PtrTy", "=", "MRI", ".", "getType", "(", "PtrReg", ")", ";", "unsigned", "Size", "=", "PtrTy", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Subtarget", ".", "useFlatForGlobal", "(", ")", "||", "!", "SITargetLowering", "::", "isFlatGlobalAddrSpace", "(", "PtrTy", ".", "getAddressSpace", "(", ")", ")", ")", "return", "AMDGPU", "::", "getValueMapping", "(", "AMDGPU", "::", "VGPRRegBankID", ",", "Size", ")", ";", "const", "RegisterBank", "*", "PtrBank", "=", "getRegBank", "(", "PtrReg", ",", "MRI", ",", "*", "TRI", ")", ";", "return", "AMDGPU", "::", "getValueMapping", "(", "PtrBank", "->", "getID", "(", ")", ",", "Size", ")", ";", "}", "</s>" ]

[ "Return", "the", "mapping", "for", "a", "pointer", "argument", "." ]

[ "AMDGPU", "AMDGPU", "SI", "AMDGPU::getValueMapping", "AMDGPU::VGPRRegBankID", "AMDGPU::getValueMapping" ]

[]

[ "<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", ")", ";", "assert", "(", "SrcReg", "!=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", "&&", "SrcReg", "!=", "MFI", "->", "getFrameOffsetReg", "(", ")", "&&", "SrcReg", "!=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ";", "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", ")", ";", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "1", ")", ";", "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", "1", "AMDGPU::M0", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", "AMDGPU::KILL", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "static", "rtx", "mn10300_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", ")", "{", "rtx", "rv", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "!", "POINTER_TYPE_P", "(", "valtype", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_DATA_REGNUM", ")", ";", "else", "if", "(", "!", "TARGET_PTR_A0D0", "||", "!", "outgoing", "||", "cfun", "->", "returns_struct", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FIRST_ADDRESS_REGNUM", ")", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "FIRST_ADDRESS_REGNUM", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "FIRST_DATA_REGNUM", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "rv", ";", "}", "</s>" ]

[ "Return", "the", "location", "of", "the", "function", "'s", "value", ".", "This", "will", "be", "either", "$", "d0", "for", "integer", "functions", ",", "$", "a0", "for", "pointers", ",", "or", "a", "PARALLEL", "of", "both", "$", "d0", "and", "$", "a0", "if", "the", "-mreturn-pointer-on-do", "flag", "is", "set", ".", "Note", "that", "we", "only", "return", "the", "PARALLEL", "for", "outgoing", "values", ";", "we", "do", "not", "want", "callers", "relying", "on", "this", "extra", "copy", "." ]

[ "mn10300", "2", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "const", "Z80Subtarget", "*", "Z80TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "Z80Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "\"target-cpu\"", "\"target-features\"", "512", "Z80" ]

[]

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

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

[ "ARC", "ARC" ]

[]

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

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

[ "TLCS900", "TLCS900", "0" ]

[]

[ "<s>", "static", "void", "s390_init_frame_layout", "(", "void", ")", "{", "HOST_WIDE_INT", "frame_size", ";", "int", "base_used", ";", "int", "clobbered_regs", "[", "16", "]", ";", "if", "(", "!", "TARGET_CPU_ZARCH", ")", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "true", ";", "do", "{", "frame_size", "=", "cfun_frame_layout", ".", "frame_size", ";", "base_used", "=", "cfun", "->", "machine", "->", "split_branches_pending_p", "||", "current_function_uses_const_pool", "||", "(", "!", "DISP_IN_RANGE", "(", "-", "frame_size", ")", "&&", "!", "CONST_OK_FOR_K", "(", "-", "frame_size", ")", ")", ";", "if", "(", "!", "base_used", ")", "cfun", "->", "machine", "->", "base_reg", "=", "NULL_RTX", ";", "else", "if", "(", "current_function_is_leaf", "&&", "!", "regs_ever_live", "[", "5", "]", ")", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "5", ")", ";", "else", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "BASE_REGNUM", ")", ";", "s390_register_info", "(", "clobbered_regs", ")", ";", "s390_frame_info", "(", ")", ";", "}", "while", "(", "frame_size", "!=", "cfun_frame_layout", ".", "frame_size", ")", ";", "}", "</s>" ]

[ "Generate", "frame", "layout", ".", "Fills", "in", "register", "and", "frame", "data", "for", "the", "current", "function", "in", "cfun-", ">", "machine", ".", "This", "routine", "can", "be", "called", "multiple", "times", ";", "it", "will", "re-do", "the", "complete", "frame", "layout", "every", "time", "." ]

[ "s390", "16", "5", "5" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Indirect Thunks\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Indirect Thunks\"" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "AttributeSet", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "ForCodeSize", "=", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

[ "<s>", "void", "PPCSubtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "Policy", ".", "ShouldTrackPressure", "=", "true", ";", "}", "</s>" ]

[ "Override", "generic", "scheduling", "policy", "within", "a", "region", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "bool", "IsLP64", ",", "bool", "UseLEA", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", ";", "if", "(", "UseLEA", ")", "Opc", "=", "getLEArOpcode", "(", "IsLP64", ")", ";", "else", "Opc", "=", "isSub", "?", "getSUBriOpcode", "(", "IsLP64", ",", "Offset", ")", ":", "getADDriOpcode", "(", "IsLP64", ",", "Offset", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstr", "*", "MI", "=", "NULL", ";", "if", "(", "UseLEA", ")", "{", "MI", "=", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "StackPtr", ",", "false", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ")", ";", "}", "else", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "1LL", "31", "1", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r", "3" ]

[]

[ "<s>", "const", "uint32_t", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_RegMask", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin64_Altivec_RegMask", ":", "CSR_Darwin64_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_Darwin32_Altivec_RegMask", ":", "CSR_Darwin32_RegMask", ")", ";", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "{", "assert", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "\"Altivec is not implemented on AIX yet.\"", ")", ";", "return", "TM", ".", "isPPC64", "(", ")", "?", "CSR_AIX64_RegMask", ":", "CSR_AIX32_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "{", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR64_ColdCC_Altivec_RegMask", ":", "CSR_SVR64_ColdCC_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR32_ColdCC_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR32_ColdCC_SPE_RegMask", ":", "CSR_SVR32_ColdCC_RegMask", ")", ")", ";", "}", "return", "TM", ".", "isPPC64", "(", ")", "?", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR464_Altivec_RegMask", ":", "CSR_SVR464_RegMask", ")", ":", "(", "Subtarget", ".", "hasAltivec", "(", ")", "?", "CSR_SVR432_Altivec_RegMask", ":", "(", "Subtarget", ".", "hasSPE", "(", ")", "?", "CSR_SVR432_SPE_RegMask", ":", "CSR_SVR432_RegMask", ")", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"Altivec is not implemented on AIX yet.\"", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "LW", ")", ")", ".", "addReg", "(", "Mips", "::", "RA", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "NumBytes", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::ADDu", "Mips::SP", "Mips::FP", "Mips::ZERO", "Mips::LW", "Mips::FP", "Mips::SP", "Mips::LW", "Mips::RA", "Mips::SP", "Mips::ADDiu", "Mips::SP", "Mips::SP" ]

[]

[ "<s>", "static", "void", "arm_elf_asm_destructor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "arm_elf_asm_cdtor", "(", "symbol", ",", "priority", ",", "false", ")", ";", "}", "</s>" ]

[ "Add", "a", "function", "to", "the", "list", "of", "static", "destructors", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "SparcTargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isTargetLinux", "(", ")", ")", "return", "TargetLowering", "::", "useLoadStackGuardNode", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "arc_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "rtx", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "int", "flags", "=", "SYMBOL_REF_FLAGS", "(", "symbol", ")", ";", "tree", "attr", "=", "(", "TREE_TYPE", "(", "decl", ")", "!=", "error_mark_node", "?", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ":", "NULL_TREE", ")", ";", "tree", "long_call_attr", "=", "lookup_attribute", "(", "\"long_call\"", ",", "attr", ")", ";", "tree", "medium_call_attr", "=", "lookup_attribute", "(", "\"medium_call\"", ",", "attr", ")", ";", "tree", "short_call_attr", "=", "lookup_attribute", "(", "\"short_call\"", ",", "attr", ")", ";", "if", "(", "long_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_LONG_CALL", ";", "else", "if", "(", "medium_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_MEDIUM_CALL", ";", "else", "if", "(", "short_call_attr", "!=", "NULL_TREE", ")", "flags", "|=", "SYMBOL_FLAG_SHORT_CALL", ";", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "=", "flags", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_ENCODE_SECTION_INFO", "hook", "." ]

[ "arc", "0", "\"long_call\"", "\"medium_call\"", "\"short_call\"" ]

[]

[ "<s>", "TargetPassConfig", "*", "PPCTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "TargetPassConfig", "*", "PassConfig", "=", "new", "PPCPassConfig", "(", "this", ",", "PM", ")", ";", "PassConfig", "->", "setEnableTailMerge", "(", "false", ")", ";", "return", "PassConfig", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isExtractSubvectorCheap", "(", "EVT", "ResVT", ",", "EVT", "SrcVT", ",", "unsigned", "Index", ")", "const", "{", "if", "(", "!", "isOperationLegalOrCustom", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "ResVT", ")", ")", "return", "false", ";", "return", "(", "Index", "==", "0", "||", "Index", "==", "ResVT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "EXTRACT_SUBVECTOR", "is", "cheap", "for", "this", "result", "type", "with", "this", "index", "." ]

[ "AArch64", "AArch64", "ISD::EXTRACT_SUBVECTOR", "0" ]

[]

[ "<s>", "bool", "isValid", "(", ")", "const", "{", "return", "State", "!=", "Uninitialized", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "RISCV" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "RISCV", "::", "GPRRegClass", ";", "if", "(", "!", "isInt", "<", "11", ">", "(", "MFI", ".", "estimateStackSize", "(", "MF", ")", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlign", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "}", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::GPRRegClass", "11" ]

[]

[ "<s>", "static", "bool", "pa_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "return", "tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "pa" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "FSGNJ_S", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "auto", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__memory_base\"", ")", "==", "0", "||", "strcmp", "(", "Name", ",", "\"__table_base\"", ")", "==", "0", ")", "{", "bool", "Mutable", "=", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "Mutable", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "getLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "\"__memory_base\"", "0", "\"__table_base\"", "0", "\"__stack_pointer\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "void", "h8300_init_once", "(", "void", ")", "{", "static", "const", "char", "*", "const", "h8_push_ops", "[", "2", "]", "=", "{", "\"push\"", ",", "\"push.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_pop_ops", "[", "2", "]", "=", "{", "\"pop\"", ",", "\"pop.l\"", "}", ";", "static", "const", "char", "*", "const", "h8_mov_ops", "[", "2", "]", "=", "{", "\"mov.w\"", ",", "\"mov.l\"", "}", ";", "if", "(", "TARGET_H8300", ")", "{", "cpu_type", "=", "(", "int", ")", "CPU_H8300", ";", "h8_reg_names", "=", "names_big", ";", "}", "else", "{", "cpu_type", "=", "(", "int", ")", "CPU_H8300H", ";", "h8_reg_names", "=", "names_extended", ";", "}", "h8_push_op", "=", "h8_push_ops", "[", "cpu_type", "]", ";", "h8_pop_op", "=", "h8_pop_ops", "[", "cpu_type", "]", ";", "h8_mov_op", "=", "h8_mov_ops", "[", "cpu_type", "]", ";", "if", "(", "!", "TARGET_H8300S", "&&", "TARGET_MAC", ")", "{", "error", "(", "\"-ms2600 is used without -ms\"", ")", ";", "target_flags", "|=", "MASK_H8300S_1", ";", "}", "if", "(", "TARGET_H8300", "&&", "TARGET_NORMAL_MODE", ")", "{", "error", "(", "\"-mn is used without -mh or -ms\"", ")", ";", "target_flags", "^=", "MASK_NORMAL_MODE", ";", "}", "if", "(", "optimize_size", ")", "{", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "13", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "13", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "13", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "5", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "6", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "13", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_S", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "14", "]", "=", "SHIFT_LOOP", ";", "}", "if", "(", "!", "TARGET_H8300SX", ")", "{", "h8300_move_ratio", "=", "3", ";", "}", "else", "if", "(", "flag_omit_frame_pointer", ")", "{", "h8300_move_ratio", "=", "4", ";", "}", "else", "if", "(", "optimize_size", ")", "{", "h8300_move_ratio", "=", "4", ";", "}", "else", "{", "h8300_move_ratio", "=", "6", ";", "}", "}", "</s>" ]

[ "Initialize", "various", "cpu", "specific", "globals", "at", "start", "up", "." ]

[ "h8300", "2", "\"push\"", "\"push.l\"", "2", "\"pop\"", "\"pop.l\"", "2", "\"mov.w\"", "\"mov.l\"", "\"-ms2600 is used without -ms\"", "\"-mn is used without -mh or -ms\"", "5", "6", "13", "14", "13", "14", "13", "14", "5", "6", "5", "6", "5", "6", "13", "14", "14", "3", "4", "4", "6" ]

[]

[ "<s>", "void", "mn10300_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "POST_INC", ":", "mn10300_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fputc", "(", "'+'", ",", "file", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "mn10300_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "fputc", "(", "'+'", ",", "file", ")", ";", "fputc", "(", "','", ",", "file", ")", ";", "mn10300_print_operand", "(", "file", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "break", ";", "case", "REG", ":", "mn10300_print_operand", "(", "file", ",", "addr", ",", "0", ")", ";", "break", ";", "case", "PLUS", ":", "{", "rtx", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "index", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "REG_P", "(", "index", ")", "&&", "!", "REG_OK_FOR_INDEX_P", "(", "index", ")", ")", "{", "rtx", "x", "=", "base", ";", "base", "=", "index", ";", "index", "=", "x", ";", "gcc_assert", "(", "REG_P", "(", "index", ")", "&&", "REG_OK_FOR_INDEX_P", "(", "index", ")", ")", ";", "}", "gcc_assert", "(", "REG_OK_FOR_BASE_P", "(", "base", ")", ")", ";", "mn10300_print_operand", "(", "file", ",", "index", ",", "0", ")", ";", "fputc", "(", "','", ",", "file", ")", ";", "mn10300_print_operand", "(", "file", ",", "base", ",", "0", ")", ";", "break", ";", "}", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "addr", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Output", "assembly", "language", "output", "for", "the", "address", "ADDR", "to", "FILE", "." ]

[ "mn10300", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "FunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "SIFixVGPRCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY", ":", "if", "(", "TII", "->", "isVGPRCopy", "(", "MI", ")", "&&", "!", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "MI", ".", "addOperand", "(", "MF", ",", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "EXEC", ",", "false", ",", "true", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Add exec use to \"", "<<", "MI", ")", ";", "Changed", "=", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::EXEC", "\"Add exec use to \"" ]

[]

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

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

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

[]

[ "<s>", "virtual", "bool", "addPreISel", "(", ")", "{", "if", "(", "PatmosSinglePathInfo", "::", "isEnabled", "(", ")", ")", "{", "addPass", "(", "createUnifyFunctionExitNodesPass", "(", ")", ")", ";", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "addPass", "(", "createPatmosSPClonePass", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "void", "HexagonDCE", "::", "removeOperand", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ",", "unsigned", "OpNum", ")", "{", "MachineInstr", "*", "MI", "=", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ";", "auto", "getOpNum", "=", "[", "MI", "]", "(", "MachineOperand", "&", "Op", ")", "->", "unsigned", "{", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "n", ";", "++", "i", ")", "if", "(", "&", "MI", "->", "getOperand", "(", "i", ")", "==", "&", "Op", ")", "return", "i", ";", "llvm_unreachable", "(", "\"Invalid operand\"", ")", ";", "}", ";", "DenseMap", "<", "NodeId", ",", "unsigned", ">", "OpMap", ";", "NodeList", "Refs", "=", "IA", ".", "Addr", "->", "members", "(", "getDFG", "(", ")", ")", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "Refs", ")", "OpMap", ".", "insert", "(", "std", "::", "make_pair", "(", "RA", ".", "Id", ",", "getOpNum", "(", "RA", ".", "Addr", "->", "getOp", "(", ")", ")", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "OpNum", ")", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "Refs", ")", "{", "unsigned", "N", "=", "OpMap", "[", "RA", ".", "Id", "]", ";", "if", "(", "N", "<", "OpNum", ")", "RA", ".", "Addr", "->", "setRegRef", "(", "&", "MI", "->", "getOperand", "(", "N", ")", ")", ";", "else", "if", "(", "N", ">", "OpNum", ")", "RA", ".", "Addr", "->", "setRegRef", "(", "&", "MI", "->", "getOperand", "(", "N", "-", "1", ")", ")", ";", "}", "}", "</s>" ]

[ "Erase", "an", "operand", "from", "an", "instruction", ",", "leaving", "it", "with", "one", "fewer", "operand", "than", "it", "started", "with", "." ]

[ "Hexagon", "Hexagon", "0", "\"Invalid operand\"", "1" ]

[]

[ "<s>", "EVT", "TeakTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", ",", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i40", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Teak", "Teak", "MVT::i40" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isFPImmLegal", "(", "const", "APFloat", "&", "Imm", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Imm", ".", "isPosZero", "(", ")", "&&", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "f32", "||", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Legal \"", "<<", "VT", ".", "getEVTString", "(", ")", "<<", "\" imm value: 0\\n\"", ")", ";", "return", "true", ";", "}", "bool", "IsLegal", "=", "false", ";", "SmallString", "<", "128", ">", "ImmStrVal", ";", "Imm", ".", "toString", "(", "ImmStrVal", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP64Imm", "(", "Imm", ")", "!=", "-", "1", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP32Imm", "(", "Imm", ")", "!=", "-", "1", ";", "else", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "IsLegal", "=", "AArch64_AM", "::", "getFP16Imm", "(", "Imm", ")", "!=", "-", "1", ";", "if", "(", "IsLegal", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Legal \"", "<<", "VT", ".", "getEVTString", "(", ")", "<<", "\" imm value: \"", "<<", "ImmStrVal", "<<", "\"\\n\"", ")", ";", "return", "true", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Illegal \"", "<<", "VT", ".", "getEVTString", "(", ")", "<<", "\" imm value: \"", "<<", "ImmStrVal", "<<", "\"\\n\"", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "MVT::f64", "MVT::f32", "MVT::f16", "\"Legal \"", "\" imm value: 0\\n\"", "128", "MVT::f64", "AArch64_AM::getFP64Imm", "1", "MVT::f32", "AArch64_AM::getFP32Imm", "1", "MVT::f16", "AArch64_AM::getFP16Imm", "1", "\"Legal \"", "\" imm value: \"", "\"\\n\"", "\"Illegal \"", "\" imm value: \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "getRegAllocationHints", "(", "Register", "VirtReg", ",", "ArrayRef", "<", "MCPhysReg", ">", "Order", ",", "SmallVectorImpl", "<", "MCPhysReg", ">", "&", "Hints", ",", "const", "MachineFunction", "&", "MF", ",", "const", "VirtRegMap", "*", "VRM", ",", "const", "LiveRegMatrix", "*", "Matrix", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "std", "::", "pair", "<", "Register", ",", "Register", ">", "Hint", "=", "MRI", ".", "getRegAllocationHint", "(", "VirtReg", ")", ";", "unsigned", "Odd", ";", "switch", "(", "Hint", ".", "first", ")", "{", "case", "ARMRI", "::", "RegPairEven", ":", "Odd", "=", "0", ";", "break", ";", "case", "ARMRI", "::", "RegPairOdd", ":", "Odd", "=", "1", ";", "break", ";", "default", ":", "TargetRegisterInfo", "::", "getRegAllocationHints", "(", "VirtReg", ",", "Order", ",", "Hints", ",", "MF", ",", "VRM", ")", ";", "return", "false", ";", "}", "Register", "Paired", "=", "Hint", ".", "second", ";", "if", "(", "!", "Paired", ")", "return", "false", ";", "Register", "PairedPhys", ";", "if", "(", "Paired", ".", "isPhysical", "(", ")", ")", "{", "PairedPhys", "=", "Paired", ";", "}", "else", "if", "(", "VRM", "&&", "VRM", "->", "hasPhys", "(", "Paired", ")", ")", "{", "PairedPhys", "=", "getPairedGPR", "(", "VRM", "->", "getPhys", "(", "Paired", ")", ",", "Odd", ",", "this", ")", ";", "}", "if", "(", "PairedPhys", "&&", "is_contained", "(", "Order", ",", "PairedPhys", ")", ")", "Hints", ".", "push_back", "(", "PairedPhys", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "Order", ")", "{", "if", "(", "Reg", "==", "PairedPhys", "||", "(", "getEncodingValue", "(", "Reg", ")", "&", "1", ")", "!=", "Odd", ")", "continue", ";", "MCPhysReg", "Paired", "=", "getPairedGPR", "(", "Reg", ",", "!", "Odd", ",", "this", ")", ";", "if", "(", "!", "Paired", "||", "MRI", ".", "isReserved", "(", "Paired", ")", ")", "continue", ";", "Hints", ".", "push_back", "(", "Reg", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "'hint", "'", "registers", "that", "the", "register", "allocator", "should", "try", "first", "when", "allocating", "a", "physical", "register", "for", "the", "virtual", "register", "VirtReg", "." ]

[ "ARM", "ARM", "ARMRI::RegPairEven", "0", "ARMRI::RegPairOdd", "1", "1" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "function_expander", "::", "add_integer_operand", "(", "HOST_WIDE_INT", "x", ")", "{", "m_ops", ".", "safe_grow", "(", "m_ops", ".", "length", "(", ")", "+", "1", ")", ";", "create_integer_operand", "(", "&", "m_ops", ".", "last", "(", ")", ",", "x", ")", ";", "}", "</s>" ]

[ "Add", "an", "integer", "operand", "X", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "unsigned", "AlphaRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasFP", "(", "MF", ")", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::R15", "Alpha::R30" ]

[]

[ "<s>", "int", "pru_get_ctable_base_offset", "(", "unsigned", "HOST_WIDE_INT", "caddr", ")", "{", "int", "i", ";", "i", "=", "pru_get_ctable_base_index", "(", "caddr", ")", ";", "gcc_assert", "(", "i", ">=", "0", ")", ";", "return", "caddr", "-", "pru_ctable", "[", "i", "]", ".", "base", ";", "}", "</s>" ]

[ "Return", "the", "offset", "from", "some", "CTABLE", "base", "for", "this", "address", "." ]

[ "pru", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "rs6000_frame_related", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "val", ",", "rtx", "reg2", ",", "rtx", "repl2", ")", "{", "rtx", "repl", ";", "if", "(", "REGNO", "(", "reg", ")", "==", "STACK_POINTER_REGNUM", ")", "{", "gcc_checking_assert", "(", "val", "==", "0", ")", ";", "repl", "=", "NULL_RTX", ";", "}", "else", "repl", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ",", "GEN_INT", "(", "val", ")", ")", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "!", "repl", "&&", "!", "reg2", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "!", "REG_P", "(", "SET_SRC", "(", "set", ")", ")", "||", "!", "fixed_reg_p", "(", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "set_used_flags", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "if", "(", "repl", ")", "pat", "=", "simplify_replace_rtx", "(", "pat", ",", "reg", ",", "repl", ")", ";", "if", "(", "reg2", ")", "pat", "=", "simplify_replace_rtx", "(", "pat", ",", "reg2", ",", "repl2", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "pat", "=", "shallow_copy_rtx", "(", "pat", ")", ";", "XVEC", "(", "pat", ",", "0", ")", "=", "shallow_copy_rtvec", "(", "XVEC", "(", "pat", ",", "0", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "{", "rtx", "set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "if", "(", "repl", ")", "set", "=", "simplify_replace_rtx", "(", "set", ",", "reg", ",", "repl", ")", ";", "if", "(", "reg2", ")", "set", "=", "simplify_replace_rtx", "(", "set", ",", "reg2", ",", "repl2", ")", ";", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", "=", "set", ";", "if", "(", "!", "REG_P", "(", "SET_SRC", "(", "set", ")", ")", "||", "!", "fixed_reg_p", "(", "REGNO", "(", "SET_SRC", "(", "set", ")", ")", ")", ")", "RTX_FRAME_RELATED_P", "(", "set", ")", "=", "1", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "copy_rtx_if_shared", "(", "pat", ")", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Add", "to", "'insn", "'", "a", "note", "which", "is", "PATTERN", "(", "INSN", ")", "but", "with", "REG", "replaced", "with", "(", "plus", ":", "P", "(", "reg", "1", ")", "VAL", ")", ",", "and", "with", "REG2", "replaced", "with", "RREG", "if", "REG2", "is", "not", "NULL", ".", "It", "would", "be", "nice", "if", "dwarf2out_frame_debug_expr", "could", "deduce", "these", "equivalences", "by", "itself", "so", "it", "was", "n't", "necessary", "to", "hold", "its", "hand", "so", "much", ".", "Do", "n't", "be", "tempted", "to", "always", "supply", "d2_f_d_e", "with", "the", "actual", "cfa", "register", ",", "ie", ".", "r31", "when", "we", "are", "using", "a", "hard", "frame", "pointer", ".", "That", "fails", "when", "saving", "regs", "off", "r1", ",", "and", "sched", "moves", "the", "r31", "setup", "past", "the", "reg", "saves", "." ]

[ "powerpcspe", "0", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1" ]

[]

[ "<s>", "BitVector", "TPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "LFSR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "LFSR_NO_CHANGE", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "V_LANE_ID_32", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "V_LANE_ID_16", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "V_LANE_ID_8", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "SP0", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "VP0", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "hasGoyaISA", "(", ")", ")", "{", "Reserved", ".", "set", "(", "TPC", "::", "S31", ")", ";", "}", "Reserved", ".", "set", "(", "TPC", "::", "S32", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "S33", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "S34", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "S35", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "S_LFSR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "TPC", "::", "S_LFSR_NO_CHANGE", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "I0", ")", ";", "Reserved", ".", "set", "(", "TPC", "::", "I1", ")", ";", "const", "Module", "*", "MM", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", ";", "Metadata", "*", "PrintfModule", "=", "MM", "->", "getModuleFlag", "(", "\"tpc-printf\"", ")", ";", "if", "(", "PrintfModule", ")", "{", "Reserved", ".", "set", "(", "TPC", "::", "I2", ")", ";", "MachineInstrBuilder", "MIB", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "MBB", "=", "MF", ".", "getBlockNumbered", "(", "0", ")", ";", "auto", "firstInst", "=", "MF", ".", "getBlockNumbered", "(", "0", ")", "->", "instr_begin", "(", ")", ";", "auto", "FI", "=", "&", "*", "firstInst", ";", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "firstInst", ",", "FI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TPC", "::", "SET_INDX_spu_ip", ")", ",", "TPC", "::", "I2", ")", ".", "addReg", "(", "TPC", "::", "I2", ",", "RegState", "::", "Undef", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "TPC", "::", "SP0", ")", ".", "addImm", "(", "0", ")", ";", "}", "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", "." ]

[ "TPC", "TPC", "TPC::LFSR", "TPC::LFSR_NO_CHANGE", "TPC::V_LANE_ID_32", "TPC::V_LANE_ID_16", "TPC::V_LANE_ID_8", "TPC::SP0", "TPC::VP0", "TPC", "TPC::S31", "TPC::S32", "TPC::S33", "TPC::S34", "TPC::S35", "TPC::S_LFSR", "TPC::S_LFSR_NO_CHANGE", "TPC::I0", "TPC::I1", "\"tpc-printf\"", "TPC::I2", "0", "0", "TPC::SET_INDX_spu_ip", "TPC::I2", "TPC::I2", "0", "31", "0", "TPC::SP0", "0" ]

[]

[ "<s>", "void", "ix86_emit_i387_tanh", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "e1", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "e2", "=", "gen_reg_rtx", "(", "XFmode", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "rtx", "cst2", ",", "tmp", ";", "rtx_code_label", "*", "jump_label", "=", "gen_label_rtx", "(", ")", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_fxamxf2_i387", "(", "scratch", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "op1", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_absxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_negxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_expm1xf2", "(", "e1", ",", "e2", ")", ")", ";", "cst2", "=", "force_reg", "(", "XFmode", ",", "CONST2_RTX", "(", "XFmode", ")", ")", ";", "emit_insn", "(", "gen_addxf3", "(", "e2", ",", "e1", ",", "cst2", ")", ")", ";", "emit_insn", "(", "gen_divxf3", "(", "e2", ",", "e1", ",", "e2", ")", ")", ";", "emit_insn", "(", "gen_testqi_ext_1_ccno", "(", "scratch", ",", "GEN_INT", "(", "0x02", ")", ")", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "jump_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "50", "/", "100", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "jump_label", ";", "emit_insn", "(", "gen_negxf2", "(", "e2", ",", "e2", ")", ")", ";", "emit_label", "(", "jump_label", ")", ";", "LABEL_NUSES", "(", "jump_label", ")", "=", "1", ";", "emit_move_insn", "(", "op0", ",", "e2", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "an", "tanh", "XFmode", "calculation", "." ]

[ "i386", "0x02", "50", "100", "1" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "bool", "BPFAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "if", "(", "(", "Count", "%", "8", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "8", ")", "support", "::", "endian", "::", "write", "<", "uint64_t", ">", "(", "OS", ",", "0x15000000", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "BPF", "BPF", "8", "0", "0", "8", "support::endian", "0x15000000" ]

[]

[ "<s>", "bool", "AArch64PromoteConstant", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "LocalChange", "=", "false", ";", "SmallSet", "<", "Constant", "*", ",", "8", ">", "AlreadyChecked", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "unsigned", "OpIdx", "=", "0", ",", "EndOpIdx", "=", "MI", ".", "getNumOperands", "(", ")", ";", "OpIdx", "!=", "EndOpIdx", ";", "++", "OpIdx", ")", "{", "Constant", "*", "Cst", "=", "dyn_cast", "<", "Constant", ">", "(", "MI", ".", "getOperand", "(", "OpIdx", ")", ")", ";", "if", "(", "Cst", "&&", "!", "isa", "<", "GlobalValue", ">", "(", "Cst", ")", "&&", "!", "isa", "<", "ConstantExpr", ">", "(", "Cst", ")", "&&", "AlreadyChecked", ".", "insert", "(", "Cst", ")", ".", "second", ")", "LocalChange", "|=", "promoteConstant", "(", "Cst", ")", ";", "}", "}", "}", "return", "LocalChange", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "0" ]

[]

[ "<s>", "static", "void", "nds32_emit_isr_vector_section", "(", "int", "vector_id", ")", "{", "unsigned", "int", "vector_number_offset", "=", "0", ";", "const", "char", "*", "c_str", "=", "\"CATEGORY\"", ";", "const", "char", "*", "sr_str", "=", "\"SR\"", ";", "const", "char", "*", "nt_str", "=", "\"NT\"", ";", "const", "char", "*", "vs_str", "=", "\"VS\"", ";", "char", "first_level_handler_name", "[", "100", "]", ";", "char", "section_name", "[", "100", "]", ";", "char", "symbol_name", "[", "100", "]", ";", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "category", ")", "{", "case", "NDS32_ISR_INTERRUPT", ":", "vector_number_offset", "=", "9", ";", "c_str", "=", "\"i\"", ";", "break", ";", "case", "NDS32_ISR_EXCEPTION", ":", "vector_number_offset", "=", "0", ";", "c_str", "=", "\"e\"", ";", "break", ";", "case", "NDS32_ISR_NONE", ":", "case", "NDS32_ISR_RESET", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", ")", "{", "case", "NDS32_SAVE_ALL", ":", "sr_str", "=", "\"sa\"", ";", "break", ";", "case", "NDS32_PARTIAL_SAVE", ":", "sr_str", "=", "\"ps\"", ";", "break", ";", "}", "switch", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "nested_type", ")", "{", "case", "NDS32_NESTED", ":", "nt_str", "=", "\"ns\"", ";", "break", ";", "case", "NDS32_NOT_NESTED", ":", "nt_str", "=", "\"nn\"", ";", "break", ";", "case", "NDS32_NESTED_READY", ":", "nt_str", "=", "\"nr\"", ";", "break", ";", "}", "vs_str", "=", "(", "nds32_isr_vector_size", "==", "4", ")", "?", "\"_4b\"", ":", "\"\"", ";", "snprintf", "(", "first_level_handler_name", ",", "sizeof", "(", "first_level_handler_name", ")", ",", "\"_nds32_%s_%s_%s%s\"", ",", "c_str", ",", "sr_str", ",", "nt_str", ",", "vs_str", ")", ";", "snprintf", "(", "section_name", ",", "sizeof", "(", "section_name", ")", ",", "\".nds32_vector.%02d\"", ",", "vector_id", ")", ";", "snprintf", "(", "symbol_name", ",", "sizeof", "(", "symbol_name", ")", ",", "\"_nds32_vector_%02d%s\"", ",", "vector_id", ",", "vs_str", ")", ";", "nds32_emit_section_head_template", "(", "section_name", ",", "symbol_name", ",", "floor_log2", "(", "nds32_isr_vector_size", ")", ",", "false", ")", ";", "if", "(", "nds32_isr_vector_size", "==", "4", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to first level handler\\n\"", ",", "first_level_handler_name", ")", ";", "}", "else", "{", "if", "(", "TARGET_REDUCED_REGS", ")", "{", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", "==", "NDS32_SAVE_ALL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! reduced set regs + save_all\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0xf\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r10, 0x0\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! reduced set regs + partial_save\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0x2\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", ")", ";", "}", "}", "else", "{", "if", "(", "nds32_isr_vectors", "[", "vector_id", "]", ".", "save_reg", "==", "NDS32_SAVE_ALL", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! full set regs + save_all\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r27, 0xf\\n\"", ")", ";", "}", "else", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t! full set regs + partial_save\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r15, [$sp], $r27, 0x2\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", ")", ";", "}", "}", "fprintf", "(", "asm_out_file", ",", "\"\\tmovi\\t$r0, %d ! preparing software vid\\n\"", ",", "vector_id", "-", "vector_number_offset", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tj\\t%s ! jump to first level handler\\n\"", ",", "first_level_handler_name", ")", ";", "}", "nds32_emit_section_tail_template", "(", "symbol_name", ")", ";", "}", "</s>" ]

[ "Function", "to", "emit", "isr", "vector", "section", "." ]

[ "nds32", "0", "\"CATEGORY\"", "\"SR\"", "\"NT\"", "\"VS\"", "100", "100", "100", "9", "\"i\"", "0", "\"e\"", "\"sa\"", "\"ps\"", "\"ns\"", "\"nn\"", "\"nr\"", "4", "\"_4b\"", "\"\"", "\"_nds32_%s_%s_%s%s\"", "\".nds32_vector.%02d\"", "\"_nds32_vector_%02d%s\"", "4", "\"\\tj\\t%s ! jump to first level handler\\n\"", "\"\\t! reduced set regs + save_all\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0xf\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r10, 0x0\\n\"", "\"\\t! reduced set regs + partial_save\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r15, 0x2\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", "\"\\t! full set regs + save_all\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r27, 0xf\\n\"", "\"\\t! full set regs + partial_save\\n\"", "\"\\tsmw.adm\\t$r15, [$sp], $r27, 0x2\\n\"", "\"\\tsmw.adm\\t$r0, [$sp], $r5, 0x0\\n\"", "\"\\tmovi\\t$r0, %d ! preparing software vid\\n\"", "\"\\tj\\t%s ! jump to first level handler\\n\"" ]

[]

[ "<s>", "void", "mn10300_print_reg_list", "(", "FILE", "*", "file", ",", "int", "mask", ")", "{", "int", "need_comma", ";", "int", "i", ";", "need_comma", "=", "0", ";", "fputc", "(", "'['", ",", "file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_EXTENDED_REGNUM", ";", "i", "++", ")", "if", "(", "(", "mask", "&", "(", "1", "<<", "i", ")", ")", "!=", "0", ")", "{", "if", "(", "need_comma", ")", "fputc", "(", "','", ",", "file", ")", ";", "fputs", "(", "reg_names", "[", "i", "]", ",", "file", ")", ";", "need_comma", "=", "1", ";", "}", "if", "(", "(", "mask", "&", "0x3c000", ")", "!=", "0", ")", "{", "gcc_assert", "(", "(", "mask", "&", "0x3c000", ")", "==", "0x3c000", ")", ";", "if", "(", "need_comma", ")", "fputc", "(", "','", ",", "file", ")", ";", "fputs", "(", "\"exreg1\"", ",", "file", ")", ";", "need_comma", "=", "1", ";", "}", "fputc", "(", "']'", ",", "file", ")", ";", "}", "</s>" ]

[ "Print", "a", "set", "of", "registers", "in", "the", "format", "required", "by", "``", "movm", "''", "and", "``", "ret", "''", ".", "Register", "K", "is", "saved", "if", "bit", "K", "of", "MASK", "is", "set", ".", "The", "data", "and", "address", "registers", "can", "be", "stored", "individually", ",", "but", "the", "extended", "registers", "can", "not", ".", "We", "assume", "that", "the", "mask", "alread", "takes", "that", "into", "account", ".", "For", "instance", ",", "bits", "14", "to", "17", "must", "have", "the", "same", "value", "." ]

[ "mn10300", "0", "0", "1", "0", "1", "0x3c000", "0", "0x3c000", "0x3c000", "\"exreg1\"", "1" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isInlineAsmSourceOfDivergence", "(", "const", "CallInst", "*", "CI", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ")", "const", "{", "if", "(", "Indices", ".", "size", "(", ")", ">", "1", ")", "return", "true", ";", "const", "DataLayout", "&", "DL", "=", "CI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TargetLowering", "::", "AsmOperandInfoVector", "TargetConstraints", "=", "TLI", "->", "ParseConstraints", "(", "DL", ",", "ST", "->", "getRegisterInfo", "(", ")", ",", "*", "CI", ")", ";", "const", "int", "TargetOutputIdx", "=", "Indices", ".", "empty", "(", ")", "?", "-", "1", ":", "Indices", "[", "0", "]", ";", "int", "OutputIdx", "=", "0", ";", "for", "(", "auto", "&", "TC", ":", "TargetConstraints", ")", "{", "if", "(", "TC", ".", "Type", "!=", "InlineAsm", "::", "isOutput", ")", "continue", ";", "if", "(", "TargetOutputIdx", "!=", "-", "1", "&&", "TargetOutputIdx", "!=", "OutputIdx", "++", ")", "continue", ";", "TLI", "->", "ComputeConstraintToUse", "(", "TC", ",", "SDValue", "(", ")", ")", ";", "Register", "AssignedReg", ";", "const", "TargetRegisterClass", "*", "RC", ";", "std", "::", "tie", "(", "AssignedReg", ",", "RC", ")", "=", "TLI", "->", "getRegForInlineAsmConstraint", "(", "TRI", ",", "TC", ".", "ConstraintCode", ",", "TC", ".", "ConstraintVT", ")", ";", "if", "(", "AssignedReg", ")", "{", "RC", "=", "TRI", "->", "getPhysRegClass", "(", "AssignedReg", ")", ";", "}", "if", "(", "!", "RC", "||", "!", "TRI", "->", "isSGPRClass", "(", "RC", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Analyze", "if", "the", "results", "of", "inline", "asm", "are", "divergent", "." ]

[ "AMDGPU", "1", "SI", "1", "0", "0", "1" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "StringRef", "WinEHParentName", "=", "F", ".", "getFnAttribute", "(", "\"wineh-parent\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "WinEHParentName", "!=", "F", ".", "getName", "(", ")", "&&", "!", "WinEHParentName", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isMSVCEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "auto", "*", "MMIPtr", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "assert", "(", "MMIPtr", "&&", "\"MachineModuleInfo should always be available\"", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "*", "MMIPtr", ";", "switch", "(", "Personality", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected personality function\"", ")", ";", "case", "EHPersonality", "::", "MSVC_CXX", ":", "addCXXStateStores", "(", "F", ",", "MMI", ")", ";", "break", ";", "case", "EHPersonality", "::", "MSVC_X86SEH", ":", "addSEHStateStores", "(", "F", ",", "MMI", ")", ";", "break", ";", "}", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"wineh-parent\"", "\"no-frame-pointer-elim\"", "\"true\"", "\"MachineModuleInfo should always be available\"", "\"unexpected personality function\"", "X86" ]

[]

[ "<s>", "unsigned", "PatmosInstrInfo", "::", "getIssueWidth", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "PST", ".", "getSchedModel", "(", ")", ".", "IssueWidth", ";", "return", "PST", ".", "getIssueWidth", "(", "MI", "->", "getDesc", "(", ")", ".", "SchedClass", ")", ";", "}", "</s>" ]

[ "Maximum", "number", "of", "micro-ops", "that", "may", "be", "scheduled", "per", "cycle", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "bool", "sh_lra_p", "(", "void", ")", "{", "return", "sh_lra_flag", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "sh" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "&&", "(", "hasFP", "(", "MF", ")", "||", "hasBP", "(", "MF", ")", ")", "&&", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", ")", ";", "auto", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ";", "const", "auto", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", "&&", "needsSPWriteback", "(", "MF", ")", ")", "{", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "writeSPToGlobal", "(", "getSPReg", "(", "MF", ")", ",", "MF", ",", "MBB", ",", "I", ",", "DL", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "0", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", "WebAssembly" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "iq2000_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Allocate", "a", "chunk", "of", "memory", "for", "per-function", "machine-dependent", "data", "." ]

[ "iq2000" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "static", "unsigned", "int", "bpf_hard_regno_nregs", "(", "unsigned", "int", "regno", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ")", "{", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "consecutive", "hard", "registers", ",", "starting", "at", "register", "number", "REGNO", ",", "required", "to", "hold", "a", "value", "of", "mode", "MODE", "." ]

[ "bpf" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "HexagonFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "(", "void", ")", "Opc", ";", "assert", "(", "(", "Opc", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "&&", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::ADJCALLSTACKDOWN", "Hexagon::ADJCALLSTACKUP", "\"Cannot handle this call frame pseudo instruction\"" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "shouldSignExtendTypeInLibCall", "(", "EVT", "Type", ",", "bool", "IsSigned", ")", "const", "{", "if", "(", "Subtarget", ".", "hasMips3", "(", ")", "&&", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ")", "{", "if", "(", "Type", "==", "MVT", "::", "i32", ")", "return", "true", ";", "}", "return", "IsSigned", ";", "}", "</s>" ]

[ "Returns", "true", "if", "arguments", "should", "be", "sign-extended", "in", "lib", "calls", "." ]

[ "Mips", "Mips", "Mips", "MVT::i32" ]

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", "->", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MBlazeFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "MBlaze", "::", "GPRRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "MBlaze", "::", "R20", ")", ";", "RegInfo", ".", "addLiveIn", "(", "MBlaze", "::", "R20", ")", ";", "MBlazeFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze::GPRRegisterClass", "MBlaze::R20", "MBlaze::R20", "MBlaze" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformBRCONDCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Cmp", "=", "N", "->", "getOperand", "(", "4", ")", ";", "if", "(", "Cmp", ".", "getOpcode", "(", ")", "!=", "ARMISD", "::", "CMPZ", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "LHS", "=", "Cmp", ".", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "Cmp", ".", "getOperand", "(", "1", ")", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "BB", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "ARMcc", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ARMCC", "::", "CondCodes", "CC", "=", "(", "ARMCC", "::", "CondCodes", ")", "cast", "<", "ConstantSDNode", ">", "(", "ARMcc", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "CC", "==", "ARMCC", "::", "NE", "&&", "LHS", ".", "getOpcode", "(", ")", "==", "ISD", "::", "AND", "&&", "LHS", "->", "hasOneUse", "(", ")", "&&", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "CMOV", "&&", "LHS", "->", "getOperand", "(", "0", ")", "->", "hasOneUse", "(", ")", ")", "{", "auto", "*", "LHS00C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "0", ")", ")", ";", "auto", "*", "LHS01C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "1", ")", ")", ";", "auto", "*", "LHS1C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "LHS", "->", "getOperand", "(", "1", ")", ")", ";", "auto", "*", "RHSC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "RHS", ")", ";", "if", "(", "(", "LHS00C", "&&", "LHS00C", "->", "getZExtValue", "(", ")", "==", "0", ")", "&&", "(", "LHS01C", "&&", "LHS01C", "->", "getZExtValue", "(", ")", "==", "1", ")", "&&", "(", "LHS1C", "&&", "LHS1C", "->", "getZExtValue", "(", ")", "==", "1", ")", "&&", "(", "RHSC", "&&", "RHSC", "->", "getZExtValue", "(", ")", "==", "0", ")", ")", "{", "return", "DAG", ".", "getNode", "(", "ARMISD", "::", "BRCOND", ",", "dl", ",", "VT", ",", "Chain", ",", "BB", ",", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "2", ")", ",", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "3", ")", ",", "LHS", "->", "getOperand", "(", "0", ")", "->", "getOperand", "(", "4", ")", ")", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "PerformBRCONDCombine", "-", "Target-specific", "DAG", "combining", "for", "ARMISD", ":", ":BRCOND", "." ]

[ "ARM", "ARM", "4", "ARMISD::CMPZ", "0", "0", "1", "0", "1", "ARM", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "ARM", "ARMCC::NE", "ISD::AND", "0", "ARMISD::CMOV", "0", "0", "0", "0", "1", "1", "0", "1", "1", "0", "ARMISD::BRCOND", "0", "2", "0", "3", "0", "4" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "SMRange", "Range", "=", "None", ",", "bool", "MatchingInlineAsm", "=", "false", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "MatchingInlineAsm", ")", "{", "if", "(", "!", "getLexer", "(", ")", ".", "isAtStartOfStatement", "(", ")", ")", "eatToEndOfLine", "(", ")", ";", "return", "false", ";", "}", "bool", "Result", "=", "Parser", ".", "Error", "(", "L", ",", "Msg", ",", "Range", ")", ";", "eatToEndOfLine", "(", ")", ";", "CurrentSlot", "=", "SlotParser", "::", "Unknown", ";", "Bundle", ".", "clear", "(", ")", ";", "Bundle", ".", "setOpcode", "(", "0", ")", ";", "Bundle", ".", "setLoc", "(", "SMLoc", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "TPC", "0" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AArch64LegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_VAARG", ":", "return", "legalizeVaArg", "(", "MI", ",", "MRI", ",", "MIRBuilder", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "legalizeLoadStore", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "legalizeShlAshrLshr", "(", "MI", ",", "MRI", ",", "MIRBuilder", ",", "Observer", ")", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AArch64", "AArch64", "\"expected switch to return\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "WebAssemblyTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "assert", "(", "VT", "!=", "MVT", "::", "iPTR", "&&", "\"Pointer MVT not expected here\"", ")", ";", "if", "(", "Subtarget", "->", "hasSIMD128", "(", ")", "&&", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "V128RegClass", ")", ";", "}", "if", "(", "VT", ".", "isInteger", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I32RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "<=", "64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "WebAssembly", "WebAssembly", "1", "0", "MVT::iPTR", "\"Pointer MVT not expected here\"", "128", "0U", "WebAssembly::V128RegClass", "32", "0U", "WebAssembly::I32RegClass", "64", "0U", "WebAssembly::I64RegClass" ]

[]

[ "<s>", "bool", "mep_mov_ok", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "fprintf", "(", "stderr", ",", "\"mep_mov_ok %s %c=%c\\n\"", ",", "mode_name", "[", "mode", "]", ",", "mep_section_tag", "(", "operands", "[", "0", "]", ")", ",", "mep_section_tag", "(", "operands", "[", "1", "]", ")", ")", ";", "debug_rtx", "(", "operands", "[", "0", "]", ")", ";", "debug_rtx", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "HIGH", ")", "return", "false", ";", "if", "(", "mep_section_tag", "(", "operands", "[", "0", "]", ")", "==", "'f'", "||", "mep_section_tag", "(", "operands", "[", "1", "]", ")", "==", "'f'", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, f\\n\"", ")", ";", "return", "false", ";", "}", "i", "=", "mep_section_tag", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "(", "i", "==", "'b'", "||", "i", "==", "'t'", ")", "&&", "!", "reload_completed", "&&", "!", "reload_in_progress", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, bt\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "rtx", "x", "=", "operands", "[", "i", "]", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "!", "MEP_CONTROL_REG", "(", "x", ")", ")", "{", "fprintf", "(", "stderr", ",", "\" - ok\\n\"", ")", ";", "return", "true", ";", "}", "}", "fprintf", "(", "stderr", ",", "\" - no, no gen reg\\n\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Cases", "where", "the", "pattern", "ca", "n't", "be", "made", "to", "use", "at", "all", "." ]

[ "mep", "\"mep_mov_ok %s %c=%c\\n\"", "0", "1", "0", "1", "1", "0", "1", "\" - no, f\\n\"", "1", "\" - no, bt\\n\"", "0", "2", "0", "\" - ok\\n\"", "\" - no, no gen reg\\n\"" ]

[]

[ "<s>", "bool", "gpr_or_gpr_p", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "return", "(", "(", "REG_P", "(", "op0", ")", "&&", "INT_REGNO_P", "(", "REGNO", "(", "op0", ")", ")", ")", "||", "(", "REG_P", "(", "op1", ")", "&&", "INT_REGNO_P", "(", "REGNO", "(", "op1", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "either", "operand", "is", "a", "general", "purpose", "register", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "unsigned", "HOST_WIDE_INT", "s390_extract_part", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "def", ")", "{", "unsigned", "HOST_WIDE_INT", "value", "=", "0", ";", "int", "max_parts", "=", "HOST_BITS_PER_WIDE_INT", "/", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "int", "part_bits", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "unsigned", "HOST_WIDE_INT", "part_mask", "=", "(", "HOST_WIDE_INT_1U", "<<", "part_bits", ")", "-", "1", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max_parts", ";", "i", "++", ")", "{", "if", "(", "i", "==", "0", ")", "value", "=", "UINTVAL", "(", "op", ")", ";", "else", "value", ">>=", "part_bits", ";", "if", "(", "(", "value", "&", "part_mask", ")", "!=", "(", "def", "&", "part_mask", ")", ")", "return", "value", "&", "part_mask", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "part", "of", "op", "which", "has", "a", "value", "different", "from", "def", ".", "The", "size", "of", "the", "part", "is", "determined", "by", "mode", ".", "Use", "this", "function", "only", "if", "you", "already", "know", "that", "op", "really", "contains", "such", "a", "part", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "int", "icode", "=", "INSN_CODE", "(", "insn", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", "&&", "(", "icode", "==", "CODE_FOR_bdz_si", "||", "icode", "==", "CODE_FOR_bdz_di", "||", "icode", "==", "CODE_FOR_bdnz_si", "||", "icode", "==", "CODE_FOR_bdnz_di", "||", "icode", "==", "CODE_FOR_bdztf_si", "||", "icode", "==", "CODE_FOR_bdztf_di", "||", "icode", "==", "CODE_FOR_bdnztf_si", "||", "icode", "==", "CODE_FOR_bdnztf_di", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_LEGITIMATE_COMBINED_INSN", "hook", "." ]

[ "rs6000" ]

[]