Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "unsigned", "SICMCCodeEmitter", "::", "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", "." ]

[ "SIC", "SIC", "32" ]

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "if", "(", "processMachineBasicBlock", "(", "MBB", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "NVPTXTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "UP", ".", "Threshold", "/", "4", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "4" ]

[]

[ "<s>", "static", "tree", "alpha_fold_builtin_extxx", "(", "tree", "op", "[", "]", ",", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ",", "unsigned", "HOST_WIDE_INT", "bytemask", ",", "bool", "is_high", ")", "{", "long", "zap_const", "=", "2", ";", "tree", "*", "zap_op", "=", "NULL", ";", "if", "(", "op_const", "&", "2", ")", "{", "unsigned", "HOST_WIDE_INT", "loc", ";", "loc", "=", "opint", "[", "1", "]", "&", "7", ";", "loc", "*=", "BITS_PER_UNIT", ";", "if", "(", "loc", "!=", "0", ")", "{", "if", "(", "op_const", "&", "1", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", "=", "opint", "[", "0", "]", ";", "if", "(", "is_high", ")", "temp", "<<=", "loc", ";", "else", "temp", ">>=", "loc", ";", "opint", "[", "0", "]", "=", "temp", ";", "zap_const", "=", "3", ";", "}", "}", "else", "zap_op", "=", "op", ";", "}", "opint", "[", "1", "]", "=", "bytemask", ";", "return", "alpha_fold_builtin_zapnot", "(", "zap_op", ",", "opint", ",", "zap_const", ")", ";", "}", "</s>" ]

[ "Fold", "the", "builtins", "for", "the", "EXT", "family", "of", "instructions", "." ]

[ "alpha", "2", "2", "1", "7", "0", "1", "0", "0", "3", "1" ]

[]

[ "<s>", "static", "bool", "noncall_uses_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "insn", ",", "rtx", "*", "set", ")", "{", "*", "set", "=", "NULL_RTX", ";", "rtx", "reg2", "=", "sfunc_uses_reg", "(", "insn", ")", ";", "if", "(", "reg2", "&&", "REGNO", "(", "reg2", ")", "==", "REGNO", "(", "reg", ")", ")", "{", "rtx", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", "&&", "REG_P", "(", "SET_DEST", "(", "pattern", ")", ")", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "*", "set", "=", "pattern", ";", "return", "false", ";", "}", "if", "(", "!", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "pattern", "=", "single_set", "(", "insn", ")", ";", "if", "(", "pattern", "&&", "REG_P", "(", "SET_DEST", "(", "pattern", ")", ")", "&&", "REGNO", "(", "reg", ")", "==", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "{", "rtx", "par", ",", "part", ";", "int", "i", ";", "*", "set", "=", "pattern", ";", "par", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "par", ")", "==", "PARALLEL", ")", "for", "(", "i", "=", "XVECLEN", "(", "par", ",", "0", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "part", "=", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "part", ")", "!=", "SET", "&&", "reg_mentioned_p", "(", "reg", ",", "part", ")", ")", "return", "true", ";", "}", "return", "reg_mentioned_p", "(", "reg", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "}", "return", "true", ";", "}", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "{", "for", "(", "int", "i", "=", "XVECLEN", "(", "pattern", ",", "0", ")", "-", "1", ";", "i", ">=", "1", ";", "i", "--", ")", "if", "(", "reg_mentioned_p", "(", "reg", ",", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "pattern", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "SET", ")", "{", "if", "(", "reg_mentioned_p", "(", "reg", ",", "SET_DEST", "(", "pattern", ")", ")", ")", "{", "if", "(", "!", "REG_P", "(", "SET_DEST", "(", "pattern", ")", ")", "||", "REGNO", "(", "reg", ")", "!=", "REGNO", "(", "SET_DEST", "(", "pattern", ")", ")", ")", "return", "true", ";", "*", "set", "=", "pattern", ";", "}", "pattern", "=", "SET_SRC", "(", "pattern", ")", ";", "}", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "CALL", "||", "!", "MEM_P", "(", "XEXP", "(", "pattern", ",", "0", ")", ")", "||", "!", "rtx_equal_p", "(", "reg", ",", "XEXP", "(", "XEXP", "(", "pattern", ",", "0", ")", ",", "0", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "See", "if", "the", "only", "way", "in", "which", "INSN", "uses", "REG", "is", "by", "calling", "it", ",", "or", "by", "setting", "it", "while", "calling", "it", ".", "Set", "*", "SET", "to", "a", "SET", "rtx", "if", "the", "register", "is", "set", "by", "INSN", "." ]

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

[]

[ "<s>", "bool", "arm_const_double_by_parts", "(", "rtx", "val", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "val", ")", ";", "rtx", "part", ";", "if", "(", "optimize_size", "||", "arm_ld_sched", ")", "return", "true", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "part", "=", "gen_highpart_mode", "(", "SImode", ",", "mode", ",", "val", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "part", ")", ")", ";", "if", "(", "const_ok_for_arm", "(", "INTVAL", "(", "part", ")", ")", "||", "const_ok_for_arm", "(", "~", "INTVAL", "(", "part", ")", ")", ")", "return", "true", ";", "part", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "part", ")", ")", ";", "if", "(", "const_ok_for_arm", "(", "INTVAL", "(", "part", ")", ")", "||", "const_ok_for_arm", "(", "~", "INTVAL", "(", "part", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "worthwhile", "to", "split", "a", "64-bit", "constant", "into", "two", "32-bit", "operations", ".", "This", "is", "the", "case", "if", "optimizing", "for", "size", ",", "or", "if", "we", "have", "load", "delay", "slots", ",", "or", "if", "one", "32-bit", "part", "can", "be", "done", "with", "a", "single", "data", "operation", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "AVRInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "{", "continue", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AVR", "::", "RJMPk", "&&", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", "==", "AVRCC", "::", "COND_INVALID", ")", "{", "break", ";", "}", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "0", "AVR::RJMPk", "AVRCC::COND_INVALID" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "SmallVector", "<", "MachineOperand", ",", "4", ">", "ThisCond", ";", "ThisCond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "const", "MachineOperand", "*", "ThisTarget", ";", "if", "(", "!", "isBranch", "(", "I", ",", "ThisCond", ",", "ThisTarget", ")", ")", "return", "true", ";", "if", "(", "!", "ThisTarget", "->", "isMBB", "(", ")", ")", "return", "true", ";", "if", "(", "ThisCond", "[", "0", "]", ".", "getImm", "(", ")", "==", "RISCV", "::", "CCMASK_ANY", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "ThisTarget", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "0", ";", "TBB", "=", "ThisTarget", "->", "getMBB", "(", ")", ";", "continue", ";", "}", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "ThisTarget", "->", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "ThisCond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "(", "I", "->", "getNumExplicitOperands", "(", ")", ")", ";", "i", "++", ")", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "<=", "4", ")", ";", "assert", "(", "TBB", ")", ";", "if", "(", "TBB", "!=", "ThisTarget", "->", "getMBB", "(", ")", ")", "return", "true", ";", "unsigned", "OldCond", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "OldCond", "==", "ThisCond", "[", "0", "]", ".", "getImm", "(", ")", ")", "continue", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "4", "0", "0", "RISCV::CCMASK_ANY", "0", "0", "0", "4", "0", "0" ]

[]

[ "<s>", "bool", "NyuziAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Mnemonic", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "NyuziOperand", "::", "createToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "for", "(", ";", ";", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Mnemonic", ")", ")", "return", "true", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "Comma", ")", ")", "break", ";", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "NyuziOperand::createToken" ]

[]

[ "<s>", "static", "rtx", "avr_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "const", "char", "*", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "unsigned", "int", "id", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "const", "struct", "avr_builtin_description", "*", "d", "=", "&", "avr_bdesc", "[", "id", "]", ";", "tree", "arg0", ";", "rtx", "op0", ";", "gcc_assert", "(", "id", "<", "AVR_BUILTIN_COUNT", ")", ";", "switch", "(", "id", ")", "{", "case", "AVR_BUILTIN_NOP", ":", "emit_insn", "(", "gen_nopv", "(", "GEN_INT", "(", "1", ")", ")", ")", ";", "return", "0", ";", "case", "AVR_BUILTIN_DELAY_CYCLES", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_delay_cycles", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_NOPS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "error", "(", "\"%s expects a compile time integer constant\"", ",", "bname", ")", ";", "else", "avr_expand_nops", "(", "op0", ")", ";", "return", "NULL_RTX", ";", "}", "case", "AVR_BUILTIN_INSERT_BITS", ":", "{", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op0", ")", ")", "{", "error", "(", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", ",", "bname", ")", ";", "return", "target", ";", "}", "break", ";", "}", "case", "AVR_BUILTIN_ROUNDHR", ":", "case", "AVR_BUILTIN_ROUNDUHR", ":", "case", "AVR_BUILTIN_ROUNDR", ":", "case", "AVR_BUILTIN_ROUNDUR", ":", "case", "AVR_BUILTIN_ROUNDLR", ":", "case", "AVR_BUILTIN_ROUNDULR", ":", "case", "AVR_BUILTIN_ROUNDLLR", ":", "case", "AVR_BUILTIN_ROUNDULLR", ":", "case", "AVR_BUILTIN_ROUNDHK", ":", "case", "AVR_BUILTIN_ROUNDUHK", ":", "case", "AVR_BUILTIN_ROUNDK", ":", "case", "AVR_BUILTIN_ROUNDUK", ":", "case", "AVR_BUILTIN_ROUNDLK", ":", "case", "AVR_BUILTIN_ROUNDULK", ":", "case", "AVR_BUILTIN_ROUNDLLK", ":", "case", "AVR_BUILTIN_ROUNDULLK", ":", "if", "(", "TREE_CODE", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", "!=", "INTEGER_CST", ")", "break", ";", "int", "rbit", "=", "(", "int", ")", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "rbit", ">=", "(", "int", ")", "GET_MODE_FBIT", "(", "mode", ")", ")", "{", "warning", "(", "OPT_Wextra", ",", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", ",", "rbit", ",", "GET_MODE_FBIT", "(", "mode", ")", ")", ";", "return", "expand_expr", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "NULL_RTX", ",", "mode", ",", "EXPAND_NORMAL", ")", ";", "}", "else", "if", "(", "rbit", "<=", "-", "(", "int", ")", "GET_MODE_IBIT", "(", "mode", ")", ")", "{", "warning", "(", "0", ",", "\"rounding result will always be 0\"", ")", ";", "return", "CONST0_RTX", "(", "mode", ")", ";", "}", "break", ";", "}", "if", "(", "d", "->", "icode", "==", "CODE_FOR_nothing", "&&", "DECL_ASSEMBLER_NAME", "(", "get_callee_fndecl", "(", "exp", ")", ")", "!=", "NULL_TREE", ")", "{", "return", "expand_call", "(", "exp", ",", "target", ",", "ignore", ")", ";", "}", "gcc_assert", "(", "d", "->", "icode", "!=", "CODE_FOR_nothing", ")", ";", "gcc_assert", "(", "d", "->", "n_args", "==", "call_expr_nargs", "(", "exp", ")", ")", ";", "if", "(", "d", "->", "n_args", "==", "0", ")", "{", "emit_insn", "(", "(", "GEN_FCN", "(", "d", "->", "icode", ")", ")", "(", "target", ")", ")", ";", "return", "NULL_RTX", ";", "}", "return", "avr_default_expand_builtin", "(", "d", "->", "icode", ",", "exp", ",", "target", ")", ";", "}", "</s>" ]

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "avr", "0", "1", "0", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time integer constant\"", "0", "\"%s expects a compile time long integer constant\"", "\" as first argument\"", "1", "1", "\"rounding to %d bits has no effect for \"", "\"fixed-point value with %d fractional bits\"", "0", "0", "\"rounding result will always be 0\"", "0" ]

[]

[ "<s>", "static", "bool", "xtensa_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "(", "unsigned", ")", "(", "GP_RETURN_LAST", "-", "GP_RETURN_FIRST", "+", "1", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "xtensa", "1" ]

[]

[ "<s>", "unsigned", "constant_generates_xxspltiw", "(", "vec_const_128bit_type", "*", "vsx_const", ")", "{", "if", "(", "!", "TARGET_SPLAT_WORD_CONSTANT", "||", "!", "TARGET_PREFIXED", "||", "!", "TARGET_VSX", ")", "return", "0", ";", "if", "(", "!", "vsx_const", "->", "all_words_same", ")", "return", "0", ";", "if", "(", "vsx_const", "->", "all_bytes_same", ")", "return", "0", ";", "if", "(", "vsx_const", "->", "all_half_words_same", ")", "{", "unsigned", "short", "h_word", "=", "vsx_const", "->", "half_words", "[", "0", "]", ";", "short", "sign_h_word", "=", "(", "(", "h_word", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "if", "(", "EASY_VECTOR_15", "(", "sign_h_word", ")", ")", "return", "0", ";", "}", "unsigned", "int", "word", "=", "vsx_const", "->", "words", "[", "0", "]", ";", "int", "sign_word", "=", "(", "(", "word", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "EASY_VECTOR_15", "(", "sign_word", ")", ")", "return", "0", ";", "return", "vsx_const", "->", "words", "[", "0", "]", ";", "}", "</s>" ]

[ "Determine", "if", "a", "vector", "constant", "can", "be", "loaded", "with", "XXSPLTIW", ".", "Return", "zero", "if", "the", "XXSPLTIW", "instruction", "can", "not", "be", "used", ".", "Otherwise", "return", "the", "immediate", "value", "to", "be", "used", "with", "the", "XXSPLTIW", "instruction", "." ]

[ "rs6000", "0", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0", "0", "0xffffffff", "0x80000000", "0x80000000", "0", "0" ]

[]

[ "<s>", "riscv_vector", "::", "vlmul_type", "get_vlmul", "(", ")", "const", "{", "return", "m_vlmul", ";", "}", "</s>" ]

[ "Helper", "function", "to", "get", "VLMUL", "operand", ".", "We", "always", "have", "VLMUL", "value", "for", "all", "RVV", "instructions", "that", "have", "VTYPE", "OP", "." ]

[ "riscv", "riscv_vector::vlmul_type" ]

[]

[ "<s>", "const", "char", "*", "output_a_rotate", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "rotate_amount", "=", "operands", "[", "2", "]", ";", "enum", "shift_mode", "rotate_mode", ";", "enum", "shift_type", "rotate_type", ";", "const", "char", "*", "insn_buf", ";", "int", "bits", ";", "int", "amount", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rotate_amount", ")", "==", "CONST_INT", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "rotate_mode", "=", "QIshift", ";", "break", ";", "case", "HImode", ":", "rotate_mode", "=", "HIshift", ";", "break", ";", "case", "SImode", ":", "rotate_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ROTATERT", ":", "rotate_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "case", "ROTATE", ":", "rotate_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "INTVAL", "(", "rotate_amount", ")", ";", "if", "(", "amount", "<", "0", ")", "amount", "=", "0", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "(", "unsigned", ")", "2", ")", "{", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "if", "(", "(", "mode", "==", "HImode", "&&", "TARGET_H8300", "&&", "amount", ">=", "5", ")", "||", "(", "mode", "==", "HImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "6", ")", "||", "(", "mode", "==", "HImode", "&&", "TARGET_H8300S", "&&", "amount", "==", "8", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "10", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300S", "&&", "amount", ">=", "13", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "insn_buf", "=", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "case", "SImode", ":", "insn_buf", "=", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "2", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "for", "(", "bits", "=", "TARGET_H8300S", "?", "2", ":", "1", ";", "bits", ">", "0", ";", "bits", "/=", "2", ")", "{", "if", "(", "bits", "==", "2", ")", "insn_buf", "=", "rotate_two", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "else", "insn_buf", "=", "rotate_one", "[", "cpu_type", "]", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "for", "(", ";", "amount", ">=", "bits", ";", "amount", "-=", "bits", ")", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "rotate", "insn", "." ]

[ "h8300", "0", "2", "0", "0", "2", "5", "6", "8", "10", "13", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", "2", "2", "1", "0", "2", "2", "\"\"" ]

[]

[ "<s>", "unsigned", "MSP430InstrInfo", "::", "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", "(", ")", "!=", "MSP430", "::", "JMP", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "JCC", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "Br", "&&", "I", "->", "getOpcode", "(", ")", "!=", "MSP430", "::", "Bm", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "\"code size not handled\"", "0", "MSP430::JMP", "MSP430::JCC", "MSP430::Br", "MSP430::Bm" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeSet", "Attr", ")", "const", "{", "bool", "OptSize", "=", "Attr", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ";", "return", "OptSize", "&&", "!", "VT", ".", "isVector", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "isStore", "(", ")", "const", "{", "return", "Access", "==", "AccessTy", "::", "Store", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "recipe", "is", "a", "store", "." ]

[ "M68k" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "DisablePPCUnaligned", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "!", "VT", ".", "isVector", "(", ")", "&&", "!", "Subtarget", ".", "allowsUnalignedFPAccess", "(", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "isVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "VT", "!=", "MVT", "::", "v2f64", "&&", "VT", "!=", "MVT", "::", "v2i64", "&&", "VT", "!=", "MVT", "::", "v4f32", "&&", "VT", "!=", "MVT", "::", "v4i32", ")", "return", "false", ";", "}", "else", "{", "return", "false", ";", "}", "}", "if", "(", "VT", "==", "MVT", "::", "ppcf128", ")", "return", "false", ";", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "MVT::v2f64", "MVT::v2i64", "MVT::v4f32", "MVT::v4i32", "MVT::ppcf128" ]

[]

[ "<s>", "int", "csky_get_movedouble_length", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "REG_P", "(", "dst", ")", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "{", "int", "dstreg", "=", "REGNO", "(", "dst", ")", ";", "int", "srcreg", "=", "REGNO", "(", "src", ")", ";", "if", "(", "CSKY_VREG_P", "(", "srcreg", ")", "&&", "CSKY_VREG_P", "(", "dstreg", ")", ")", "return", "4", ";", "else", "return", "8", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "{", "rtx", "memexp", "=", "XEXP", "(", "src", ",", "0", ")", ";", "int", "dstreg", "=", "REGNO", "(", "dst", ")", ";", "struct", "csky_address", "op0", ";", "decompose_csky_address", "(", "XEXP", "(", "src", ",", "0", ")", ",", "&", "op0", ")", ";", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "LABEL_REF", ")", "return", "8", ";", "if", "(", "CSKY_VREG_P", "(", "dstreg", ")", ")", "return", "4", ";", "return", "8", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", ")", "{", "split_double", "(", "src", ",", "operands", "+", "2", ",", "operands", "+", "3", ")", ";", "if", "(", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "+", "1", ")", "&&", "CSKY_CONST_OK_FOR_N", "(", "INTVAL", "(", "operands", "[", "3", "]", ")", "+", "1", ")", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "<", "6", ")", "return", "4", ";", "else", "return", "8", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", "&&", "GET_CODE", "(", "src", ")", "==", "REG", ")", "{", "rtx", "memexp", "=", "XEXP", "(", "dst", ",", "0", ")", ";", "int", "srcreg", "=", "REGNO", "(", "src", ")", ";", "int", "offset", "=", "-", "1", ";", "if", "(", "CSKY_VREG_P", "(", "srcreg", ")", ")", "return", "4", ";", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "REG", ")", "offset", "=", "0", ";", "else", "if", "(", "GET_CODE", "(", "memexp", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "0", ")", ")", "==", "REG", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "memexp", ",", "1", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "memexp", ",", "1", ")", ")", "==", "REG", ")", "offset", "=", "INTVAL", "(", "XEXP", "(", "memexp", ",", "0", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "srcreg", "<=", "6", "&&", "offset", "<=", "1020", ")", "return", "4", ";", "else", "if", "(", "(", "srcreg", "==", "7", "&&", "offset", "<=", "1024", ")", "||", "(", "srcreg", "<=", "7", "&&", "offset", "==", "1024", ")", ")", "return", "6", ";", "else", "return", "8", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Calculate", "the", "instruction", "'s", "length", "for", "moving", "double-word", "data", "." ]

[ "csky", "0", "1", "4", "8", "0", "0", "8", "4", "8", "2", "3", "2", "1", "3", "1", "0", "6", "4", "8", "0", "1", "4", "0", "0", "1", "1", "0", "6", "1020", "4", "7", "1024", "7", "1024", "6", "8", "0" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "RV16K" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSIWithSVE", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "CSI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSIWithSVE", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MFI", "->", "getStackRegionToHandleCSR", "(", "CSIWithSVE", "[", "i", "]", ".", "getReg", "(", ")", ")", "!=", "nullptr", ")", "continue", ";", "CSI", ".", "push_back", "(", "CSIWithSVE", "[", "i", "]", ")", ";", "}", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "begin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "end", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "if", "(", "MFI", "->", "getStackRegionToHandleCSR", "(", "Reg1", ")", ")", "continue", ";", "unsigned", "LdrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXi", ":", "AArch64", "::", "LDRXui", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDi", ":", "AArch64", "::", "LDRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "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", "(", ")", "." ]

[ "AArch64", "AArch64", "0", "8", "AArch64::LDPXi", "AArch64::LDRXui", "AArch64::LDPDi", "AArch64::LDRDui", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "int", "crx_interrupt_function_p", "(", "void", ")", "{", "tree", "attributes", ";", "attributes", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "return", "lookup_attribute", "(", "\"interrupt\"", ",", "attributes", ")", "!=", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "current", "function", "being", "compiled", "is", "an", "interrupt", "*", "function", "as", "specified", "by", "the", "``", "interrupt", "''", "attribute", "." ]

[ "crx", "\"interrupt\"" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cum", ";", "tree", "param", ";", "tree", "next_param", ";", "if", "(", "TARGET_DEBUG_D_MODE", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args, fntype = 0x%.8lx\"", ",", "(", "long", ")", "fntype", ")", ";", "if", "(", "!", "fntype", ")", "fputc", "(", "'\\n'", ",", "stderr", ")", ";", "else", "{", "tree", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "fprintf", "(", "stderr", ",", "\", fntype code = %s, ret code = %s\\n\"", ",", "get_tree_code_name", "(", "TREE_CODE", "(", "fntype", ")", ")", ",", "get_tree_code_name", "(", "TREE_CODE", "(", "ret_type", ")", ")", ")", ";", "}", "}", "*", "cum", "=", "zero_cum", ";", "for", "(", "param", "=", "fntype", "?", "TYPE_ARG_TYPES", "(", "fntype", ")", ":", "0", ";", "param", "!=", "0", ";", "param", "=", "next_param", ")", "{", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "if", "(", "next_param", "==", "0", "&&", "TREE_VALUE", "(", "param", ")", "!=", "void_type_node", ")", "cum", "->", "gp_reg_found", "=", "1", ";", "}", "}", "</s>" ]

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

[ "iq2000", "\"\\ninit_cumulative_args, fntype = 0x%.8lx\"", "\", fntype code = %s, ret code = %s\\n\"", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "hasAndNotCompare", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "return", "Subtarget", ".", "hasStdExtZbb", "(", ")", "&&", "!", "isa", "<", "ConstantSDNode", ">", "(", "Y", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "mayAlias", "(", "const", "MachineFrameInfo", "*", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "instruction", "'s", "memory", "access", "aliases", "the", "memory", "access", "of", "Other", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "WebAssemblyLowerRefTypesIntPtrConv", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Lower RefTypes IntPtr Convs **********\\n\"", "\"********** Function: \"", "<<", "F", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "std", "::", "set", "<", "Instruction", "*", ">", "worklist", ";", "for", "(", "inst_iterator", "I", "=", "inst_begin", "(", "F", ")", ",", "E", "=", "inst_end", "(", "F", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "PtrToIntInst", "*", "PTI", "=", "dyn_cast", "<", "PtrToIntInst", ">", "(", "&", "*", "I", ")", ";", "IntToPtrInst", "*", "ITP", "=", "dyn_cast", "<", "IntToPtrInst", ">", "(", "&", "*", "I", ")", ";", "if", "(", "!", "(", "PTI", "&&", "isRefType", "(", "PTI", "->", "getPointerOperand", "(", ")", "->", "getType", "(", ")", ")", ")", "&&", "!", "(", "ITP", "&&", "isRefType", "(", "ITP", "->", "getDestTy", "(", ")", ")", ")", ")", "continue", ";", "UndefValue", "*", "U", "=", "UndefValue", "::", "get", "(", "I", "->", "getType", "(", ")", ")", ";", "I", "->", "replaceAllUsesWith", "(", "U", ")", ";", "Function", "*", "TrapIntrin", "=", "Intrinsic", "::", "getDeclaration", "(", "F", ".", "getParent", "(", ")", ",", "Intrinsic", "::", "debugtrap", ")", ";", "CallInst", "::", "Create", "(", "TrapIntrin", ",", "{", "}", ",", "\"\"", ",", "&", "*", "I", ")", ";", "worklist", ".", "insert", "(", "&", "*", "I", ")", ";", "}", "for", "(", "Instruction", "*", "I", ":", "worklist", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "!", "worklist", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Lower RefTypes IntPtr Convs **********\\n\"", "\"********** Function: \"", "Intrinsic::getDeclaration", "Intrinsic::debugtrap", "\"\"" ]

[]

[ "<s>", "void", "emitBytes", "(", "const", "uint8_t", "*", "Opcode", ",", "size_t", "Size", ")", "{", "Ops", ".", "insert", "(", "Ops", ".", "end", "(", ")", ",", "Opcode", ",", "Opcode", "+", "Size", ")", ";", "OpBegins", ".", "push_back", "(", "OpBegins", ".", "back", "(", ")", "+", "Size", ")", ";", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "ARM" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "*", "DL", "=", "TM", ".", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "Triple", "(", "TM", ".", "getTargetTriple", "(", ")", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", "->", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "getOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

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

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

[ "PIC16", "PIC16" ]

[]

[ "<s>", "int", "small_data_operand", "(", "rtx", "op", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "sym_ref", ";", "if", "(", "rs6000_sdata", "==", "SDATA_NONE", "||", "rs6000_sdata", "==", "SDATA_DATA", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "!=", "ABI_V4", ")", "return", "0", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym_ref", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "!=", "CONST", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "!=", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "0", ";", "else", "{", "rtx", "sum", "=", "XEXP", "(", "op", ",", "0", ")", ";", "HOST_WIDE_INT", "summand", ";", "summand", "=", "INTVAL", "(", "XEXP", "(", "sum", ",", "1", ")", ")", ";", "if", "(", "summand", "<", "0", "||", "summand", ">", "g_switch_value", ")", "return", "0", ";", "sym_ref", "=", "XEXP", "(", "sum", ",", "0", ")", ";", "}", "return", "SYMBOL_REF_SMALL_P", "(", "sym_ref", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "for", "an", "operand", "in", "small", "memory", "on", "V.4/eabi", "." ]

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

[]

[ "<s>", "bool", "Cpu0PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCpu0ISelDag", "(", "getCpu0TargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

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

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "void", "asm_conditional_branch", "(", "rtx", "insn", ",", "rtx", "*", "operands", ",", "int", "n_nops", ",", "int", "predict_taken", ")", "{", "int", "offset", "=", "branch_dest", "(", "insn", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "int", "len", "=", "(", "offset", ">=", "-", "1024", "&&", "offset", "<=", "1022", "?", "0", ":", "offset", ">=", "-", "4094", "&&", "offset", "<=", "4096", "?", "1", ":", "2", ")", ";", "int", "bp", "=", "predict_taken", "&&", "len", "==", "0", "?", "1", ":", "cbranch_predicted_taken_p", "(", "insn", ")", ";", "int", "idx", "=", "(", "bp", "<<", "1", ")", "|", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "EQ", "?", "BRF", ":", "BRT", ")", ";", "output_asm_insn", "(", "ccbranch_templates", "[", "idx", "]", "[", "len", "]", ",", "operands", ")", ";", "gcc_assert", "(", "n_nops", "==", "0", "||", "!", "bp", ")", ";", "if", "(", "len", "==", "0", ")", "while", "(", "n_nops", "--", ">", "0", ")", "output_asm_insn", "(", "\"nop;\"", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Output", "INSN", ",", "which", "is", "a", "conditional", "branch", "instruction", "with", "operands", "OPERANDS", ".", "We", "deal", "with", "the", "various", "forms", "of", "conditional", "branches", "that", "can", "be", "generated", "by", "bfin_reorg", "to", "prevent", "the", "hardware", "from", "doing", "speculative", "loads", ",", "by", "-", "emitting", "a", "sufficient", "number", "of", "nops", ",", "if", "N_NOPS", "is", "nonzero", ",", "or", "-", "always", "emitting", "the", "branch", "as", "predicted", "taken", ",", "if", "PREDICT_TAKEN", "is", "true", ".", "Either", "of", "these", "is", "only", "necessary", "if", "the", "branch", "is", "short", ",", "otherwise", "the", "template", "we", "use", "ends", "in", "an", "unconditional", "jump", "which", "flushes", "the", "pipeline", "anyway", "." ]

[ "bfin", "1024", "1022", "0", "4094", "4096", "1", "2", "0", "1", "1", "0", "0", "0", "0", "\"nop;\"" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "createSystemZExpandPseudoPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "SMLoc", "getLoc", "(", ")", "const", "{", "return", "getParser", "(", ")", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "source", "location", "of", "the", "point", "where", "the", "field", "was", "defined", "." ]

[ "RI5CY" ]

[]

[ "<s>", "inline", "unsigned", "int", "function_instance", "::", "vectors_per_tuple", "(", ")", "const", "{", "return", "base", "->", "vectors_per_tuple", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "function", "operates", "on", "tuples", "of", "vectors", ",", "return", "the", "number", "of", "vectors", "in", "the", "tuples", ",", "otherwise", "return", "1", "." ]

[ "aarch64" ]

[]

[ "<s>", "format_object", "<", "int64_t", ">", "formatImm", "(", "int64_t", "Value", ")", "const", "{", "return", "PrintImmHex", "?", "formatHex", "(", "Value", ")", ":", "formatDec", "(", "Value", ")", ";", "}", "</s>" ]

[ "Utility", "function", "to", "print", "immediates", "in", "decimal", "or", "hex", "." ]

[ "MOS" ]

[]

[ "<s>", "rtx", "m68hc11_gen_lowpart", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "m68hc11_auto_inc_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "return", "gen_rtx_MEM", "(", "mode", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "long", "l", "[", "2", "]", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "REAL_VALUE_TYPE", "r", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "r", ",", "l", "[", "0", "]", ")", ";", "}", "else", "{", "rtx", "first", ",", "second", ";", "split_double", "(", "x", ",", "&", "first", ",", "&", "second", ")", ";", "return", "second", ";", "}", "if", "(", "mode", "==", "SImode", ")", "return", "GEN_INT", "(", "l", "[", "0", "]", ")", ";", "return", "gen_int_mode", "(", "l", "[", "0", "]", ",", "HImode", ")", ";", "}", "else", "{", "l", "[", "0", "]", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "}", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "return", "GEN_INT", "(", "l", "[", "0", "]", ")", ";", "case", "HImode", ":", "gcc_assert", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", ";", "return", "gen_int_mode", "(", "l", "[", "0", "]", ",", "HImode", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "mode", "==", "QImode", "&&", "D_REG_P", "(", "x", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "HARD_B_REGNUM", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "SUBREG_BYTE", "(", "x", ")", "!=", "0", ")", "{", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "return", "gen_rtx_SUBREG", "(", "mode", ",", "SUBREG_REG", "(", "x", ")", ",", "SUBREG_BYTE", "(", "x", ")", "+", "4", ")", ";", "case", "HImode", ":", "return", "gen_rtx_SUBREG", "(", "mode", ",", "SUBREG_REG", "(", "x", ")", ",", "SUBREG_BYTE", "(", "x", ")", "+", "2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "x", "=", "gen_lowpart", "(", "mode", ",", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "copy_rtx", "(", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Low", "and", "High", "part", "extraction", "for", "68HC11", ".", "These", "routines", "are", "similar", "to", "gen_lowpart", "and", "gen_highpart", "but", "they", "have", "been", "fixed", "to", "work", "for", "constants", "and", "68HC11", "specific", "registers", "." ]

[ "m68hc11", "0", "0", "2", "0", "0", "0", "0", "0", "0", "0", "4", "2" ]

[]

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

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

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

[]

[ "<s>", "const", "uint16_t", "*", "VideoCore4RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", "?", "CSR_FP_SaveList", ":", "CSR_SaveList", ")", ";", "}", "</s>" ]

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

[ "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "setImmOperand", "(", "MachineInstr", "*", "MI", ",", "R600Operands", "::", "Ops", "Op", ",", "int64_t", "Imm", ")", "const", "{", "int", "Idx", "=", "getOperandIdx", "(", "*", "MI", ",", "Op", ")", ";", "assert", "(", "Idx", "!=", "-", "1", "&&", "\"Operand not supported for this instruction.\"", ")", ";", "assert", "(", "MI", "->", "getOperand", "(", "Idx", ")", ".", "isImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "Idx", ")", ".", "setImm", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "setting", "instruction", "flag", "values", "." ]

[ "R600", "R600Operands::Ops", "1", "\"Operand not supported for this instruction.\"" ]

[]

[ "<s>", "StringRef", "CSKYMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_CSKY_None", ":", "case", "VK_CSKY_ADDR", ":", "return", "\"\"", ";", "case", "VK_CSKY_ADDR_HI16", ":", "return", "\"@HI16\"", ";", "case", "VK_CSKY_ADDR_LO16", ":", "return", "\"@LO16\"", ";", "case", "VK_CSKY_GOT_IMM18_BY4", ":", "case", "VK_CSKY_GOT", ":", "return", "\"@GOT\"", ";", "case", "VK_CSKY_GOTPC", ":", "return", "\"@GOTPC\"", ";", "case", "VK_CSKY_GOTOFF", ":", "return", "\"@GOTOFF\"", ";", "case", "VK_CSKY_PLT_IMM18_BY4", ":", "case", "VK_CSKY_PLT", ":", "return", "\"@PLT\"", ";", "case", "VK_CSKY_TLSLE", ":", "return", "\"@TPOFF\"", ";", "case", "VK_CSKY_TLSIE", ":", "return", "\"@GOTTPOFF\"", ";", "case", "VK_CSKY_TLSGD", ":", "return", "\"@TLSGD32\"", ";", "case", "VK_CSKY_TLSLDO", ":", "return", "\"@TLSLDO32\"", ";", "case", "VK_CSKY_TLSLDM", ":", "return", "\"@TLSLDM32\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "CSKY", "CSKY", "\"Invalid ELF symbol kind\"", "CSKY", "CSKY", "\"\"", "CSKY", "\"@HI16\"", "CSKY", "\"@LO16\"", "CSKY", "CSKY", "\"@GOT\"", "CSKY", "\"@GOTPC\"", "CSKY", "\"@GOTOFF\"", "CSKY", "CSKY", "\"@PLT\"", "CSKY", "\"@TPOFF\"", "CSKY", "\"@GOTTPOFF\"", "CSKY", "\"@TLSGD32\"", "CSKY", "\"@TLSLDO32\"", "CSKY", "\"@TLSLDM32\"" ]

[]

[ "<s>", "static", "bool", "mips_canonicalize_int_order_test", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "cmp1", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "plus_one", ";", "if", "(", "mips_int_order_operand_ok_p", "(", "*", "code", ",", "*", "cmp1", ")", ")", "return", "true", ";", "if", "(", "CONST_INT_P", "(", "*", "cmp1", ")", ")", "switch", "(", "*", "code", ")", "{", "case", "LE", ":", "plus_one", "=", "trunc_int_for_mode", "(", "UINTVAL", "(", "*", "cmp1", ")", "+", "1", ",", "mode", ")", ";", "if", "(", "INTVAL", "(", "*", "cmp1", ")", "<", "plus_one", ")", "{", "*", "code", "=", "LT", ";", "*", "cmp1", "=", "force_reg", "(", "mode", ",", "GEN_INT", "(", "plus_one", ")", ")", ";", "return", "true", ";", "}", "break", ";", "case", "LEU", ":", "plus_one", "=", "trunc_int_for_mode", "(", "UINTVAL", "(", "*", "cmp1", ")", "+", "1", ",", "mode", ")", ";", "if", "(", "plus_one", "!=", "0", ")", "{", "*", "code", "=", "LTU", ";", "*", "cmp1", "=", "force_reg", "(", "mode", ",", "GEN_INT", "(", "plus_one", ")", ")", ";", "return", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "*", "CMP1", "(", "of", "mode", "MODE", ")", "is", "a", "valid", "second", "operand", "for", "integer", "ordering", "test", "*", "CODE", ",", "or", "if", "an", "equivalent", "combination", "can", "be", "formed", "by", "adjusting", "*", "CODE", "and", "*", "CMP1", ".", "When", "returning", "true", ",", "update", "*", "CODE", "and", "*", "CMP1", "with", "the", "chosen", "code", "and", "operand", ",", "otherwise", "leave", "them", "alone", "." ]

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "ScratchExecCopy", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "if", "(", "ScratchExecCopy", "==", "AMDGPU", "::", "NoRegister", ")", "{", "LivePhysRegs", "LiveRegs", "(", "*", "ST", ".", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveIns", "(", "MBB", ")", ";", "ScratchExecCopy", "=", "findScratchNonCalleeSaveRegister", "(", "MF", ",", "LiveRegs", ",", "AMDGPU", "::", "SReg_64_XEXECRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_OR_SAVEEXEC_B64", ")", ",", "ScratchExecCopy", ")", ".", "addImm", "(", "-", "1", ")", ";", "}", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "if", "(", "ScratchExecCopy", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "ScratchExecCopy", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint32_t", "RoundedSize", "=", "FuncInfo", "->", "isStackRealigned", "(", ")", "?", "NumBytes", "+", "MFI", ".", "getMaxAlignment", "(", ")", ":", "NumBytes", ";", "const", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "RoundedSize", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::NoRegister", "SI", "AMDGPU::NoRegister", "AMDGPU::SReg_64_XEXECRegClass", "AMDGPU::S_OR_SAVEEXEC_B64", "1", "AMDGPU::VGPR_32RegClass", "AMDGPU::NoRegister", "AMDGPU::S_MOV_B64", "AMDGPU::EXEC", "AMDGPU::S_SUB_U32" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "RESTORE_CR", ":", "case", "PPC", "::", "RESTORE_CRBIT", ":", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LXVD2X", ":", "case", "PPC", "::", "QVLFDX", ":", "case", "PPC", "::", "QVLFSXs", ":", "case", "PPC", "::", "QVLFDXb", ":", "case", "PPC", "::", "RESTORE_VRSAVE", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::LD", "PPC::LWZ", "PPC::LFS", "PPC::LFD", "PPC::RESTORE_CR", "PPC::RESTORE_CRBIT", "PPC::LVX", "PPC::LXVD2X", "PPC::QVLFDX", "PPC::QVLFSXs", "PPC::QVLFDXb", "PPC::RESTORE_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "bool", "ARCInstrInfo", "::", "isPostIncrement", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "MID", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "uint64_t", "F", "=", "MID", ".", "TSFlags", ";", "return", "(", "(", "F", ">>", "TSF_AddrModeOff", ")", "&", "TSF_AddModeMask", ")", "==", "PostInc", ";", "}", "</s>" ]

[ "Return", "true", "for", "post-incremented", "instructions", "." ]

[ "ARC", "ARC" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "X86", "MVT::i8" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerKernelArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addAddressSpaceInferencePasses", "(", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "int", "symbolic_memory_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "SUBREG", ")", "op", "=", "SUBREG_REG", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "op", ")", "==", "CONST", "||", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "a", "memory", "reference", "involving", "a", "symbolic", "constant", "that", "is", "not", "in", "the", "constant", "pool", "." ]

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

[]

[ "<s>", "unsigned", "MipsOutgoingValueHandler", "::", "assignCustomValue", "(", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ",", "std", "::", "function", "<", "void", "(", ")", ">", "*", "Thunk", ")", "{", "const", "CCValAssign", "&", "VALo", "=", "VAs", "[", "0", "]", ";", "const", "CCValAssign", "&", "VAHi", "=", "VAs", "[", "1", "]", ";", "assert", "(", "VALo", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VAHi", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VALo", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "VAHi", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"unexpected custom value\"", ")", ";", "auto", "Unmerge", "=", "MIRBuilder", ".", "buildUnmerge", "(", "{", "LLT", "::", "scalar", "(", "32", ")", ",", "LLT", "::", "scalar", "(", "32", ")", "}", ",", "Arg", ".", "Regs", "[", "0", "]", ")", ";", "Register", "Lo", "=", "Unmerge", ".", "getReg", "(", "0", ")", ";", "Register", "Hi", "=", "Unmerge", ".", "getReg", "(", "1", ")", ";", "Arg", ".", "OrigRegs", ".", "assign", "(", "Arg", ".", "Regs", ".", "begin", "(", ")", ",", "Arg", ".", "Regs", ".", "end", "(", ")", ")", ";", "Arg", ".", "Regs", "=", "{", "Lo", ",", "Hi", "}", ";", "if", "(", "!", "STI", ".", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "if", "(", "Thunk", ")", "{", "*", "Thunk", "=", "[", "=", "]", "(", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "VALo", ".", "getLocReg", "(", ")", ",", "Lo", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "VAHi", ".", "getLocReg", "(", ")", ",", "Hi", ")", ";", "}", ";", "return", "2", ";", "}", "MIRBuilder", ".", "buildCopy", "(", "VALo", ".", "getLocReg", "(", ")", ",", "Lo", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "VAHi", ".", "getLocReg", "(", ")", ",", "Hi", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Handle", "custom", "values", ",", "which", "may", "be", "passed", "into", "one", "or", "more", "of", "VAs", "." ]

[ "Mips", "Mips", "0", "1", "MVT::i32", "MVT::i32", "MVT::f64", "MVT::f64", "\"unexpected custom value\"", "32", "32", "0", "0", "1", "2", "2" ]

[]

[ "<s>", "static", "MachineInstr", "*", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "unsigned", "BitSize", ",", "int", "FrameIdx", ",", "int", "Offset", ",", "const", "TargetInstrInfo", "*", "TII", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "{", "unsigned", "SubIdx", "=", "(", "BitSize", "==", "8", ")", "?", "X86", "::", "sub_8bit", ":", "X86", "::", "sub_16bit", ";", "unsigned", "Opc", "=", "(", "BitSize", "==", "8", ")", "?", "X86", "::", "MOV8mr", ":", "X86", "::", "MOV16mr", ";", "if", "(", "BitSize", "==", "TRI", "->", "getRegSizeInBits", "(", "*", "RC", ")", ")", "SubIdx", "=", "0", ";", "MachineInstr", "*", "NewMI", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ",", "Offset", ")", ".", "addReg", "(", "SrcReg", ",", "0", ",", "SubIdx", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

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

[ "X86", "8", "X86::sub_8bit", "X86::sub_16bit", "8", "X86::MOV8mr", "X86::MOV16mr", "0", "0" ]

[]

[ "<s>", "tree", "ix86_handle_selectany_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", "||", "!", "TREE_PUBLIC", "(", "*", "node", ")", ")", "{", "error", "(", "\"%qE attribute applies only to initialized variables\"", "\" with external linkage\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "selectany", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "i386", "\"%qE attribute applies only to initialized variables\"", "\" with external linkage\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ":", "{", "unsigned", "NumSubRegs", "=", "getNumSubRegsForSpillOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "unsigned", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "NumSubRegs", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SIMachineFunctionInfo", "::", "SpilledReg", "Spill", ";", "unsigned", "SubReg", "=", "RI", ".", "getPhysRegSubReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "i", ")", ";", "Spill", "=", "MFI", "->", "SpillTracker", ".", "getSpilledReg", "(", "FrameIndex", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_WRITELANE_B32", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "SubReg", ")", ".", "addImm", "(", "Spill", ".", "Lane", "+", "i", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ":", "{", "unsigned", "NumSubRegs", "=", "getNumSubRegsForSpillOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "NumSubRegs", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SIMachineFunctionInfo", "::", "SpilledReg", "Spill", ";", "unsigned", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "unsigned", "SubReg", "=", "RI", ".", "getPhysRegSubReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "i", ")", ";", "Spill", "=", "MFI", "->", "SpillTracker", ".", "getSpilledReg", "(", "FrameIndex", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_READLANE_B32", ")", ",", "SubReg", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "Spill", ".", "Lane", "+", "i", ")", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ProtectJTSupportPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "!", "Func", ".", "protectJT", "(", ")", ")", "return", "false", ";", "bool", "modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Func", ".", "begin", "(", ")", ";", "MBB", "!=", "Func", ".", "end", "(", ")", ";", "MBB", "++", ")", "{", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "MBB", "->", "end", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "NMI", "=", "std", "::", "next", "(", "MI", ")", ";", "modified", "|=", "handleInst", "(", "*", "MBB", ",", "MI", ")", ";", "MI", "=", "NMI", ";", "}", "}", "return", "modified", ";", "}", "</s>" ]

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

[ "X86" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "sparc_expand_vcond", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ",", "int", "ccode", ",", "int", "fcode", ")", "{", "enum", "rtx_code", "code", "=", "signed_condition", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", ";", "rtx", "mask", ",", "cop0", ",", "cop1", ",", "fcmp", ",", "cmask", ",", "bshuf", ",", "gsr", ";", "mask", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "cop0", "=", "operands", "[", "4", "]", ";", "cop1", "=", "operands", "[", "5", "]", ";", "if", "(", "code", "==", "LT", "||", "code", "==", "GE", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "std", "::", "swap", "(", "cop0", ",", "cop1", ")", ";", "}", "gsr", "=", "gen_rtx_REG", "(", "DImode", ",", "SPARC_GSR_REG", ")", ";", "fcmp", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cop0", ",", "cop1", ")", ")", ",", "fcode", ")", ";", "cmask", "=", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "2", ",", "mask", ",", "gsr", ")", ",", "ccode", ")", ";", "bshuf", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "gsr", ")", ",", "UNSPEC_BSHUFFLE", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "fcmp", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gsr", ",", "cmask", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "bshuf", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "conditionally", "move", "a", "combination", "of", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "into", "OPERANDS", "[", "0", "]", "in", "MODE", ",", "depending", "on", "the", "outcome", "of", "the", "comparison", "of", "OPERANDS", "[", "4", "]", "and", "OPERANDS", "[", "5", "]", ".", "OPERANDS", "[", "3", "]", "is", "the", "operator", "of", "the", "condition", ".", "FCODE", "is", "the", "machine", "code", "to", "be", "used", "for", "OPERANDS", "[", "3", "]", "and", "CCODE", "the", "machine", "code", "to", "be", "used", "for", "the", "condition", "mask", "." ]

[ "sparc", "3", "4", "5", "1", "2", "3", "1", "2", "0" ]

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Running on \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "BBUtils", "->", "adjustBBOffsetsAfter", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "Changed", "=", "false", ";", "RevertedWhileLoops", ".", "clear", "(", ")", ";", "for", "(", "auto", "*", "ML", ":", "*", "MLI", ")", "Changed", "|=", "processPostOrderLoops", "(", "ML", ")", ";", "for", "(", "auto", "*", "WlsInstr", ":", "RevertedWhileLoops", ")", "Changed", "|=", "revertWhileToDoLoop", "(", "WlsInstr", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"Running on \"", "\"\\n\"", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "MipsLegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ")", "const", "{", "using", "namespace", "TargetOpcode", ";", "MIRBuilder", ".", "setInstr", "(", "MI", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "G_ADD", ":", "{", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", ";", "const", "LLT", "sHalf", "=", "LLT", "::", "scalar", "(", "Size", "/", "2", ")", ";", "unsigned", "RHSLow", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "RHSHigh", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "LHSLow", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "LHSHigh", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "ResLow", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "ResHigh", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "Carry", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "TmpResHigh", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "MIRBuilder", ".", "buildUnmerge", "(", "{", "RHSHigh", ",", "RHSLow", "}", ",", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildUnmerge", "(", "{", "LHSHigh", ",", "LHSLow", "}", ",", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildAdd", "(", "TmpResHigh", ",", "LHSHigh", ",", "RHSHigh", ")", ";", "MIRBuilder", ".", "buildAdd", "(", "ResLow", ",", "LHSLow", ",", "RHSLow", ")", ";", "MIRBuilder", ".", "buildICmp", "(", "CmpInst", "::", "ICMP_ULT", ",", "Carry", ",", "ResLow", ",", "LHSLow", ")", ";", "MIRBuilder", ".", "buildAdd", "(", "ResHigh", ",", "TmpResHigh", ",", "Carry", ")", ";", "MIRBuilder", ".", "buildMerge", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "{", "ResHigh", ",", "ResLow", "}", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "G_CONSTANT", ":", "{", "unsigned", "Size", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", ";", "const", "LLT", "sHalf", "=", "LLT", "::", "scalar", "(", "Size", "/", "2", ")", ";", "const", "APInt", "&", "CImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getCImm", "(", ")", "->", "getValue", "(", ")", ";", "unsigned", "ResLow", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "unsigned", "ResHigh", "=", "MRI", ".", "createGenericVirtualRegister", "(", "sHalf", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "ResLow", ",", "*", "ConstantInt", "::", "get", "(", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ",", "CImmValue", ".", "trunc", "(", "Size", "/", "2", ")", ")", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "ResHigh", ",", "*", "ConstantInt", "::", "get", "(", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ",", "CImmValue", ".", "lshr", "(", "Size", "/", "2", ")", ".", "trunc", "(", "Size", "/", "2", ")", ")", ")", ";", "MIRBuilder", ".", "buildMerge", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "{", "ResHigh", ",", "ResLow", "}", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "2", "2", "1", "0", "0", "2", "1", "2", "2", "2", "0" ]

[]

[ "<s>", "static", "void", "rs6000_darwin64_record_arg_advance_flush", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "HOST_WIDE_INT", "bitpos", ",", "int", "final", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intregs", ",", "intoffset", ";", "if", "(", "cum", "->", "floats_in_gpr", "==", "1", "&&", "(", "cum", "->", "intoffset", "%", "64", "==", "0", "||", "(", "cum", "->", "intoffset", "==", "-", "1", "&&", "final", ")", ")", ")", "{", "cum", "->", "words", "++", ";", "cum", "->", "floats_in_gpr", "=", "0", ";", "}", "if", "(", "cum", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "cum", "->", "intoffset", ";", "cum", "->", "intoffset", "=", "-", "1", ";", "cum", "->", "floats_in_gpr", "=", "0", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "{", "unsigned", "int", "bits", "=", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ";", "if", "(", "!", "int_mode_for_size", "(", "bits", ",", "0", ")", ".", "exists", "(", ")", ")", "{", "intoffset", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "}", "}", "startbit", "=", "ROUND_DOWN", "(", "intoffset", ",", "BITS_PER_WORD", ")", ";", "endbit", "=", "ROUND_UP", "(", "bitpos", ",", "BITS_PER_WORD", ")", ";", "intregs", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "cum", "->", "words", "+=", "intregs", ";", "if", "(", "(", "unsigned", ")", "cum", "->", "words", "<", "(", "endbit", "/", "BITS_PER_WORD", ")", ")", "{", "int", "pad", "=", "(", "endbit", "/", "BITS_PER_WORD", ")", "-", "cum", "->", "words", ";", "cum", "->", "words", "+=", "pad", ";", "}", "}", "</s>" ]

[ "Use", "this", "to", "flush", "pending", "int", "fields", "." ]

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "prefers32BitThumb", "(", ")", ")", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "}", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

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

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::SETCC", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SIGN_EXTEND", "ISD::RETURNADDR", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", "&&", "!", "isOptNone", "(", "MF", ")", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "SpillRCs", ".", "insert", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "!", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ",", "RC", ")", ")", "continue", ";", "unsigned", "Num", "=", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", "?", "NumberScavengerSlots", ":", "1", ";", "unsigned", "S", "=", "RC", "->", "getSize", "(", ")", ",", "A", "=", "RC", "->", "getAlignment", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Num", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "S", ",", "A", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "Hexagon::IntRegsRegClass", "1", "0" ]

[]

[ "<s>", "bool", "inside_x_p", "(", "rtx", "op", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "{", "rtx", "lhs", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "rhs", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "TARGET_SMALL", ")", "{", "if", "(", "GET_CODE", "(", "lhs", ")", "==", "CONST_INT", "&&", "ok_for_index", "(", "rhs", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "rhs", ")", "==", "CONST_INT", "&&", "ok_for_index", "(", "lhs", ",", "strict", ")", ")", "return", "true", ";", "}", "if", "(", "data_ref_p", "(", "lhs", ")", ")", "{", "if", "(", "ok_for_index", "(", "rhs", ",", "strict", ")", ")", "{", "return", "true", ";", "}", "}", "if", "(", "data_ref_p", "(", "rhs", ")", ")", "{", "if", "(", "ok_for_index", "(", "lhs", ",", "strict", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "16", "bit", "register", "+", "pointer", "sized", "address" ]

[ "z8k", "0", "1" ]

[]

[ "<s>", "static", "void", "nvptx_assemble_undefined_decl", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const_tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", ";", "const", "char", "*", "section", "=", "nvptx_section_for_decl", "(", "decl", ")", ";", "fprintf", "(", "file", ",", "\"// BEGIN%s VAR DECL: \"", ",", "TREE_PUBLIC", "(", "decl", ")", "?", "\" GLOBAL\"", ":", "\"\"", ")", ";", "assemble_name_raw", "(", "file", ",", "name", ")", ";", "fputs", "(", "\"\\n\"", ",", "file", ")", ";", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "fprintf", "(", "file", ",", "\".extern %s .b8 \"", ",", "section", ")", ";", "assemble_name_raw", "(", "file", ",", "name", ")", ";", "if", "(", "size", ">", "0", ")", "fprintf", "(", "file", ",", "\"[\"", "HOST_WIDE_INT_PRINT_DEC", "\"]\"", ",", "size", ")", ";", "fprintf", "(", "file", ",", "\";\\n\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_ASSEMBLE_UNDEFINED_DECL", ".", "Write", "an", "extern", "declaration", "only", "for", "variable", "DECL", "with", "NAME", "to", "FILE", "." ]

[ "nvptx", "\"// BEGIN%s VAR DECL: \"", "\" GLOBAL\"", "\"\"", "\"\\n\"", "\".extern %s .b8 \"", "0", "\"[\"", "\"]\"", "\";\\n\\n\"" ]

[]

[ "<s>", "void", "function_builder", "::", "append_name", "(", "const", "char", "*", "name", ")", "{", "obstack_grow", "(", "&", "m_string_obstack", ",", "name", ",", "strlen", "(", "name", ")", ")", ";", "}", "</s>" ]

[ "Add", "NAME", "to", "the", "end", "of", "the", "function", "name", "being", "built", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx_code", "m68k_output_compare_si", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx_code", "code", ")", "{", "rtx_code", "tmp", "=", "m68k_find_flags_value", "(", "op0", ",", "op1", ",", "code", ")", ";", "if", "(", "tmp", "!=", "UNKNOWN", ")", "return", "tmp", ";", "remember_compare_flags", "(", "op0", ",", "op1", ")", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "op0", ";", "ops", "[", "1", "]", "=", "op1", ";", "if", "(", "op1", "==", "const0_rtx", "&&", "(", "TARGET_68020", "||", "TARGET_COLDFIRE", "||", "!", "ADDRESS_REG_P", "(", "op0", ")", ")", ")", "output_asm_insn", "(", "\"tst%.l %0\"", ",", "ops", ")", ";", "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "\"cmpm%.l %1,%0\"", ",", "ops", ")", ";", "else", "if", "(", "REG_P", "(", "op1", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "\"cmp%.l %d0,%d1\"", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}", "else", "if", "(", "!", "TARGET_COLDFIRE", "&&", "ADDRESS_REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op1", ")", "<", "0x8000", "&&", "INTVAL", "(", "op1", ")", ">=", "-", "0x8000", ")", "output_asm_insn", "(", "\"cmp%.w %1,%0\"", ",", "ops", ")", ";", "else", "output_asm_insn", "(", "\"cmp%.l %d1,%d0\"", ",", "ops", ")", ";", "return", "code", ";", "}", "</s>" ]

[ "Emit", "a", "comparison", "between", "OP0", "and", "OP1", ".", "CODE", "is", "the", "code", "of", "the", "comparison", ".", "It", "is", "returned", ",", "potentially", "modified", "if", "necessary", "." ]

[ "m68k", "2", "0", "1", "\"tst%.l %0\"", "\"cmpm%.l %1,%0\"", "\"cmp%.l %d0,%d1\"", "0x8000", "0x8000", "\"cmp%.w %1,%0\"", "\"cmp%.l %d1,%d0\"" ]

[]

[ "<s>", "void", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "loadRegFromStack", "(", "MBB", ",", "MBBI", ",", "DestReg", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "0" ]

[]

[ "<s>", "virtual", "const", "TargetRegisterClass", "*", "getRepRegClassFor", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "Untyped", ")", "return", "Subtarget", "->", "hasDSP", "(", ")", "?", "&", "Mips", "::", "ACC64DSPRegClass", ":", "&", "Mips", "::", "ACC64RegClass", ";", "return", "TargetLowering", "::", "getRepRegClassFor", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "the", "'representative", "'", "register", "class", "for", "the", "specified", "value", "type", "." ]

[ "Mips", "MVT::Untyped", "Mips::ACC64DSPRegClass", "Mips::ACC64RegClass" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "64", ")", ";", "LLT", "s64", "=", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "IsTailCall", ")", "{", "Offset", "+=", "FPDiff", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "Register", "FIReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "FIReg", ",", "FI", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "return", "FIReg", ";", "}", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Register", "(", "AArch64", "::", "SP", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s64", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildPtrAdd", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "AArch64", "0", "64", "64", "AArch64::SP" ]

[]

[ "<s>", "int", "sh_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "sh_cfun_interrupt_handler_p", "(", ")", "&&", "!", "regs_ever_live", "[", "new_reg", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "." ]

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

[]

[ "<s>", "static", "MipsOperand", "*", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "MipsOperand", "*", "Op", "=", "new", "MipsOperand", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "unsigned", "getCommonDomains", "(", "unsigned", "mask", ")", "const", "{", "return", "AvailableDomains", "&", "mask", ";", "}", "</s>" ]

[ "Return", "bitmask", "of", "domains", "that", "are", "available", "and", "in", "mask", "." ]

[ "X86" ]

[]

[ "<s>", "static", "enum", "mips_int_mask", "mips_interrupt_mask", "(", "tree", "type", ")", "{", "tree", "attr", "=", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "tree", "args", ",", "cst", ";", "const", "char", "*", "str", ";", "if", "(", "attr", "==", "NULL", ")", "return", "INT_MASK_EIC", ";", "args", "=", "TREE_VALUE", "(", "attr", ")", ";", "if", "(", "args", "==", "NULL", ")", "return", "INT_MASK_EIC", ";", "cst", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "cst", ")", ",", "\"eic\"", ")", "==", "0", ")", "return", "INT_MASK_EIC", ";", "str", "=", "TREE_STRING_POINTER", "(", "cst", ")", ";", "gcc_assert", "(", "strlen", "(", "str", ")", "==", "strlen", "(", "\"vector=sw0\"", ")", ")", ";", "if", "(", "str", "[", "7", "]", "==", "'s'", ")", "return", "(", "enum", "mips_int_mask", ")", "(", "INT_MASK_SW0", "+", "(", "str", "[", "9", "]", "-", "'0'", ")", ")", ";", "return", "(", "enum", "mips_int_mask", ")", "(", "INT_MASK_HW0", "+", "(", "str", "[", "9", "]", "-", "'0'", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "mask", "for", "the", "``", "interrupt", "''", "attribute", "." ]

[ "mips", "\"interrupt\"", "\"eic\"", "0", "\"vector=sw0\"", "7", "9", "9" ]

[]

[ "<s>", "bool", "isBlockAddress", "(", ")", "const", "{", "return", "Kind", "==", "ARMCP", "::", "CPBlockAddress", ";", "}", "</s>" ]

[ "isBlockAddress", "-", "Tests", "if", "this", "is", "a", "MO_BlockAddress", "operand", "." ]

[ "ARM", "ARMCP::CPBlockAddress" ]

[]

[ "<s>", "rtx", "rs6000_emit_eqne", "(", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "scratch", ")", "{", "if", "(", "op2", "==", "const0_rtx", ")", "return", "op1", ";", "if", "(", "GET_CODE", "(", "scratch", ")", "==", "SCRATCH", ")", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "logical_operand", "(", "op2", ",", "mode", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_XOR", "(", "mode", ",", "op1", ",", "op2", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "scratch", ",", "gen_rtx_PLUS", "(", "mode", ",", "op1", ",", "negate_rtx", "(", "mode", ",", "op2", ")", ")", ")", ")", ";", "return", "scratch", ";", "}", "</s>" ]

[ "Emit", "RTL", "that", "sets", "a", "register", "to", "zero", "if", "OP1", "and", "OP2", "are", "equal", ".", "SCRATCH", "can", "be", "used", "as", "that", "dest", "register", ".", "Return", "the", "dest", "register", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isInteger", "(", ")", "||", "!", "VT2", ".", "isInteger", "(", ")", ")", "return", "false", ";", "unsigned", "NumBits1", "=", "VT1", ".", "getSizeInBits", "(", ")", ";", "unsigned", "NumBits2", "=", "VT2", ".", "getSizeInBits", "(", ")", ";", "return", "NumBits1", "==", "64", "&&", "NumBits2", "==", "32", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "64", "32" ]

[]

[ "<s>", "void", "TPCMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "isLoopInst", "(", "MI", ")", ")", "{", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "dumpInstrNames", "(", "MI", ",", "MCII", ")", ";", ")", ";", "encodeLoop", "(", "MI", ",", "OS", ",", "getInstrBits", "(", "MI", ",", "Fixups", ",", "STI", ")", ",", "Fixups", ",", "STI", ")", ";", "return", ";", "}", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "dumpInstrNames", "(", "MI", ",", "MCII", ")", ";", ")", ";", "TPCInstrBits", "Bits", ";", "fillInstrBits", "(", "MI", ",", "Fixups", ",", "Bits", ",", "STI", ",", "false", ",", "true", ")", ";", "emitBits", "(", "OS", ",", "&", "Bits", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\"\\n\"", "\"\\n\"", "TPC" ]

[]

[ "<s>", "bool", "AlphaCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "II", "=", "(", "(", "AlphaTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "do", "{", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitBasicBlock", "(", "*", "I", ")", ";", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "PPCDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "SelectionDAG", "::", "allnodes_iterator", "Position", "(", "CurDAG", "->", "getRoot", "(", ")", ".", "getNode", "(", ")", ")", ";", "++", "Position", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "OR", ":", "Res", "=", "combineToCMPB", "(", "N", ")", ";", "break", ";", "}", "if", "(", "!", "Res", ")", "foldBoolExts", "(", "Res", ",", "N", ")", ";", "if", "(", "Res", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"PPC DAG preprocessing replacing:\\nOld: \"", ")", ";", "DEBUG", "(", "N", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nNew: \"", ")", ";", "DEBUG", "(", "Res", ".", "getNode", "(", ")", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Res", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OR", "\"PPC DAG preprocessing replacing:\\nOld: \"", "\"\\nNew: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"PowerPC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PowerPC DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "std", "::", "vector", "<", "SDNode", "*", ">", "*", "Created", ")", "const", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i64", ")", "||", "!", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "CCVal", ";", "SDValue", "Cmp", "=", "getAArch64Cmp", "(", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ",", "CCVal", ",", "DAG", ",", "DL", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CSel", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "CSEL", ",", "DL", ",", "VT", ",", "Add", ",", "N0", ",", "CCVal", ",", "Cmp", ")", ";", "if", "(", "Created", ")", "{", "Created", "->", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", "->", "push_back", "(", "CSel", ".", "getNode", "(", ")", ")", ";", "}", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "CSel", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "if", "(", "Created", ")", "Created", "->", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "AArch64", "AArch64", "0", "MVT::i32", "MVT::i64", "0", "0", "1ULL", "1", "AArch64", "ISD::SETLT", "ISD::ADD", "AArch64ISD::CSEL", "ISD::SRA", "MVT::i64", "ISD::SUB", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "toString", "(", "const", "Type", "*", "Ty", ",", "bool", "hasAddr64", ")", "{", "switch", "(", "Ty", "->", "getTypeID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Type", "::", "PointerTyID", ":", "return", "hasAddr64", "?", "\"i64\"", ":", "\"i32\"", ";", "case", "Type", "::", "FloatTyID", ":", "return", "\"f32\"", ";", "case", "Type", "::", "DoubleTyID", ":", "return", "\"f64\"", ";", "case", "Type", "::", "IntegerTyID", ":", "switch", "(", "Ty", "->", "getIntegerBitWidth", "(", ")", ")", "{", "case", "8", ":", "return", "\"i8\"", ";", "case", "16", ":", "return", "\"i16\"", ";", "case", "32", ":", "return", "\"i32\"", ";", "case", "64", ":", "return", "\"i64\"", ";", "default", ":", "break", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Invalid type \"", ";", "Ty", "->", "print", "(", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "llvm_unreachable", "(", "\"invalid type\"", ")", ";", "return", "\"<invalid>\"", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

[ "WebAssembly", "\"i64\"", "\"i32\"", "\"f32\"", "\"f64\"", "8", "\"i8\"", "16", "\"i16\"", "32", "\"i32\"", "64", "\"i64\"", "\"Invalid type \"", "\"invalid type\"", "\"<invalid>\"" ]

[]

[ "<s>", "bool", "AMDGPUInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "const", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "G_ADD", ":", "return", "selectG_ADD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "return", "selectG_CONSTANT", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "return", "selectG_GEP", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "selectG_LOAD", "(", "I", ")", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "return", "selectG_STORE", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "SNESPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createSNESISelDag", "(", "getSNESTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES", "SNES" ]

[]

[ "<s>", "BitVector", "Z80RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "Z80FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Reserved", ".", "set", "(", "Z80", "::", "SPS", ")", ";", "Reserved", ".", "set", "(", "Z80", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "Z80", "::", "PC", ")", ";", "for", "(", "MCSubRegIterator", "I", "(", "Z80", "::", "UIX", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "Z80::SPS", "Z80::SPL", "Z80::PC", "Z80::UIX" ]

[]

[ "<s>", "outliner", "::", "OutlinedFunction", "RISCVInstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "auto", "CannotInsertCall", "=", "[", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "C", ".", "getMF", "(", ")", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "C", ".", "initLRU", "(", "*", "TRI", ")", ";", "LiveRegUnits", "LRU", "=", "C", ".", "LRU", ";", "return", "!", "LRU", ".", "available", "(", "RISCV", "::", "X5", ")", ";", "}", ";", "llvm", "::", "erase_if", "(", "RepeatedSequenceLocs", ",", "CannotInsertCall", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "size", "(", ")", "<", "2", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "unsigned", "SequenceSize", "=", "0", ";", "auto", "I", "=", "RepeatedSequenceLocs", "[", "0", "]", ".", "front", "(", ")", ";", "auto", "E", "=", "std", "::", "next", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "SequenceSize", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "unsigned", "CallOverhead", "=", "8", ";", "for", "(", "auto", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "MachineOutlinerDefault", ",", "CallOverhead", ")", ";", "unsigned", "FrameOverhead", "=", "4", ";", "if", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "getMF", "(", ")", "->", "getSubtarget", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ")", "FrameOverhead", "=", "2", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "FrameOverhead", ",", "MachineOutlinerDefault", ")", ";", "}", "</s>" ]

[ "Returns", "a", "outliner", ":", ":OutlinedFunction", "struct", "containing", "target-specific", "information", "for", "a", "set", "of", "outlining", "candidates", "." ]

[ "RI5CY", "RISCV", "RISCV::X5", "2", "0", "0", "0", "8", "4", "0", "RISCV::FeatureStdExtC", "2" ]

[]

[ "<s>", "bool", "expand_a_shift", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "operands", "[", "]", ")", "{", "switch", "(", "h8sx_classify_shift", "(", "mode", ",", "code", ",", "operands", "[", "2", "]", ")", ")", "{", "case", "H8SX_SHIFT_BINARY", ":", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "return", "false", ";", "case", "H8SX_SHIFT_UNARY", ":", "return", "false", ";", "case", "H8SX_SHIFT_NONE", ":", "break", ";", "}", "emit_move_insn", "(", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "copy_rtx", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "2", "]", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "QImode", ")", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Called", "from", "the", ".md", "file", "to", "emit", "code", "to", "do", "shifts", ".", "Returns", "a", "boolean", "indicating", "success", "(", "currently", "this", "is", "always", "TRUE", ")", "." ]

[ "h8300", "2", "1", "1", "0", "1", "2", "0", "0", "2" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "AMDGPUSubtarget", "::", "getWavesPerEU", "(", "const", "Function", "&", "F", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Default", "(", "1", ",", "getMaxWavesPerEU", "(", ")", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "FlatWorkGroupSizes", "=", "getFlatWorkGroupSizes", "(", "F", ")", ";", "unsigned", "MinImpliedByFlatWorkGroupSize", "=", "getWavesPerEUForWorkGroup", "(", "FlatWorkGroupSizes", ".", "second", ")", ";", "bool", "RequestedFlatWorkGroupSize", "=", "false", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-flat-work-group-size\"", ")", ")", "{", "Default", ".", "first", "=", "MinImpliedByFlatWorkGroupSize", ";", "RequestedFlatWorkGroupSize", "=", "true", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Requested", "=", "AMDGPU", "::", "getIntegerPairAttribute", "(", "F", ",", "\"amdgpu-waves-per-eu\"", ",", "Default", ",", "true", ")", ";", "if", "(", "Requested", ".", "second", "&&", "Requested", ".", "first", ">", "Requested", ".", "second", ")", "return", "Default", ";", "if", "(", "Requested", ".", "first", "<", "getMinWavesPerEU", "(", ")", "||", "Requested", ".", "first", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "Requested", ".", "second", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "RequestedFlatWorkGroupSize", "&&", "Requested", ".", "first", "<", "MinImpliedByFlatWorkGroupSize", ")", "return", "Default", ";", "return", "Requested", ";", "}", "</s>" ]

[ "Overload", "which", "uses", "the", "specified", "values", "for", "the", "flat", "work", "group", "sizes", ",", "rather", "than", "querying", "the", "function", "itself", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"amdgpu-flat-work-group-size\"", "AMDGPU::getIntegerPairAttribute", "\"amdgpu-waves-per-eu\"" ]

[]

[ "<s>", "static", "inline", "bool", "pdp11_saved_regno", "(", "unsigned", "regno", ")", "{", "return", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ";", "}", "</s>" ]

[ "A", "helper", "function", "to", "determine", "if", "REGNO", "should", "be", "saved", "in", "the", "current", "function", "'s", "stack", "frame", "." ]

[ "pdp11" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "virtual", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectDFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", "&&", "!", "SelectAFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectXFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "case", "'o'", ":", "if", "(", "!", "SelectDFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", "&&", "!", "SelectAFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "Op0", "=", "Op", ";", "Op1", "=", "getSmallIPtrImm", "(", "0", ")", ";", "}", "break", ";", "case", "'v'", ":", "llvm_unreachable", "(", "\"InlineAsmMemoryOperand 'v' constraint not handled.\"", ")", ";", "SelectAddrIdxOnly", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "0", "\"InlineAsmMemoryOperand 'v' constraint not handled.\"" ]

[]

[ "<s>", "bool", "X86DomainReassignment", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "DisableX86DomainReassignment", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function before Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "hasAVX512", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "initConverters", "(", ")", ";", "bool", "Changed", "=", "false", ";", "EnclosedEdges", ".", "clear", "(", ")", ";", "EnclosedInstrs", ".", "clear", "(", ")", ";", "std", "::", "vector", "<", "Closure", ">", "Closures", ";", "unsigned", "ClosureID", "=", "0", ";", "for", "(", "unsigned", "Idx", "=", "0", ";", "Idx", "<", "MRI", "->", "getNumVirtRegs", "(", ")", ";", "++", "Idx", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "Idx", ")", ";", "if", "(", "!", "isGPR", "(", "MRI", "->", "getRegClass", "(", "Reg", ")", ")", ")", "continue", ";", "if", "(", "EnclosedEdges", ".", "count", "(", "Reg", ")", ")", "continue", ";", "Closure", "C", "(", "ClosureID", "++", ",", "{", "MaskDomain", "}", ")", ";", "buildClosure", "(", "C", ",", "Reg", ")", ";", "if", "(", "!", "C", ".", "empty", "(", ")", "&&", "C", ".", "isLegal", "(", "MaskDomain", ")", ")", "Closures", ".", "push_back", "(", "std", "::", "move", "(", "C", ")", ")", ";", "}", "for", "(", "Closure", "&", "C", ":", "Closures", ")", "{", "LLVM_DEBUG", "(", "C", ".", "dump", "(", "MRI", ")", ")", ";", "if", "(", "isReassignmentProfitable", "(", "C", ",", "MaskDomain", ")", ")", "{", "reassign", "(", "C", ",", "MaskDomain", ")", ";", "++", "NumClosuresConverted", ";", "Changed", "=", "true", ";", "}", "}", "DeleteContainerSeconds", "(", "Converters", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** Machine Function after Domain Reassignment *****\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"***** Machine Function before Domain Reassignment *****\\n\"", "X86", "\"Expected MIR to be in SSA form\"", "0", "0", "\"***** Machine Function after Domain Reassignment *****\\n\"" ]

[]

[ "<s>", "static", "rtx", "frv_legitimize_target", "(", "enum", "insn_code", "icode", ",", "rtx", "target", ")", "{", "enum", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "mode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "mode", ")", ")", "return", "gen_reg_rtx", "(", "mode", ")", ";", "else", "return", "target", ";", "}", "</s>" ]

[ "Return", "a", "legitimate", "rtx", "for", "instruction", "ICODE", "'s", "return", "value", ".", "Use", "TARGET", "if", "it", "'s", "not", "null", ",", "has", "the", "right", "mode", ",", "and", "satisfies", "operand", "0", "'s", "predicate", "." ]

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

[]

[ "<s>", "static", "void", "riscv_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.option %spic\\n\"", ",", "(", "flag_pic", "?", "\"\"", ":", "\"no\"", ")", ")", ";", "if", "(", "!", "riscv_mrelax", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option norelax\\n\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "riscv", "\"\\t.option %spic\\n\"", "\"\"", "\"no\"", "\"\\t.option norelax\\n\"" ]

[]

[ "<s>", "rtx", "arm_gen_compare_reg", "(", "enum", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ",", "rtx", "scratch", ")", "{", "machine_mode", "mode", ";", "rtx", "cc_reg", ";", "int", "dimode_comparison", "=", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "y", ")", "==", "DImode", ";", "if", "(", "dimode_comparison", "&&", "!", "REG_P", "(", "x", ")", ")", "x", "=", "force_reg", "(", "DImode", ",", "x", ")", ";", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "if", "(", "dimode_comparison", "&&", "mode", "!=", "CC_CZmode", ")", "{", "rtx", "clobber", ",", "set", ";", "if", "(", "mode", "==", "CC_Zmode", "&&", "y", "!=", "const0_rtx", ")", "{", "gcc_assert", "(", "!", "reload_completed", ")", ";", "x", "=", "expand_binop", "(", "DImode", ",", "xor_optab", ",", "x", ",", "y", ",", "NULL_RTX", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "y", "=", "const0_rtx", ";", "}", "if", "(", "reload_completed", ")", "gcc_assert", "(", "scratch", "!=", "NULL", "&&", "GET_MODE", "(", "scratch", ")", "==", "SImode", ")", ";", "else", "scratch", "=", "gen_rtx_SCRATCH", "(", "SImode", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "scratch", ")", ";", "set", "=", "gen_rtx_SET", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "}", "else", "emit_set_insn", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "the", "compare", "insn", "and", "return", "the", "rtx", "for", "register", "0", "in", "the", "proper", "mode", ".", "FP", "means", "this", "is", "a", "floating", "point", "compare", ":", "I", "do", "n't", "think", "that", "it", "is", "needed", "on", "the", "arm", "." ]

[ "arm", "0", "2" ]

[]

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

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "tree", "gcn_goacc_create_worker_broadcast_record", "(", "tree", "record_type", ",", "bool", "sender", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "tree", "type", "=", "build_qualified_type", "(", "record_type", ",", "TYPE_QUALS_NO_ADDR_SPACE", "(", "record_type", ")", "|", "ENCODE_QUAL_ADDR_SPACE", "(", "ADDR_SPACE_LDS", ")", ")", ";", "if", "(", "!", "sender", ")", "{", "tree", "ptr_type", "=", "build_pointer_type", "(", "type", ")", ";", "return", "create_tmp_var_raw", "(", "ptr_type", ",", "name", ")", ";", "}", "if", "(", "record_type", "==", "char_type_node", ")", "offset", "=", "1", ";", "tree", "ptr_type", "=", "build_pointer_type", "(", "type", ")", ";", "return", "build_int_cst", "(", "ptr_type", ",", "offset", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GOACC_CREATE_WORKER_BROADCAST_RECORD", ".", "Create", "OpenACC", "worker", "state", "propagation", "record", "in", "shared", "memory", "." ]

[ "gcn", "1" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "override", "{", "return", "Kind", "==", "Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "MMIX" ]

[]

[ "<s>", "Value", "*", "RISCVTargetLowering", "::", "emitMaskedAtomicRMWIntrinsic", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicRMWInst", "*", "AI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "Incr", ",", "Value", "*", "Mask", ",", "Value", "*", "ShiftAmt", ",", "AtomicOrdering", "Ord", ")", "const", "{", "unsigned", "XLen", "=", "Subtarget", ".", "getXLen", "(", ")", ";", "Value", "*", "Ordering", "=", "Builder", ".", "getIntN", "(", "XLen", ",", "static_cast", "<", "uint64_t", ">", "(", "AI", "->", "getOrdering", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "AlignedAddr", "->", "getType", "(", ")", "}", ";", "Function", "*", "LrwOpScwLoop", "=", "Intrinsic", "::", "getDeclaration", "(", "AI", "->", "getModule", "(", ")", ",", "getIntrinsicForMaskedAtomicRMWBinOp", "(", "XLen", ",", "AI", "->", "getOperation", "(", ")", ")", ",", "Tys", ")", ";", "if", "(", "XLen", "==", "64", ")", "{", "Incr", "=", "Builder", ".", "CreateSExt", "(", "Incr", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "Mask", "=", "Builder", ".", "CreateSExt", "(", "Mask", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "ShiftAmt", "=", "Builder", ".", "CreateSExt", "(", "ShiftAmt", ",", "Builder", ".", "getInt64Ty", "(", ")", ")", ";", "}", "Value", "*", "Result", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Min", "||", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Max", ")", "{", "const", "DataLayout", "&", "DL", "=", "AI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "ValWidth", "=", "DL", ".", "getTypeStoreSizeInBits", "(", "AI", "->", "getValOperand", "(", ")", "->", "getType", "(", ")", ")", ";", "Value", "*", "SextShamt", "=", "Builder", ".", "CreateSub", "(", "Builder", ".", "getIntN", "(", "XLen", ",", "XLen", "-", "ValWidth", ")", ",", "ShiftAmt", ")", ";", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "SextShamt", ",", "Ordering", "}", ")", ";", "}", "else", "{", "Result", "=", "Builder", ".", "CreateCall", "(", "LrwOpScwLoop", ",", "{", "AlignedAddr", ",", "Incr", ",", "Mask", ",", "Ordering", "}", ")", ";", "}", "if", "(", "XLen", "==", "64", ")", "Result", "=", "Builder", ".", "CreateTrunc", "(", "Result", ",", "Builder", ".", "getInt32Ty", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "atomicrmw", "using", "a", "target-specific", "intrinsic", "." ]

[ "RI5CY", "RISCV", "Intrinsic::getDeclaration", "64", "64" ]

[]