Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register x\"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "CSKY", "\"<register x\"", "\">\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_movs", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "unsigned", "i", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "x", ";", "if", "(", "d", "->", "one_operand_p", ")", "return", "false", ";", "if", "(", "!", "(", "TARGET_SSE", "&&", "vmode", "==", "V4SFmode", ")", "&&", "!", "(", "TARGET_MMX_WITH_SSE", "&&", "vmode", "==", "V2SFmode", ")", "&&", "!", "(", "TARGET_SSE2", "&&", "vmode", "==", "V2DFmode", ")", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "!=", "nelt", "&&", "d", "->", "perm", "[", "0", "]", "!=", "0", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "+", "nelt", "-", "d", "->", "perm", "[", "0", "]", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "nelt", ")", "x", "=", "gen_rtx_VEC_MERGE", "(", "vmode", ",", "d", "->", "op1", ",", "d", "->", "op0", ",", "GEN_INT", "(", "1", ")", ")", ";", "else", "x", "=", "gen_rtx_VEC_MERGE", "(", "vmode", ",", "d", "->", "op0", ",", "d", "->", "op1", ",", "GEN_INT", "(", "1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "d", "->", "target", ",", "x", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_builtin_1", ".", "Try", "to", "implement", "D", "using", "movss", "or", "movsd", "." ]

[ "i386", "0", "0", "0", "1", "0", "0", "1", "1" ]

[]

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

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

[ "VE", "VE", "MVT::i64" ]

[]

[ "<s>", "bool", "ARM64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "!", "DoLoadStoreOpt", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "Fn", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARM64InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getRegisterInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64" ]

[]

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

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

[ "F2003f", "F2003f" ]

[]

[ "<s>", "static", "bool", "rs6000_builtin_support_vector_misalignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "misalignment", ",", "bool", "is_packed", ")", "{", "if", "(", "TARGET_VSX", ")", "{", "if", "(", "optab_handler", "(", "movmisalign_optab", ",", "mode", ")", "==", "CODE_FOR_nothing", ")", "return", "false", ";", "if", "(", "misalignment", "==", "-", "1", ")", "{", "if", "(", "rs6000_vector_alignment_reachable", "(", "type", ",", "is_packed", ")", ")", "{", "int", "element_size", "=", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ";", "if", "(", "element_size", "==", "64", "||", "element_size", "==", "32", ")", "return", "true", ";", "}", "return", "false", ";", "}", "if", "(", "misalignment", "%", "4", "==", "0", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "vector", "misalignment", "factor", "is", "supported", "by", "the", "target", "." ]

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

[]

[ "<s>", "int", "function_arg_regno_p", "(", "int", "r", ")", "{", "return", "(", "r", ">=", "8", "&&", "r", "<=", "25", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "register", "may", "be", "used", "to", "pass", "function", "parameters", "." ]

[ "avr", "8", "25" ]

[]

[ "<s>", "void", "v850_output_local", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ")", "{", "fprintf", "(", "file", ",", "\"%s\"", ",", "LOCAL_ASM_OP", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "ASM_OUTPUT_ALIGNED_DECL_COMMON", "(", "file", ",", "decl", ",", "name", ",", "size", ",", "align", ")", ";", "}", "</s>" ]

[ "Called", "via", "the", "macro", "ASM_OUTPUT_DECL_LOCAL" ]

[ "v850", "\"%s\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "SHUXIPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createSHUXIISelDag", "(", "getSHUXITargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "SHUXI", "SHUXI" ]

[]

[ "<s>", "bool", "AArch64ExpandHardenedPseudos", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64ExpandHardenedPseudos *****\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "MBBE", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "MBBE", ";", ")", "{", "auto", "&", "MI", "=", "*", "MBBI", "++", ";", "Modified", "|=", "expandMI", "(", "MI", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64ExpandHardenedPseudos *****\\n\"" ]

[]

[ "<s>", "void", "TeakRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "dbgs", "(", ")", "<<", "\"eliminateFrameIndex\\n\"", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", ";", "case", "Teak", "::", "STORE_REG_TO_STACK_PSEUDO_16", ":", "case", "Teak", "::", "STORE_REG_TO_STACK_PSEUDO_TRUNC16", ":", "case", "Teak", "::", "STORE_REG_TO_STACK_PSEUDO_32", ":", "case", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_16", ":", "case", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_16_SEXT40", ":", "case", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_16_ZEXT40", ":", "case", "Teak", "::", "LOAD_REG_FROM_STACK_PSEUDO_32_SEXT40", ":", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "break", ";", "}", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "FI", ")", "+", "MFI", ".", "getStackSize", "(", ")", "+", "ImmOp", ".", "getImm", "(", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "Teak", "::", "R7", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "-", "(", "Offset", ">>", "1", ")", "-", "1", ")", ";", "}", "</s>" ]

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

[ "Teak", "Teak", "\"eliminateFrameIndex\\n\"", "0", "Teak::STORE_REG_TO_STACK_PSEUDO_16", "Teak::STORE_REG_TO_STACK_PSEUDO_TRUNC16", "Teak::STORE_REG_TO_STACK_PSEUDO_32", "Teak::LOAD_REG_FROM_STACK_PSEUDO_16", "Teak::LOAD_REG_FROM_STACK_PSEUDO_16_SEXT40", "Teak::LOAD_REG_FROM_STACK_PSEUDO_16_ZEXT40", "Teak::LOAD_REG_FROM_STACK_PSEUDO_32_SEXT40", "1", "Teak::R7", "1", "1" ]

[]

[ "<s>", "static", "int", "arm_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep", ",", "int", "cost", ")", "{", "rtx", "i_pat", ",", "d_pat", ";", "if", "(", "TARGET_THUMB1", "&&", "REG_NOTE_KIND", "(", "link", ")", "==", "0", "&&", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_cbranchsi4_insn", "&&", "recog_memoized", "(", "dep", ")", ">=", "0", "&&", "get_attr_conds", "(", "dep", ")", "==", "CONDS_SET", ")", "return", "0", ";", "if", "(", "current_tune", "->", "sched_adjust_cost", "!=", "NULL", ")", "{", "if", "(", "!", "current_tune", "->", "sched_adjust_cost", "(", "insn", ",", "link", ",", "dep", ",", "&", "cost", ")", ")", "return", "cost", ";", "}", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_ANTI", "||", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_OUTPUT", ")", "return", "0", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "0", "&&", "CALL_P", "(", "insn", ")", ")", "return", "1", ";", "if", "(", "(", "i_pat", "=", "single_set", "(", "insn", ")", ")", "!=", "NULL", "&&", "MEM_P", "(", "SET_SRC", "(", "i_pat", ")", ")", "&&", "(", "d_pat", "=", "single_set", "(", "dep", ")", ")", "!=", "NULL", "&&", "MEM_P", "(", "SET_DEST", "(", "d_pat", ")", ")", ")", "{", "rtx", "src_mem", "=", "XEXP", "(", "SET_SRC", "(", "i_pat", ")", ",", "0", ")", ";", "if", "(", "(", "GET_CODE", "(", "src_mem", ")", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "src_mem", ")", ")", "||", "reg_mentioned_p", "(", "stack_pointer_rtx", ",", "src_mem", ")", "||", "reg_mentioned_p", "(", "frame_pointer_rtx", ",", "src_mem", ")", "||", "reg_mentioned_p", "(", "hard_frame_pointer_rtx", ",", "src_mem", ")", ")", "return", "1", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "This", "function", "implements", "the", "target", "macro", "TARGET_SCHED_ADJUST_COST", ".", "It", "corrects", "the", "value", "of", "COST", "based", "on", "the", "relationship", "between", "INSN", "and", "DEP", "through", "the", "dependence", "LINK", ".", "It", "returns", "the", "new", "value", ".", "There", "is", "a", "per-core", "adjust_cost", "hook", "to", "adjust", "scheduler", "costs", "and", "the", "per-core", "hook", "can", "choose", "to", "completely", "override", "the", "generic", "adjust_cost", "function", ".", "Only", "put", "bits", "of", "code", "into", "arm_adjust_cost", "that", "are", "common", "across", "all", "cores", "." ]

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

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "RISCVTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "8", "||", "Size", "==", "16", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "RISCV", "RISCV", "8", "16" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "s390_save_gprs_to_fprs", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "for", "(", "i", "=", "6", ";", "i", "<", "16", ";", "i", "++", ")", "{", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "i", ")", ")", ")", "{", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "cfun_gpr_save_slot", "(", "i", ")", ")", ",", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "PATTERN", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Copy", "GPRS", "into", "FPR", "save", "slots", "." ]

[ "s390", "6", "16", "1" ]

[]

[ "<s>", "static", "int", "thumb2_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "TARGET_HAVE_MVE", "&&", "VALID_MVE_MODE", "(", "mode", ")", ")", "return", "mve_vector_mem_operand", "(", "mode", ",", "x", ",", "strict_p", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "1", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "!", "CONST_INT_P", "(", "addend", ")", ")", "return", "0", ";", "offset", "=", "INTVAL", "(", "addend", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "return", "(", "offset", ">", "-", "256", "&&", "offset", "<", "256", ")", ";", "return", "(", "use_ldrd", "&&", "offset", ">", "-", "1024", "&&", "offset", "<", "1024", "&&", "(", "offset", "&", "3", ")", "==", "0", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "1", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "TARGET_NEON", "&&", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_HAVE_MVE", "&&", "VALID_MVE_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "0", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "(", "thumb2_legitimate_index_p", "(", "mode", ",", "xop1", ",", "strict_p", ")", "||", "(", "!", "strict_p", "&&", "will_be_in_index_register", "(", "xop1", ")", ")", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "thumb2_legitimate_index_p", "(", "mode", ",", "xop0", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "can_avoid_literal_pool_for_label_p", "(", "x", ")", ")", "return", "0", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "Thumb-2", "address", "operand", "." ]

[ "arm", "1", "4", "0", "0", "1", "1", "0", "0", "1", "1", "0", "4", "256", "256", "1024", "1024", "3", "0", "0", "0", "0", "0", "1", "1", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "shouldSink", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "isPredicated", "(", "MI", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "Next", "=", "&", "MI", ";", "++", "Next", ";", "unsigned", "SrcReg", ",", "SrcReg2", ";", "int", "CmpMask", ",", "CmpValue", ";", "if", "(", "Next", "!=", "MI", ".", "getParent", "(", ")", "->", "end", "(", ")", "&&", "analyzeCompare", "(", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpMask", ",", "CmpValue", ")", "&&", "isRedundantFlagInstr", "(", "&", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpValue", ",", "&", "MI", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "should", "be", "sunk", "by", "MachineSink", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "addMSAIntType", "(", "MVT", "::", "SimpleValueType", "Ty", ",", "const", "TargetRegisterClass", "*", "RC", ")", "{", "addRegisterClass", "(", "Ty", ",", "RC", ")", ";", "for", "(", "unsigned", "Opc", "=", "0", ";", "Opc", "<", "ISD", "::", "BUILTIN_OP_END", ";", "++", "Opc", ")", "setOperationAction", "(", "Opc", ",", "Ty", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "BITCAST", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ADD", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "AND", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTLZ", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "CTPOP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "MUL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "OR", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SUB", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UDIV", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UREM", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMAX", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UMIN", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "VECTOR_SHUFFLE", ",", "Ty", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "VSELECT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "XOR", ",", "Ty", ",", "Legal", ")", ";", "if", "(", "Ty", "==", "MVT", "::", "v4i32", "||", "Ty", "==", "MVT", "::", "v2i64", ")", "{", "setOperationAction", "(", "ISD", "::", "FP_TO_SINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "FP_TO_UINT", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "SINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "UINT_TO_FP", ",", "Ty", ",", "Legal", ")", ";", "}", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "Ty", ",", "Legal", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETNE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETGE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETGT", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGE", ",", "Ty", ",", "Expand", ")", ";", "setCondCodeAction", "(", "ISD", "::", "SETUGT", ",", "Ty", ",", "Expand", ")", ";", "}", "</s>" ]

[ "Enable", "MSA", "support", "for", "the", "given", "integer", "type", "and", "Register", "class", "." ]

[ "Mips", "Mips", "MVT::SimpleValueType", "0", "ISD::BUILTIN_OP_END", "ISD::BITCAST", "ISD::LOAD", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::ADD", "ISD::AND", "ISD::CTLZ", "ISD::CTPOP", "ISD::MUL", "ISD::OR", "ISD::SDIV", "ISD::SREM", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::SUB", "ISD::SMAX", "ISD::SMIN", "ISD::UDIV", "ISD::UREM", "ISD::UMAX", "ISD::UMIN", "ISD::VECTOR_SHUFFLE", "ISD::VSELECT", "ISD::XOR", "MVT::v4i32", "MVT::v2i64", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::SETCC", "ISD::SETNE", "ISD::SETGE", "ISD::SETGT", "ISD::SETUGE", "ISD::SETUGT" ]

[]

[ "<s>", "void", "ix86_d_register_target_info", "(", "void", ")", "{", "const", "struct", "d_target_info_spec", "handlers", "[", "]", "=", "{", "{", "\"floatAbi\"", ",", "ix86_d_handle_target_float_abi", "}", ",", "{", "\"objectFormat\"", ",", "ix86_d_handle_target_object_format", "}", ",", "{", "NULL", ",", "NULL", "}", ",", "}", ";", "d_add_target_info_handlers", "(", "handlers", ")", ";", "}", "</s>" ]

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

[ "i386", "\"floatAbi\"", "\"objectFormat\"" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "OR1K", "OR1K", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "mips_valid_pointer_mode", "(", "scalar_int_mode", "mode", ")", "{", "return", "mode", "==", "SImode", "||", "(", "TARGET_64BIT", "&&", "mode", "==", "DImode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VALID_POINTER_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "NVPTXSubtarget", "::", "NVPTXSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "NVPTXTargetMachine", "&", "TM", ")", ":", "NVPTXGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "PTXVersion", "(", "0", ")", ",", "SmVersion", "(", "20", ")", ",", "TM", "(", "TM", ")", ",", "TLInfo", "(", "TM", ",", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", "{", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "0", "20" ]

[]

[ "<s>", "SDValue", "XCoreSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "bool", "MustPreserveCheriCapabilities", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "unsigned", "SizeBitWidth", "=", "Size", ".", "getValueSizeInBits", "(", ")", ";", "if", "(", "!", "AlwaysInline", "&&", "Alignment", ">=", "Align", "(", "4", ")", "&&", "DAG", ".", "MaskedValueIsZero", "(", "Size", ",", "APInt", "(", "SizeBitWidth", ",", "3", ")", ")", ")", "{", "const", "TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getSubtarget", "(", ")", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Ty", "=", "DAG", ".", "getDataLayout", "(", ")", ".", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setLibCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMCPY", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalFunctionSymbol", "(", "\"__memcpy_4\"", ")", ",", "std", "::", "move", "(", "Args", ")", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "4", "3", "\"__memcpy_4\"" ]

[]

[ "<s>", "unsigned", "X86FastISel", "::", "fastMaterializeFloatZero", "(", "const", "ConstantFP", "*", "CF", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "CF", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "0", ";", "bool", "HasAVX512", "=", "Subtarget", "->", "hasAVX512", "(", ")", ";", "unsigned", "Opc", "=", "0", ";", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "0", ";", "case", "MVT", "::", "f32", ":", "if", "(", "X86ScalarSSEf32", ")", "{", "Opc", "=", "HasAVX512", "?", "X86", "::", "AVX512_FsFLD0SS", ":", "X86", "::", "FsFLD0SS", ";", "RC", "=", "HasAVX512", "?", "&", "X86", "::", "FR32XRegClass", ":", "&", "X86", "::", "FR32RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp032", ";", "RC", "=", "&", "X86", "::", "RFP32RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "X86ScalarSSEf64", ")", "{", "Opc", "=", "HasAVX512", "?", "X86", "::", "AVX512_FsFLD0SD", ":", "X86", "::", "FsFLD0SD", ";", "RC", "=", "HasAVX512", "?", "&", "X86", "::", "FR64XRegClass", ":", "&", "X86", "::", "FR64RegClass", ";", "}", "else", "{", "Opc", "=", "X86", "::", "LD_Fp064", ";", "RC", "=", "&", "X86", "::", "RFP64RegClass", ";", "}", "break", ";", "case", "MVT", "::", "f80", ":", "return", "0", ";", "}", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ";", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "the", "floating-point", "constant", "+0.0", "in", "a", "register", "using", "target-", "specific", "logic", "." ]

[ "X86", "X86", "0", "0", "0", "MVT::f32", "X86", "X86::AVX512_FsFLD0SS", "X86::FsFLD0SS", "X86::FR32XRegClass", "X86::FR32RegClass", "X86::LD_Fp032", "X86::RFP32RegClass", "MVT::f64", "X86", "X86::AVX512_FsFLD0SD", "X86::FsFLD0SD", "X86::FR64XRegClass", "X86::FR64RegClass", "X86::LD_Fp064", "X86::RFP64RegClass", "MVT::f80", "0" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSUBCombine", "(", "N", ",", "DCI", ")", ";", "case", "ARMISD", "::", "FMRRD", ":", "return", "PerformFMRRDCombine", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ISD::ADD", "ISD::SUB", "ARMISD::FMRRD" ]

[]

[ "<s>", "static", "void", "ix86_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "enum", "processor_type", "old_tune", "=", "ix86_tune", ";", "enum", "processor_type", "old_arch", "=", "ix86_arch", ";", "unsigned", "int", "ix86_arch_mask", ";", "int", "i", ";", "opts", "->", "x_flag_pic", "=", "flag_pic", ";", "ix86_arch", "=", "(", "enum", "processor_type", ")", "ptr", "->", "arch", ";", "ix86_schedule", "=", "(", "enum", "attr_cpu", ")", "ptr", "->", "schedule", ";", "ix86_tune", "=", "(", "enum", "processor_type", ")", "ptr", "->", "tune", ";", "x86_prefetch_sse", "=", "ptr", "->", "prefetch_sse", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "branch_cost", ";", "ix86_tune_defaulted", "=", "ptr", "->", "tune_defaulted", ";", "ix86_arch_specified", "=", "ptr", "->", "arch_specified", ";", "opts", "->", "x_ix86_isa_flags_explicit", "=", "ptr", "->", "x_ix86_isa_flags_explicit", ";", "opts", "->", "x_ix86_isa_flags2_explicit", "=", "ptr", "->", "x_ix86_isa_flags2_explicit", ";", "opts", "->", "x_recip_mask_explicit", "=", "ptr", "->", "x_recip_mask_explicit", ";", "opts", "->", "x_ix86_arch_string", "=", "ptr", "->", "x_ix86_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "ptr", "->", "x_ix86_tune_string", ";", "opts", "->", "x_ix86_cmodel", "=", "ptr", "->", "x_ix86_cmodel", ";", "opts", "->", "x_ix86_abi", "=", "ptr", "->", "x_ix86_abi", ";", "opts", "->", "x_ix86_asm_dialect", "=", "ptr", "->", "x_ix86_asm_dialect", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "x_ix86_branch_cost", ";", "opts", "->", "x_ix86_dump_tunes", "=", "ptr", "->", "x_ix86_dump_tunes", ";", "opts", "->", "x_ix86_force_align_arg_pointer", "=", "ptr", "->", "x_ix86_force_align_arg_pointer", ";", "opts", "->", "x_ix86_force_drap", "=", "ptr", "->", "x_ix86_force_drap", ";", "opts", "->", "x_ix86_incoming_stack_boundary_arg", "=", "ptr", "->", "x_ix86_incoming_stack_boundary_arg", ";", "opts", "->", "x_ix86_pmode", "=", "ptr", "->", "x_ix86_pmode", ";", "opts", "->", "x_ix86_preferred_stack_boundary_arg", "=", "ptr", "->", "x_ix86_preferred_stack_boundary_arg", ";", "opts", "->", "x_ix86_recip_name", "=", "ptr", "->", "x_ix86_recip_name", ";", "opts", "->", "x_ix86_regparm", "=", "ptr", "->", "x_ix86_regparm", ";", "opts", "->", "x_ix86_section_threshold", "=", "ptr", "->", "x_ix86_section_threshold", ";", "opts", "->", "x_ix86_sse2avx", "=", "ptr", "->", "x_ix86_sse2avx", ";", "opts", "->", "x_ix86_stack_protector_guard", "=", "ptr", "->", "x_ix86_stack_protector_guard", ";", "opts", "->", "x_ix86_stringop_alg", "=", "ptr", "->", "x_ix86_stringop_alg", ";", "opts", "->", "x_ix86_tls_dialect", "=", "ptr", "->", "x_ix86_tls_dialect", ";", "opts", "->", "x_ix86_tune_ctrl_string", "=", "ptr", "->", "x_ix86_tune_ctrl_string", ";", "opts", "->", "x_ix86_tune_memcpy_strategy", "=", "ptr", "->", "x_ix86_tune_memcpy_strategy", ";", "opts", "->", "x_ix86_tune_memset_strategy", "=", "ptr", "->", "x_ix86_tune_memset_strategy", ";", "opts", "->", "x_ix86_tune_no_default", "=", "ptr", "->", "x_ix86_tune_no_default", ";", "opts", "->", "x_ix86_veclibabi_type", "=", "ptr", "->", "x_ix86_veclibabi_type", ";", "ix86_tune_cost", "=", "processor_target_table", "[", "ix86_tune", "]", ".", "cost", ";", "if", "(", "opts", "->", "x_optimize_size", ")", "ix86_cost", "=", "&", "ix86_size_cost", ";", "else", "ix86_cost", "=", "ix86_tune_cost", ";", "if", "(", "old_arch", "!=", "ix86_arch", ")", "{", "ix86_arch_mask", "=", "1u", "<<", "ix86_arch", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_ARCH_LAST", ";", "++", "i", ")", "ix86_arch_features", "[", "i", "]", "=", "!", "!", "(", "initial_ix86_arch_features", "[", "i", "]", "&", "ix86_arch_mask", ")", ";", "}", "if", "(", "old_tune", "!=", "ix86_tune", ")", "set_ix86_tune_features", "(", "ix86_tune", ",", "false", ")", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options" ]

[ "i386", "1u", "0" ]

[]

[ "<s>", "void", "emitInst", "(", "uint32_t", "Inst", ")", "{", "char", "Buffer", "[", "4", "]", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "4", ";", "++", "I", ")", "{", "Buffer", "[", "I", "]", "=", "uint8_t", "(", "Inst", ")", ";", "Inst", ">>=", "8", ";", "}", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitBytes", "(", "StringRef", "(", "Buffer", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".inst", "directive", "." ]

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

[]

[ "<s>", "bool", "BPFAdjustOpt", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "adjustBasicBlock", "(", "BB", ")", ";", "for", "(", "auto", "&", "I", ":", "BB", ")", "adjustInst", "(", "I", ")", ";", "}", "return", "insertPassThrough", "(", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "void", "aarch64_start_file", "(", "void", ")", "{", "struct", "cl_target_option", "*", "default_options", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "const", "struct", "processor", "*", "default_arch", "=", "aarch64_get_arch", "(", "default_options", "->", "x_explicit_arch", ")", ";", "unsigned", "long", "default_isa_flags", "=", "default_options", "->", "x_aarch64_isa_flags", ";", "std", "::", "string", "extension", "=", "aarch64_get_extension_string_for_isa_flags", "(", "default_isa_flags", ",", "default_arch", "->", "flags", ")", ";", "aarch64_last_printed_arch_string", "=", "default_arch", "->", "name", "+", "extension", ";", "aarch64_last_printed_tune_string", "=", "\"\"", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arch %s\\n\"", ",", "aarch64_last_printed_arch_string", ".", "c_str", "(", ")", ")", ";", "default_file_start", "(", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_ASM_FILE_START", ".", "Output", "the", "assembly", "header", "." ]

[ "aarch64", "\"\"", "\"\\t.arch %s\\n\"" ]

[]

[ "<s>", "void", "MOSInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "if", "(", "Orig", ".", "getOpcode", "(", ")", "==", "MOS", "::", "LDImm16", ")", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MI", "->", "removeOperand", "(", "1", ")", ";", "MI", "->", "substituteRegister", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "MOS", "::", "LDImm16Remat", ")", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "else", "{", "TargetInstrInfo", "::", "reMaterialize", "(", "MBB", ",", "I", ",", "DestReg", ",", "SubIdx", ",", "Orig", ",", "TRI", ")", ";", "}", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS::LDImm16", "1", "0", "MOS::LDImm16Remat" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_invalid_conversion", "(", "const_tree", "fromtype", ",", "const_tree", "totype", ")", "{", "if", "(", "TYPE_CANONICAL", "(", "fromtype", ")", "!=", "NULL_TREE", ")", "fromtype", "=", "TYPE_CANONICAL", "(", "fromtype", ")", ";", "if", "(", "TYPE_CANONICAL", "(", "totype", ")", "!=", "NULL_TREE", ")", "totype", "=", "TYPE_CANONICAL", "(", "totype", ")", ";", "machine_mode", "frommode", "=", "TYPE_MODE", "(", "fromtype", ")", ";", "machine_mode", "tomode", "=", "TYPE_MODE", "(", "totype", ")", ";", "if", "(", "frommode", "!=", "tomode", ")", "{", "if", "(", "frommode", "==", "XOmode", ")", "return", "N_", "(", "\"invalid conversion from type %<__vector_quad%>\"", ")", ";", "if", "(", "tomode", "==", "XOmode", ")", "return", "N_", "(", "\"invalid conversion to type %<__vector_quad%>\"", ")", ";", "if", "(", "frommode", "==", "OOmode", ")", "return", "N_", "(", "\"invalid conversion from type %<__vector_pair%>\"", ")", ";", "if", "(", "tomode", "==", "OOmode", ")", "return", "N_", "(", "\"invalid conversion to type %<__vector_pair%>\"", ")", ";", "}", "else", "if", "(", "POINTER_TYPE_P", "(", "fromtype", ")", "&&", "POINTER_TYPE_P", "(", "totype", ")", ")", "{", "frommode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "fromtype", ")", ")", ";", "tomode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "totype", ")", ")", ";", "if", "(", "frommode", "!=", "tomode", "&&", "frommode", "!=", "VOIDmode", "&&", "tomode", "!=", "VOIDmode", ")", "{", "if", "(", "frommode", "==", "XOmode", ")", "return", "N_", "(", "\"invalid conversion from type %<* __vector_quad%>\"", ")", ";", "if", "(", "tomode", "==", "XOmode", ")", "return", "N_", "(", "\"invalid conversion to type %<* __vector_quad%>\"", ")", ";", "if", "(", "frommode", "==", "OOmode", ")", "return", "N_", "(", "\"invalid conversion from type %<* __vector_pair%>\"", ")", ";", "if", "(", "tomode", "==", "OOmode", ")", "return", "N_", "(", "\"invalid conversion to type %<* __vector_pair%>\"", ")", ";", "}", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_INVALID_CONVERSION", "." ]

[ "rs6000", "\"invalid conversion from type %<__vector_quad%>\"", "\"invalid conversion to type %<__vector_quad%>\"", "\"invalid conversion from type %<__vector_pair%>\"", "\"invalid conversion to type %<__vector_pair%>\"", "\"invalid conversion from type %<* __vector_quad%>\"", "\"invalid conversion to type %<* __vector_quad%>\"", "\"invalid conversion from type %<* __vector_pair%>\"", "\"invalid conversion to type %<* __vector_pair%>\"" ]

[]

[ "<s>", "bool", "AVRDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "PatmosInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Patmos", "::", "NOP", ")", ")", ".", "addReg", "(", "Patmos", "::", "NoRegister", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Patmos", "Patmos", "Patmos::NOP", "Patmos::NoRegister", "0" ]

[]

[ "<s>", "static", "void", "s390_output_indirect_thunk_function", "(", "unsigned", "int", "regno", ",", "bool", "z10_p", ")", "{", "tree", "decl", ";", "char", "thunk_label", "[", "32", "]", ";", "int", "i", ";", "if", "(", "z10_p", ")", "sprintf", "(", "thunk_label", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EXRL", ",", "regno", ")", ";", "else", "sprintf", "(", "thunk_label", ",", "TARGET_INDIRECT_BRANCH_THUNK_NAME_EX", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ",", "regno", ")", ";", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "thunk_label", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "DECL_IGNORED_P", "(", "decl", ")", "=", "1", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "cgraph_node", "::", "create", "(", "decl", ")", "->", "set_comdat_group", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "targetm", ".", "asm_out", ".", "unique_section", "(", "decl", ",", "0", ")", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "asm_out_file", ",", "thunk_label", ")", ";", "fputs", "(", "\"\\t.hidden\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "thunk_label", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_DECLARE_FUNCTION_NAME", "(", "asm_out_file", ",", "thunk_label", ",", "decl", ")", ";", "}", "else", "{", "switch_to_section", "(", "text_section", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "thunk_label", ")", ";", "}", "DECL_INITIAL", "(", "decl", ")", "=", "make_node", "(", "BLOCK", ")", ";", "current_function_decl", "=", "decl", ";", "allocate_struct_function", "(", "decl", ",", "false", ")", ";", "init_function_start", "(", "decl", ")", ";", "cfun", "->", "is_thunk", "=", "true", ";", "first_function_block_is_cold", "=", "false", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "asm_out_file", ",", "1", ")", ";", "if", "(", "flag_asynchronous_unwind_tables", "&&", "flag_dwarf2_cfi_asm", ")", "{", "fputs", "(", "\"\\t.cfi_signal_frame\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_return_column %d\\n\"", ",", "regno", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FPR15_REGNUM", ";", "i", "++", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.cfi_same_value %s\\n\"", ",", "reg_names", "[", "i", "]", ")", ";", "}", "if", "(", "z10_p", ")", "{", "if", "(", "!", "TARGET_CPU_Z10", ")", "{", "fputs", "(", "\"\\t.machine push\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.machine z10\\n\"", ",", "asm_out_file", ")", ";", "}", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode zarch\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\texrl\\t0,1f\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_ZARCH", ")", "fputs", "(", "\"\\t.machinemode esa\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "!", "TARGET_CPU_Z10", ")", "fputs", "(", "\"\\t.machine pop\\n\"", ",", "asm_out_file", ")", ";", "}", "else", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\tlarl\\t%%r%d,1f\\n\"", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tex\\t0,0(%%r%d)\\n\"", ",", "INDIRECT_BRANCH_THUNK_REGNUM", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "fputs", "(", "\"0:\\tj\\t0b\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"1:\\tbr\\t%%r%d\\n\"", ",", "regno", ")", ";", "final_end_function", "(", ")", ";", "init_insn_lengths", "(", ")", ";", "free_after_compilation", "(", "cfun", ")", ";", "set_cfun", "(", "NULL", ")", ";", "current_function_decl", "=", "NULL", ";", "}", "</s>" ]

[ "Output", "an", "indirect", "branch", "trampoline", "for", "target", "register", "REGNO", "." ]

[ "s390", "32", "1", "1", "1", "0", "0", "\"\\t.hidden\\t\"", "1", "\"\\t.cfi_signal_frame\\n\"", "\"\\t.cfi_return_column %d\\n\"", "0", "\"\\t.cfi_same_value %s\\n\"", "\"\\t.machine push\\n\"", "\"\\t.machine z10\\n\"", "\"\\t.machinemode zarch\\n\"", "\"\\texrl\\t0,1f\\n\"", "\"\\t.machinemode esa\\n\"", "\"\\t.machine pop\\n\"", "\"\\tlarl\\t%%r%d,1f\\n\"", "\"\\tex\\t0,0(%%r%d)\\n\"", "\"0:\\tj\\t0b\\n\"", "\"1:\\tbr\\t%%r%d\\n\"" ]

[]

[ "<s>", "static", "void", "replace_constant_pool_with_broadcast", "(", "rtx_insn", "*", "insn", ")", "{", "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "rtx", "x", "=", "*", "loc", ";", "rtx", "broadcast_mem", ",", "vec_dup", ",", "constant", ",", "first", ";", "machine_mode", "mode", ";", "if", "(", "!", "MEM_P", "(", "x", ")", "||", "!", "SYMBOL_REF_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "||", "!", "CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "continue", ";", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", ";", "constant", "=", "get_pool_constant", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "constant", ")", "!=", "CONST_VECTOR", ")", "return", ";", "if", "(", "GET_MODE", "(", "constant", ")", "!=", "mode", ")", "{", "constant", "=", "simplify_subreg", "(", "mode", ",", "constant", ",", "GET_MODE", "(", "constant", ")", ",", "0", ")", ";", "if", "(", "constant", "==", "NULL_RTX", "||", "GET_CODE", "(", "constant", ")", "!=", "CONST_VECTOR", ")", "return", ";", "}", "first", "=", "XVECEXP", "(", "constant", ",", "0", ",", "0", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "GET_MODE_NUNITS", "(", "mode", ")", ";", "++", "i", ")", "{", "rtx", "tmp", "=", "XVECEXP", "(", "constant", ",", "0", ",", "i", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "tmp", ",", "first", ")", ")", "return", ";", "}", "broadcast_mem", "=", "force_const_mem", "(", "GET_MODE_INNER", "(", "mode", ")", ",", "first", ")", ";", "vec_dup", "=", "gen_rtx_VEC_DUPLICATE", "(", "mode", ",", "broadcast_mem", ")", ";", "validate_change", "(", "insn", ",", "loc", ",", "vec_dup", ",", "0", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Replace", "all", "one-value", "const", "vector", "that", "are", "referenced", "by", "SYMBOL_REFs", "in", "x", "with", "embedded", "broadcast", ".", "i.e.transform", "vpaddq", ".LC0", "(", "%", "rip", ")", ",", "%", "zmm0", ",", "%", "zmm0", "ret", ".LC0", ":", ".quad", "3", ".quad", "3", ".quad", "3", ".quad", "3", ".quad", "3", ".quad", "3", ".quad", "3", ".quad", "3", "to", "vpaddq", ".LC0", "(", "%", "rip", ")", "{", "1to8", "}", ",", "%", "zmm0", ",", "%", "zmm0", "ret", ".LC0", ":", ".quad", "3" ]

[ "i386", "0", "0", "0", "0", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isMaskAndCmp0FoldingBeneficial", "(", "const", "Instruction", "&", "AndI", ")", "const", "{", "ConstantInt", "*", "Mask", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AndI", ".", "getOperand", "(", "1", ")", ")", ";", "if", "(", "!", "Mask", ")", "return", "false", ";", "return", "Mask", "->", "getUniqueInteger", "(", ")", ".", "isPowerOf2", "(", ")", ";", "}", "</s>" ]

[ "Return", "if", "the", "target", "supports", "combining", "a", "chain", "like", ":" ]

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

[]

[ "<s>", "static", "void", "arm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "if", "(", "TARGET_32BIT", ")", "arm32_output_mi_thunk", "(", "file", ",", "thunk", ",", "delta", ",", "vcall_offset", ",", "function", ")", ";", "else", "arm_thumb1_mi_thunk", "(", "file", ",", "thunk", ",", "delta", ",", "vcall_offset", ",", "function", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "add", "DELTA", "to", "the", "first", "argument", ",", "and", "then", "jump", "to", "FUNCTION", ".", "Used", "for", "C++", "multiple", "inheritance", "." ]

[ "arm" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZERO_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "combineSIGN_EXTEND_INREG", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "combineLOAD", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "combineVECTOR_SHUFFLE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "combineFP_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "BR_CCMASK", ":", "return", "combineBR_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "return", "combineSELECT_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "GET_CCMASK", ":", "return", "combineGET_CCMASK", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "return", "combineIntDIVREM", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::SIGN_EXTEND_INREG", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::LOAD", "ISD::STORE", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::FP_ROUND", "ISD::FP_EXTEND", "ISD::BSWAP", "SystemZISD::BR_CCMASK", "SystemZISD::SELECT_CCMASK", "SystemZISD::GET_CCMASK", "ISD::SDIV", "ISD::UDIV", "ISD::SREM", "ISD::UREM" ]

[]

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

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

[ "P2" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttr", "(", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "PPCFrameInfo", "::", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

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

[]

[ "<s>", "unsigned", "MipsRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "GPR64RegClassID", ":", "case", "Mips", "::", "DSPRRegClassID", ":", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "28", "-", "TFI", "->", "hasFP", "(", "MF", ")", ";", "}", "case", "Mips", "::", "FGR32RegClassID", ":", "return", "32", ";", "case", "Mips", "::", "AFGR64RegClassID", ":", "return", "16", ";", "case", "Mips", "::", "FGR64RegClassID", ":", "return", "32", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::GPR32RegClassID", "Mips::GPR64RegClassID", "Mips::DSPRRegClassID", "28", "Mips::FGR32RegClassID", "32", "Mips::AFGR64RegClassID", "16", "Mips::FGR64RegClassID", "32" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "unsigned", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "R600Operands", "::", "WRITE", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "ValueReg", ",", "AddrReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", ")", ";", "setImmOperand", "(", "Mov", ",", "R600Operands", "::", "SRC0_REL", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "R600", "R600Operands::WRITE", "0", "R600Operands::SRC0_REL", "1" ]

[]

[ "<s>", "static", "bool", "is_store_insn", "(", "rtx", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "return", "is_store_insn1", "(", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Determine", "if", "INSN", "stores", "to", "memory", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "int", "saved_regs_mentioned", "(", "rtx", "x", ")", "{", "int", "i", ";", "const", "char", "*", "fmt", ";", "RTX_CODE", "code", ";", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "i", "=", "REGNO", "(", "x", ")", ";", "return", "!", "call_used_regs", "[", "i", "]", ";", "case", "SUBREG", ":", "i", "=", "REGNO", "(", "SUBREG_REG", "(", "x", ")", ")", ";", "return", "!", "call_used_regs", "[", "i", "]", ";", "default", ":", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "saved_regs_mentioned", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "saved_regs_mentioned", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "there", "are", "regs", "mentioned", "in", "the", "insn", "that", "are", "not", "all", "in", "the", "call_used", "regs", ".", "This", "is", "part", "of", "the", "decision", "whether", "an", "insn", "can", "be", "put", "in", "the", "epilogue", "." ]

[ "cris", "1", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "void", "AVRMCCodeEmitter", "::", "emitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "const", "uint16_t", "*", "Words", "=", "reinterpret_cast", "<", "uint16_t", "const", "*", ">", "(", "&", "Val", ")", ";", "size_t", "WordCount", "=", "Size", "/", "2", ";", "for", "(", "int64_t", "i", "=", "WordCount", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "uint16_t", "Word", "=", "Words", "[", "i", "]", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0x00ff", ")", ">>", "0", ")", ";", "OS", "<<", "(", "uint8_t", ")", "(", "(", "Word", "&", "0xff00", ")", ">>", "8", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "AVR", "AVR", "2", "1", "0", "0x00ff", "0", "0xff00", "8" ]

[]

[ "<s>", "Register", "AMDGPURegisterBankInfo", "::", "handleD16VData", "(", "MachineIRBuilder", "&", "B", ",", "MachineRegisterInfo", "&", "MRI", ",", "Register", "Reg", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasUnpackedD16VMem", "(", ")", ")", "return", "Reg", ";", "const", "LLT", "S16", "=", "LLT", "::", "scalar", "(", "16", ")", ";", "LLT", "StoreVT", "=", "MRI", ".", "getType", "(", "Reg", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", "||", "StoreVT", ".", "getElementType", "(", ")", "!=", "S16", ")", "return", "Reg", ";", "auto", "Unmerge", "=", "B", ".", "buildUnmerge", "(", "S16", ",", "Reg", ")", ";", "SmallVector", "<", "Register", ",", "4", ">", "WideRegs", ";", "for", "(", "int", "I", "=", "0", ",", "E", "=", "Unmerge", "->", "getNumOperands", "(", ")", "-", "1", ";", "I", "!=", "E", ";", "++", "I", ")", "WideRegs", ".", "push_back", "(", "Unmerge", ".", "getReg", "(", "I", ")", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "int", "NumElts", "=", "StoreVT", ".", "getNumElements", "(", ")", ";", "return", "B", ".", "buildMerge", "(", "LLT", "::", "vector", "(", "NumElts", ",", "S32", ")", ",", "WideRegs", ")", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "AMDGPU", "16", "4", "0", "1", "32", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "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", "(", ")", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "prepare_extend_operands", "(", "rtx", "*", "operands", ",", "enum", "rtx_code", "code", ",", "machine_mode", "omode", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "gen_rtx_fmt_e", "(", "code", ",", "omode", ",", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Prepare", "OPERANDS", "for", "an", "extension", "using", "CODE", "to", "OMODE", ".", "Return", "true", "iff", "the", "move", "has", "been", "emitted", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_emit_forking", "(", "unsigned", "mask", ",", "bool", "is_call", ")", "{", "mask", "&=", "(", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", "|", "GOMP_DIM_MASK", "(", "GOMP_DIM_VECTOR", ")", ")", ";", "if", "(", "mask", ")", "{", "rtx", "op", "=", "GEN_INT", "(", "mask", "|", "(", "is_call", "<<", "GOMP_DIM_MAX", ")", ")", ";", "if", "(", "!", "is_call", ")", "emit_insn", "(", "gen_nvptx_fork", "(", "op", ")", ")", ";", "emit_insn", "(", "gen_nvptx_forked", "(", "op", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "forking", "instructions", "for", "MASK", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "LanaiRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "Lanai", "::", "RCA", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::RCA" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", ")", "{", "return", "false", ";", "}", "return", "(", "(", "VT1", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i64", ")", "&&", "(", "VT2", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "Hexagon", "Hexagon", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "void", "m32r_initialize_trampoline", "(", "rtx", "tramp", "ATTRIBUTE_UNUSED", ",", "rtx", "fnaddr", "ATTRIBUTE_UNUSED", ",", "rtx", "cxt", "ATTRIBUTE_UNUSED", ")", "{", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "m32r" ]

[]

[ "<s>", "void", "arm_emit_call_insn", "(", "rtx", "pat", ",", "rtx", "addr", ",", "bool", "sibcall", ")", "{", "rtx", "insn", ";", "insn", "=", "emit_call_insn", "(", "pat", ")", ";", "if", "(", "TARGET_VXWORKS_RTP", "&&", "flag_pic", "&&", "!", "sibcall", "&&", "SYMBOL_REF_P", "(", "addr", ")", "&&", "(", "SYMBOL_REF_DECL", "(", "addr", ")", "?", "!", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "addr", ")", ")", ":", "!", "SYMBOL_REF_LOCAL_P", "(", "addr", ")", ")", ")", "{", "require_pic_register", "(", "NULL_RTX", ",", "false", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "cfun", "->", "machine", "->", "pic_reg", ")", ";", "}", "if", "(", "TARGET_FDPIC", ")", "{", "rtx", "fdpic_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "FDPIC_REGNUM", ")", ";", "use_reg", "(", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ",", "fdpic_reg", ")", ";", "}", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "rtx", "*", "fusage", "=", "&", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "clobber_reg", "(", "fusage", ",", "gen_rtx_REG", "(", "word_mode", ",", "IP_REGNUM", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "call", "instruction", "with", "pattern", "PAT", ".", "ADDR", "is", "the", "address", "of", "the", "call", "target", "." ]

[ "arm" ]

[]

[ "<s>", "static", "std", "::", "string", "getGraphName", "(", "const", "SpillCostAnalysisGraph", "&", "G", ")", "{", "return", "\"scagraph\"", ";", "}", "</s>" ]

[ "Generate", "a", "title", "for", "the", "graph", "in", "DOT", "format", "." ]

[ "Patmos", "\"scagraph\"" ]

[]

[ "<s>", "bool", "requiresFrameIndexScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "void", "alpha_expand_unaligned_load_words", "(", "rtx", "*", "out_regs", ",", "rtx", "smem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "const", "i64", "=", "GEN_INT", "(", "64", ")", ";", "rtx", "ext_tmps", "[", "MAX_MOVE_WORDS", "]", ",", "data_regs", "[", "MAX_MOVE_WORDS", "+", "1", "]", ";", "rtx", "sreg", ",", "areg", ",", "tmp", ",", "smema", ";", "HOST_WIDE_INT", "i", ";", "smema", "=", "XEXP", "(", "smem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "smema", ")", "==", "LO_SUM", ")", "smema", "=", "force_reg", "(", "Pmode", ",", "smema", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "data_regs", "[", "i", "]", "=", "out_regs", "[", "i", "]", ";", "ext_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "}", "data_regs", "[", "words", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "smem", "=", "adjust_address", "(", "smem", ",", "GET_MODE", "(", "smem", ")", ",", "ofs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "smema", ",", "8", "*", "i", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "i", "]", ",", "tmp", ")", ";", "}", "tmp", "=", "change_address", "(", "smem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "smema", ",", "8", "*", "words", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "data_regs", "[", "words", "]", ",", "tmp", ")", ";", "sreg", "=", "copy_addr_to_reg", "(", "smema", ")", ";", "areg", "=", "expand_binop", "(", "DImode", ",", "and_optab", ",", "sreg", ",", "GEN_INT", "(", "7", ")", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "if", "(", "WORDS_BIG_ENDIAN", ")", "emit_move_insn", "(", "sreg", ",", "plus_constant", "(", "sreg", ",", "7", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "if", "(", "WORDS_BIG_ENDIAN", ")", "{", "emit_insn", "(", "gen_extqh_be", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extxl_be", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "i64", ",", "sreg", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_extxl_le", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "i64", ",", "sreg", ")", ")", ";", "emit_insn", "(", "gen_extqh_le", "(", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "+", "1", "]", ",", "sreg", ")", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "ext_tmps", "[", "i", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_EQ", "(", "DImode", ",", "areg", ",", "const0_rtx", ")", ",", "const0_rtx", ",", "ext_tmps", "[", "i", "]", ")", ")", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "{", "out_regs", "[", "i", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ext_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "</s>" ]

[ "Load", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", "." ]

[ "alpha", "8", "64", "1", "0", "0", "0", "0", "8", "0", "8", "1", "0", "7", "1", "7", "0", "1", "1", "0", "1" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "removeDeadCode", "(", ")", "{", "ValueVect", "BO", ";", "BO", ".", "push_back", "(", "&", "Fn", "->", "front", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "BO", ".", "size", "(", ")", ";", "++", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "]", ")", ";", "for", "(", "auto", "DTN", ":", "children", "<", "DomTreeNode", "*", ">", "(", "DT", "->", "getNode", "(", "B", ")", ")", ")", "BO", ".", "push_back", "(", "DTN", "->", "getBlock", "(", ")", ")", ";", "}", "for", "(", "unsigned", "i", "=", "BO", ".", "size", "(", ")", ";", "i", ">", "0", ";", "--", "i", ")", "{", "BasicBlock", "*", "B", "=", "cast", "<", "BasicBlock", ">", "(", "BO", "[", "i", "-", "1", "]", ")", ";", "BasicBlock", "::", "InstListType", "&", "IL", "=", "B", "->", "getInstList", "(", ")", ";", "typedef", "BasicBlock", "::", "InstListType", "::", "reverse_iterator", "reverse_iterator", ";", "ValueVect", "Ins", ";", "for", "(", "reverse_iterator", "I", "=", "IL", ".", "rbegin", "(", ")", ",", "E", "=", "IL", ".", "rend", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Ins", ".", "push_back", "(", "&", "*", "I", ")", ";", "for", "(", "ValueVect", "::", "iterator", "I", "=", "Ins", ".", "begin", "(", ")", ",", "E", "=", "Ins", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Instruction", "*", "In", "=", "cast", "<", "Instruction", ">", "(", "*", "I", ")", ";", "if", "(", "isInstructionTriviallyDead", "(", "In", ")", ")", "In", "->", "eraseFromParent", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "0", "0", "1" ]

[]

[ "<s>", "int", "barrier_align", "(", "rtx_insn", "*", "barrier_or_label", ")", "{", "if", "(", "!", "barrier_or_label", ")", "return", "0", ";", "if", "(", "LABEL_P", "(", "barrier_or_label", ")", "&&", "NEXT_INSN", "(", "barrier_or_label", ")", "&&", "JUMP_TABLE_DATA_P", "(", "NEXT_INSN", "(", "barrier_or_label", ")", ")", ")", "return", "2", ";", "if", "(", "BARRIER_P", "(", "barrier_or_label", ")", "&&", "PREV_INSN", "(", "barrier_or_label", ")", "&&", "JUMP_TABLE_DATA_P", "(", "PREV_INSN", "(", "barrier_or_label", ")", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "PREV_INSN", "(", "barrier_or_label", ")", ")", ";", "return", "(", "(", "optimize_size", "||", "(", "(", "unsigned", ")", "XVECLEN", "(", "pat", ",", "1", ")", "*", "GET_MODE_SIZE", "(", "GET_MODE", "(", "pat", ")", ")", "<=", "(", "unsigned", ")", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", ")", "?", "1", ":", "align_jumps_log", ")", ";", "}", "rtx_insn", "*", "next", "=", "next_active_insn", "(", "barrier_or_label", ")", ";", "if", "(", "!", "next", ")", "return", "0", ";", "rtx", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "if", "(", "optimize_size", ")", "return", "0", ";", "if", "(", "!", "TARGET_SH2", "||", "!", "optimize", ")", "return", "align_jumps_log", ";", "if", "(", "mdep_reorg_phase", ">", "SH_FIXUP_PCLOAD", ")", "{", "int", "slot", ",", "credit", ";", "bool", "jump_to_next", "=", "false", ";", "rtx_insn", "*", "prev", "=", "prev_real_insn", "(", "prev_active_insn", "(", "barrier_or_label", ")", ")", ";", "for", "(", "slot", "=", "2", ",", "credit", "=", "(", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", "+", "2", ";", "credit", ">=", "0", "&&", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", ";", "prev", "=", "prev_real_insn", "(", "prev", ")", ")", "{", "jump_to_next", "=", "false", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "CLOBBER", ")", "continue", ";", "if", "(", "rtx_sequence", "*", "prev_seq", "=", "dyn_cast", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", ")", "{", "prev", "=", "prev_seq", "->", "insn", "(", "1", ")", ";", "if", "(", "INSN_UID", "(", "prev", ")", "==", "INSN_UID", "(", "next", ")", ")", "{", "jump_to_next", "=", "true", ";", "continue", ";", "}", "}", "if", "(", "slot", "&&", "get_attr_in_delay_slot", "(", "prev", ")", "==", "IN_DELAY_SLOT_YES", ")", "slot", "=", "0", ";", "credit", "-=", "get_attr_length", "(", "prev", ")", ";", "}", "if", "(", "prev", "&&", "jump_to_label_p", "(", "prev", ")", ")", "{", "rtx_insn", "*", "x", ";", "if", "(", "jump_to_next", "||", "next_real_insn", "(", "JUMP_LABEL", "(", "prev", ")", ")", "==", "next", "||", "JUMP_LABEL", "(", "prev", ")", "==", "next_nonnote_insn", "(", "next", ")", "||", "(", "x", "=", "(", "NEXT_INSN", "(", "NEXT_INSN", "(", "PREV_INSN", "(", "prev", ")", ")", ")", ")", ",", "(", "INSN_P", "(", "x", ")", "&&", "(", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_block_branch_redirect", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_indirect_jump_scratch", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_stuff_delay_slot", ")", ")", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "prev", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "credit", "-", "slot", ">=", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "PC", "?", "2", ":", "0", ")", ")", "return", "0", ";", "}", "}", "}", "return", "align_jumps_log", ";", "}", "</s>" ]

[ "BARRIER_OR_LABEL", "is", "either", "a", "BARRIER", "or", "a", "CODE_LABEL", "immediately", "following", "a", "barrier", ".", "Return", "the", "base", "2", "logarithm", "of", "the", "desired", "alignment", "." ]

[ "sh", "0", "2", "1", "1", "2", "1", "0", "1", "0", "0", "2", "1", "2", "2", "0", "1", "0", "0", "0", "2", "0", "0" ]

[]

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

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

[ "Sparc", "Sparc", "\"code size not handled\"", "0", "SP::BA", "SP::BCOND", "SP::FBCOND" ]

[]

[ "<s>", "unsigned", "LEGInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "assert", "(", "0", "&&", "\"Unimplemented\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "0", "\"Unimplemented\"", "0" ]

[]

[ "<s>", "void", "rs6000_emit_le_vsx_store", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "if", "(", "mode", "==", "TImode", "||", "mode", "==", "V1TImode", ")", "{", "mode", "=", "V2DImode", ";", "dest", "=", "adjust_address", "(", "dest", ",", "V2DImode", ",", "0", ")", ";", "source", "=", "gen_lowpart", "(", "V2DImode", ",", "source", ")", ";", "}", "rtx", "tmp", "=", "gen_reg_rtx_and_attrs", "(", "source", ")", ";", "rs6000_emit_le_vsx_permute", "(", "tmp", ",", "source", ",", "mode", ")", ";", "rs6000_emit_le_vsx_permute", "(", "dest", ",", "tmp", ",", "mode", ")", ";", "}", "</s>" ]

[ "Emit", "a", "little-endian", "store", "to", "vector", "memory", "location", "DEST", "from", "VSX", "register", "SOURCE", "in", "mode", "MODE", ".", "The", "store", "is", "done", "with", "two", "permuting", "insn", "'s", "that", "represent", "an", "xxpermdi", "and", "an", "stxvd2x", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "Candidate", "&", "back", "(", ")", "{", "return", "rbegin", "(", ")", "->", "second", ".", "back", "(", ")", ";", "}", "</s>" ]

[ "back", "-", "Get", "the", "last", "character", "in", "the", "string", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "enableCalleeSaveSkip", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "auto", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "assert", "(", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoReturn", ")", "&&", "F", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "&&", "!", "F", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "UWTable", ")", ")", ";", "(", "void", ")", "F", ";", "return", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "noreturnStackElim", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "can", "safely", "skip", "saving", "callee-saved", "registers", "for", "noreturn", "nounwind", "functions", "." ]

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

[]

[ "<s>", "bool", "isOffsetOfLocal", "(", ")", "const", "override", "{", "return", "isImm", "(", ")", "&&", "Imm", ".", "LocalRef", ";", "}", "</s>" ]

[ "isOffsetOfLocal", "-", "Do", "we", "need", "to", "emit", "code", "to", "get", "the", "offset", "of", "the", "local", "variable", ",", "rather", "than", "its", "value", "?", "Only", "valid", "when", "parsing", "MS-style", "inline", "assembly", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCondBrFoldingPass", ")", "addPass", "(", "createX86CondBrFolding", "(", ")", ")", ";", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableMachineCombinerPass", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "addPass", "(", "createX86CmovConverterPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

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

[]

[ "<s>", "void", "SHUXIInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SHUXI", "::", "GPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SHUXI", "::", "CPYrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "SHUXI::GPRegsRegClass", "SHUXI::CPYrr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "rtx", "get_replacement", "(", "struct", "reg_replace", "*", "r", ")", "{", "if", "(", "r", "->", "n_allocated", "==", "r", "->", "n_in_use", ")", "r", "->", "replacement", "[", "r", "->", "n_allocated", "++", "]", "=", "gen_reg_rtx", "(", "r", "->", "mode", ")", ";", "return", "r", "->", "replacement", "[", "r", "->", "n_in_use", "++", "]", ";", "}", "</s>" ]

[ "Allocate", "or", "reuse", "a", "replacement", "in", "R", "and", "return", "the", "rtx", "." ]

[ "nvptx" ]

[]

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

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

[ "TPC", "TPC" ]

[]

[ "<s>", "const", "CallLowering", "*", "RISCVSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "loongarch_output_external", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ")", "{", "default_elf_asm_output_external", "(", "file", ",", "decl", ",", "name", ")", ";", "if", "(", "TREE_SYMBOL_REFERENCED", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", "{", "if", "(", "loongarch_in_small_data_p", "(", "decl", ")", ")", "{", "fputs", "(", "\"\\t.extern\\t\"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Implement", "ASM_OUTPUT_EXTERNAL", "." ]

[ "loongarch", "\"\\t.extern\\t\"", "\", \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "ft32_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "FT32_R0", ")", ";", "}", "</s>" ]

[ "Handle", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "We", "always", "return", "values", "in", "register", "$", "r0", "for", "ft32", "." ]

[ "ft32" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_direct", "(", "enum", "insn_code", "icode", ",", "rtx", "target", ",", "tree", "exp", ",", "bool", "has_target_p", ")", "{", "struct", "expand_operand", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "int", "opno", ",", "argno", ";", "opno", "=", "0", ";", "if", "(", "has_target_p", ")", "create_output_operand", "(", "&", "ops", "[", "opno", "++", "]", ",", "target", ",", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ")", ";", "gcc_assert", "(", "opno", "+", "call_expr_nargs", "(", "exp", ")", "==", "insn_data", "[", "icode", "]", ".", "n_generator_args", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "mips_prepare_builtin_arg", "(", "&", "ops", "[", "opno", "++", "]", ",", "exp", ",", "argno", ")", ";", "return", "mips_expand_builtin_insn", "(", "icode", ",", "opno", ",", "ops", ",", "has_target_p", ")", ";", "}", "</s>" ]

[ "Expand", "a", "MIPS_BUILTIN_DIRECT", "function", ".", "ICODE", "is", "the", "code", "of", "the", ".md", "pattern", "and", "ARGLIST", "is", "the", "list", "of", "function", "arguments", ".", "TARGET", ",", "if", "nonnull", ",", "suggests", "a", "good", "place", "to", "put", "the", "result", ".", "HAS_TARGET", "indicates", "the", "function", "must", "return", "something", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "shouldSink", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "isPredicated", "(", "MI", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "Next", "=", "&", "MI", ";", "++", "Next", ";", "unsigned", "SrcReg", ",", "SrcReg2", ";", "int", "CmpMask", ",", "CmpValue", ";", "bool", "IsThumb1", ";", "if", "(", "Next", "!=", "MI", ".", "getParent", "(", ")", "->", "end", "(", ")", "&&", "analyzeCompare", "(", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpMask", ",", "CmpValue", ")", "&&", "isRedundantFlagInstr", "(", "&", "*", "Next", ",", "SrcReg", ",", "SrcReg2", ",", "CmpValue", ",", "&", "MI", ",", "IsThumb1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "should", "be", "sunk", "by", "MachineSink", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "CCAssignFnForReturn", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "ARM", "ARM", "ISD::OutputArg", "16" ]

[]

[ "<s>", "static", "bool", "sh_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "regno", "==", "FIRST_RET_REG", "||", "(", "TARGET_SH2E", "&&", "regno", "==", "FIRST_FP_RET_REG", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "N", "is", "a", "possible", "register", "number", "of", "function", "value", "." ]

[ "sh" ]

[]

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

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

[ "AVR", "\"AVR Assembly Printer\"" ]

[]

[ "<s>", "unsigned", "Cpu0MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "32" ]

[]

[ "<s>", "void", "aarch64_init_fcmla_laneq_builtins", "(", "void", ")", "{", "unsigned", "int", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "aarch64_fcmla_lane_builtin_data", ")", ";", "++", "i", ")", "{", "aarch64_fcmla_laneq_builtin_datum", "*", "d", "=", "&", "aarch64_fcmla_lane_builtin_data", "[", "i", "]", ";", "tree", "argtype", "=", "aarch64_simd_builtin_type", "(", "d", "->", "mode", ",", "qualifier_none", ")", ";", "machine_mode", "quadmode", "=", "GET_MODE_2XWIDER_MODE", "(", "d", "->", "mode", ")", ".", "require", "(", ")", ";", "tree", "quadtype", "=", "aarch64_simd_builtin_type", "(", "quadmode", ",", "qualifier_none", ")", ";", "tree", "lanetype", "=", "aarch64_simd_builtin_type", "(", "SImode", ",", "qualifier_lane_pair_index", ")", ";", "tree", "ftype", "=", "build_function_type_list", "(", "argtype", ",", "argtype", ",", "argtype", ",", "quadtype", ",", "lanetype", ",", "NULL_TREE", ")", ";", "tree", "attrs", "=", "aarch64_get_attributes", "(", "FLAG_FP", ",", "d", "->", "mode", ")", ";", "tree", "fndecl", "=", "aarch64_general_add_builtin", "(", "d", "->", "name", ",", "ftype", ",", "d", "->", "fcode", ",", "attrs", ")", ";", "aarch64_builtin_decls", "[", "d", "->", "fcode", "]", "=", "fndecl", ";", "}", "}", "</s>" ]

[ "Due", "to", "the", "architecture", "not", "providing", "lane", "variant", "of", "the", "lane", "instructions", "for", "fcmla", "we", "ca", "n't", "use", "the", "standard", "simd", "builtin", "expansion", "code", ",", "but", "we", "still", "want", "the", "majority", "of", "the", "validation", "that", "would", "normally", "be", "done", "." ]

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

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "(", "Kind", "==", "Register", "||", "Kind", "==", "CCOut", ")", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isIndirectCall", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Hexagon", "::", "J2_callr", ":", "case", "Hexagon", "::", "J2_callrf", ":", "case", "Hexagon", "::", "J2_callrt", ":", "case", "Hexagon", "::", "PS_call_nr", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "callsite", "is", "an", "indirect", "call", "." ]

[ "Hexagon", "Hexagon", "Hexagon::J2_callr", "Hexagon::J2_callrf", "Hexagon::J2_callrt", "Hexagon::PS_call_nr" ]

[]

[ "<s>", "static", "SDValue", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "const", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "RVLocs", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ",", "4", ">", "ResultMemLocs", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "ResultMemLocs", ".", "push_back", "(", "std", "::", "make_pair", "(", "VA", ".", "getLocMemOffset", "(", ")", ",", "InVals", ".", "size", "(", ")", ")", ")", ";", "InVals", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "}", "}", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ResultMemLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "offset", "=", "ResultMemLocs", "[", "i", "]", ".", "first", ";", "unsigned", "index", "=", "ResultMemLocs", "[", "i", "]", ".", "second", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Chain", ",", "DAG", ".", "getConstant", "(", "offset", "/", "4", ",", "MVT", "::", "i32", ")", "}", ";", "SDValue", "load", "=", "DAG", ".", "getNode", "(", "XCoreISD", "::", "LDWSP", ",", "dl", ",", "VTs", ",", "Ops", ")", ";", "InVals", "[", "index", "]", "=", "load", ";", "MemOpChains", ".", "push_back", "(", "load", ".", "getValue", "(", "1", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "XCore", "4", "0", "1", "2", "0", "4", "0", "MVT::i32", "MVT::Other", "4", "MVT::i32", "XCoreISD::LDWSP", "1", "ISD::TokenFactor", "MVT::Other" ]

[]

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

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

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

[]

[ "<s>", "void", "frv_ifcvt_machdep_init", "(", "void", "*", "ce_info", "ATTRIBUTE_UNUSED", ")", "{", "frv_ifcvt", ".", "added_insns_list", "=", "NULL_RTX", ";", "frv_ifcvt", ".", "cur_scratch_regs", "=", "0", ";", "frv_ifcvt", ".", "num_nested_cond_exec", "=", "0", ";", "frv_ifcvt", ".", "cr_reg", "=", "NULL_RTX", ";", "frv_ifcvt", ".", "nested_cc_reg", "=", "NULL_RTX", ";", "frv_ifcvt", ".", "extra_int_cr", "=", "NULL_RTX", ";", "frv_ifcvt", ".", "extra_fp_cr", "=", "NULL_RTX", ";", "frv_ifcvt", ".", "last_nested_if_cr", "=", "NULL_RTX", ";", "}", "</s>" ]

[ "Initialize", "machine-specific", "if-conversion", "data", ".", "On", "the", "FR-V", ",", "we", "do", "n't", "have", "any", "extra", "fields", "per", "se", ",", "but", "it", "is", "useful", "hook", "to", "initialize", "the", "static", "storage", "." ]

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

[]

[ "<s>", "void", "MCS51DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "N", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "int", "cr16_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "cr16_compute_save_regs", "(", ")", ";", "cr16_compute_frame", "(", ")", ";", "if", "(", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", ")", "return", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "else", "if", "(", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "FRAME_POINTER_REGNUM", ")", ")", "return", "(", "current_frame_info", ".", "reg_size", "+", "current_frame_info", ".", "var_size", ")", ";", "else", "if", "(", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", ")", "&&", "(", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", ")", "return", "(", "current_frame_info", ".", "reg_size", "+", "current_frame_info", ".", "var_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "(", "HOST_WIDE_INT", ")", "crtl", "->", "outgoing_args_size", ":", "0", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "INITIAL_ELIMINATION_OFFSET", ",", "return", "the", "OFFSET", "." ]

[ "cr16", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "hasAndNotCompare", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Subtarget", ".", "hasBMI", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "should", "transform", ":", "(", "X", "&", "Y", ")", "==", "Y", "�", "?", "(", "~X", "&", "Y", ")", "==", "0", "(", "X", "&", "Y", ")", "!", "=", "Y", "�", "?", "(", "~X", "&", "Y", ")", "!", "=", "0", "." ]

[ "X86", "X86", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "Legalizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "rtx", "gen_mhi", "(", "void", ")", "{", "return", "gen_rtx_REG", "(", "SImode", ",", "TARGET_BIG_ENDIAN", "?", "58", ":", "59", ")", ";", "}", "</s>" ]

[ "Return", "a", "REG", "rtx", "for", "mhi", ".", "N.B", ".", "the", "gcc-internal", "representation", "may", "differ", "from", "the", "hardware", "register", "number", "in", "order", "to", "allow", "the", "generic", "code", "to", "correctly", "split", "the", "concatenation", "of", "mhi", "and", "mlo", "." ]

[ "arc", "58", "59" ]

[]

[ "<s>", "unsigned", "XNCMRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "llvm_unreachable", "(", "0", ")", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "0" ]

[]

[ "<s>", "bool", "CAHPAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "CAHPOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHPOperand::createToken", "\"unexpected token\"" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "isLSRCostLess", "(", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "if", "(", "!", "LsrNoInsnsCost", ")", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "ImmCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "ImmCost", ",", "C2", ".", "SetupCost", ")", ";", "else", "return", "TargetTransformInfoImplBase", "::", "isLSRCostLess", "(", "C1", ",", "C2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "case", "'c'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "\"no_hash\"", ")", ";", "return", "false", ";", "case", "'P'", ":", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'Q'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isLittleEndian", "(", ")", ")", "break", ";", "case", "'R'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isBigEndian", "(", ")", ")", "break", ";", "case", "'H'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "1", "0", "0", "\"no_hash\"", "1", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon generate \\\"insert\\\" instructions\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon generate \\\"insert\\\" instructions\"" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "auto", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_CALL", ")", "{", "OutMI", ".", "setOpcode", "(", "TII", "->", "pseudoToMCOpcode", "(", "AMDGPU", "::", "S_SWAPPC_B64", ")", ")", ";", "MCOperand", "Dest", ",", "Src", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ",", "Dest", ")", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ",", "Src", ")", ";", "OutMI", ".", "addOperand", "(", "Dest", ")", ";", "OutMI", ".", "addOperand", "(", "Src", ")", ";", "return", ";", "}", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_TCRETURN", ")", "{", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "}", "int", "MCOpcode", "=", "TII", "->", "pseudoToMCOpcode", "(", "Opcode", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64", "AMDGPU::SI_CALL", "AMDGPU::S_SWAPPC_B64", "0", "1", "AMDGPU::SI_TCRETURN", "AMDGPU::S_SETPC_B64", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"" ]

[]

[ "<s>", "int", "sparc_absnegfloat_split_legitimate", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "y", ")", "!=", "REG", ")", "return", "0", ";", "if", "(", "REGNO", "(", "x", ")", "==", "REGNO", "(", "y", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "x", "and", "y", "are", "some", "kind", "of", "REG", "and", "they", "refer", "to", "different", "hard", "registers", ".", "This", "test", "is", "guaranteed", "to", "be", "run", "after", "reload", "." ]

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "HexagonISD", "::", "OP_BEGIN", "&&", "Opc", "<", "HexagonISD", "::", "OP_END", ")", "errs", "(", ")", "<<", "\"Check for a non-legal type in this operation\\n\"", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "return", "LowerREADCYCLECOUNTER", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::OP_BEGIN", "HexagonISD::OP_END", "\"Check for a non-legal type in this operation\\n\"", "\"Should not custom lower this!\"", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SRA", "ISD::SHL", "ISD::SRL", "ISD::ConstantPool", "ISD::JumpTable", "ISD::EH_RETURN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GLOBAL_OFFSET_TABLE", "ISD::VASTART", "ISD::LOAD", "ISD::DYNAMIC_STACKALLOC", "ISD::SETCC", "ISD::VSELECT", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "ISD::INLINEASM", "ISD::PREFETCH", "ISD::READCYCLECOUNTER" ]

[]

[ "<s>", "unsigned", "AMDGPUIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "Len", ")", "const", "{", "if", "(", "!", "StringRef", "(", "Name", ",", "Len", ")", ".", "startswith", "(", "\"llvm.\"", ")", ")", "return", "0", ";", "AMDGPUIntrinsic", "::", "ID", "IntrinsicID", "=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ";", "IntrinsicID", "=", "getIntrinsicForGCCBuiltin", "(", "\"AMDGPU\"", ",", "Name", ")", ";", "if", "(", "IntrinsicID", "!=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ")", "{", "return", "IntrinsicID", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "AMDGPU", "AMDGPU", "\"llvm.\"", "0", "AMDGPUIntrinsic::ID", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "\"AMDGPU\"", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "0" ]

[]