Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "m32c_return_addr_rtx", "(", "int", "count", ")", "{", "enum", "machine_mode", "mode", ";", "int", "offset", ";", "rtx", "ra_mem", ";", "if", "(", "count", ")", "return", "NULL_RTX", ";", "if", "(", "TARGET_A24", ")", "{", "mode", "=", "SImode", ";", "offset", "=", "4", ";", "}", "else", "{", "mode", "=", "HImode", ";", "offset", "=", "2", ";", "}", "ra_mem", "=", "gen_rtx_MEM", "(", "mode", ",", "plus_constant", "(", "gen_rtx_REG", "(", "Pmode", ",", "FP_REGNO", ")", ",", "offset", ")", ")", ";", "return", "copy_to_mode_reg", "(", "mode", ",", "ra_mem", ")", ";", "}", "</s>" ]

[ "Implements", "RETURN_ADDR_RTX", ".", "Note", "that", "R8C", "and", "M16C", "push", "24", "bits", "(", "yes", ",", "THREE", "bytes", ")", "onto", "the", "stack", "for", "the", "return", "address", ",", "but", "we", "do", "n't", "support", "pointers", "bigger", "than", "16", "bits", "on", "those", "chips", ".", "This", "will", "likely", "wreak", "havoc", "with", "exception", "unwinding", ".", "FIXME", "." ]

[ "m32c", "4", "2" ]

[]

[ "<s>", "static", "void", "mcore_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "ptr_pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "args_so_far", "=", "get_cumulative_args", "(", "args_so_far_v", ")", ";", "current_function_anonymous_args", "=", "1", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", "+", "mcore_num_arg_regs", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", ";", "if", "(", "number_of_regs_before_varargs", ">", "NPARM_REGS", ")", "number_of_regs_before_varargs", "=", "NPARM_REGS", ";", "}", "</s>" ]

[ "Keep", "track", "of", "some", "information", "about", "varargs", "for", "the", "prolog", "." ]

[ "mcore", "1" ]

[]

[ "<s>", "int", "AArch64AsmParser", "::", "tryParseRegister", "(", ")", "{", "const", "AsmToken", "&", "Tok", "=", "Parser", ".", "getTok", "(", ")", ";", "assert", "(", "Tok", ".", "is", "(", "AsmToken", "::", "Identifier", ")", "&&", "\"Token is not an Identifier\"", ")", ";", "std", "::", "string", "lowerCase", "=", "Tok", ".", "getString", "(", ")", ".", "lower", "(", ")", ";", "unsigned", "RegNum", "=", "matchRegisterNameAlias", "(", "lowerCase", ",", "false", ")", ";", "if", "(", "RegNum", "==", "0", ")", "RegNum", "=", "StringSwitch", "<", "unsigned", ">", "(", "lowerCase", ")", ".", "Case", "(", "\"fp\"", ",", "AArch64", "::", "FP", ")", ".", "Case", "(", "\"lr\"", ",", "AArch64", "::", "LR", ")", ".", "Case", "(", "\"x31\"", ",", "AArch64", "::", "XZR", ")", ".", "Case", "(", "\"w31\"", ",", "AArch64", "::", "WZR", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "RegNum", "==", "0", ")", "return", "-", "1", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "RegNum", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "AArch64", "AArch64", "\"Token is not an Identifier\"", "0", "\"fp\"", "AArch64::FP", "\"lr\"", "AArch64::LR", "\"x31\"", "AArch64::XZR", "\"w31\"", "AArch64::WZR", "0", "0", "1" ]

[]

[ "<s>", "bool", "pa_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_64BIT", "?", "16", ":", "8", ")", "||", "int_size_in_bytes", "(", "type", ")", "<=", "0", ")", ";", "}", "</s>" ]

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

[ "pa", "16", "8", "0" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "Amount", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "void", "mips_expand_conditional_trap", "(", "rtx", "comparison", ")", "{", "rtx", "op0", ",", "op1", ";", "machine_mode", "mode", ";", "enum", "rtx_code", "code", ";", "code", "=", "GET_CODE", "(", "comparison", ")", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "LE", ":", "case", "GTU", ":", "case", "LEU", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "op0", "=", "XEXP", "(", "comparison", ",", "1", ")", ";", "op1", "=", "XEXP", "(", "comparison", ",", "0", ")", ";", "break", ";", "default", ":", "op0", "=", "XEXP", "(", "comparison", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "comparison", ",", "1", ")", ";", "break", ";", "}", "mode", "=", "GET_MODE", "(", "XEXP", "(", "comparison", ",", "0", ")", ")", ";", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "!", "(", "ISA_HAS_COND_TRAPI", "?", "arith_operand", "(", "op1", ",", "mode", ")", ":", "reg_or_0_operand", "(", "op1", ",", "mode", ")", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_TRAP_IF", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op0", ",", "op1", ")", ",", "const0_rtx", ")", ")", ";", "}", "</s>" ]

[ "Perform", "the", "comparison", "in", "COMPARISON", ",", "then", "trap", "if", "the", "condition", "holds", "." ]

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

[]

[ "<s>", "static", "void", "mcore_print_operand", "(", "FILE", "*", "stream", ",", "rtx", "x", ",", "int", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "'N'", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "-", "1", ")", "fprintf", "(", "asm_out_file", ",", "\"32\"", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "INTVAL", "(", "x", ")", "+", "1", ")", ")", ";", "break", ";", "case", "'P'", ":", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "INTVAL", "(", "x", ")", "&", "0xffffffff", ")", ")", ";", "break", ";", "case", "'Q'", ":", "fprintf", "(", "asm_out_file", ",", "\"%d\"", ",", "exact_log2", "(", "~", "INTVAL", "(", "x", ")", ")", ")", ";", "break", ";", "case", "'O'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'M'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "-", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'R'", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "+", "1", "]", ",", "(", "stream", ")", ")", ";", "break", ";", "case", "MEM", ":", "mcore_print_operand_address", "(", "stream", ",", "XEXP", "(", "adjust_address", "(", "x", ",", "SImode", ",", "4", ")", ",", "0", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'U'", ":", "fprintf", "(", "asm_out_file", ",", "\"%s-%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "3", "]", ")", ";", "break", ";", "case", "'x'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "'X'", ":", "fprintf", "(", "asm_out_file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "3", "-", "INTVAL", "(", "x", ")", "/", "8", ")", ";", "break", ";", "default", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "(", "stream", ")", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "stream", ",", "x", ")", ";", "break", ";", "}", "break", ";", "}", "}", "</s>" ]

[ "Print", "operand", "x", "(", "an", "rtx", ")", "in", "assembler", "syntax", "to", "file", "stream", "according", "to", "modifier", "code", ".", "'", "R", "'", "print", "the", "next", "register", "or", "memory", "location", "along", ",", "ie", "the", "lsw", "in", "a", "double", "word", "value", "'", "O", "'", "print", "a", "constant", "without", "the", "#", "'M", "'", "print", "a", "constant", "as", "its", "negative", "'", "P", "'", "print", "log2", "of", "a", "power", "of", "two", "'", "Q", "'", "print", "log2", "of", "an", "inverse", "of", "a", "power", "of", "two", "'", "U", "'", "print", "register", "for", "ldm/stm", "instruction", "'", "X", "'", "print", "byte", "number", "for", "xtrbN", "instruction", "." ]

[ "mcore", "1", "\"32\"", "\"%d\"", "1", "\"%d\"", "0xffffffff", "\"%d\"", "1", "4", "0", "\"%s-%s\"", "3", "3", "8", "0" ]

[]

[ "<s>", "static", "rtx", "frv_expand_binopimm_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "if", "(", "!", "frv_check_constant_argument", "(", "icode", ",", "2", ",", "op1", ")", ")", "return", "NULL_RTX", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "operands", "and", "the", "second", "is", "immediate", "." ]

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

[]

[ "<s>", "const", "RISCVRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "TargetOperandInfo", "TOI", "(", "*", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "*", "HII", ",", "*", "HRI", ",", "*", "MDT", ",", "MDF", ",", "TOI", ")", ";", "G", ".", "build", "(", "BuildOptions", "::", "KeepDeadPhis", ")", ";", "DFG", "=", "&", "G", ";", "Liveness", "L", "(", "*", "MRI", ",", "*", "DFG", ")", ";", "L", ".", "computePhiInfo", "(", ")", ";", "LV", "=", "&", "L", ";", "Deleted", ".", "clear", "(", ")", ";", "NodeAddr", "<", "FuncNode", "*", ">", "FA", "=", "DFG", "->", "getFunc", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"==== [RefMap#]=====:\\n \"", "<<", "Print", "<", "NodeAddr", "<", "FuncNode", "*", ">>", "(", "FA", ",", "*", "DFG", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "FA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "Changed", "|=", "processBlock", "(", "BA", ")", ";", "for", "(", "auto", "MI", ":", "Deleted", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "Changed", ")", "{", "G", ".", "build", "(", ")", ";", "L", ".", "computeLiveIns", "(", ")", ";", "L", ".", "resetLiveIns", "(", ")", ";", "L", ".", "resetKills", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"==== [RefMap#]=====:\\n \"", "\"\\n\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "OpenRISCRegisterInfo", "::", "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", "..." ]

[ "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "bool", "HexagonCommonGEP", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "for", "(", "Function", "::", "iterator", "A", "=", "F", ".", "begin", "(", ")", ",", "Z", "=", "F", ".", "end", "(", ")", ";", "A", "!=", "Z", ";", "++", "A", ")", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "A", "->", "begin", "(", ")", ",", "E", "=", "A", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "isa", "<", "InvokeInst", ">", "(", "I", ")", "||", "isa", "<", "LandingPadInst", ">", "(", "I", ")", ")", "return", "false", ";", "Fn", "=", "&", "F", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ".", "getPostDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "Ctx", "=", "&", "F", ".", "getContext", "(", ")", ";", "Nodes", ".", "clear", "(", ")", ";", "Uses", ".", "clear", "(", ")", ";", "NodeOrder", ".", "clear", "(", ")", ";", "SpecificBumpPtrAllocator", "<", "GepNode", ">", "Allocator", ";", "Mem", "=", "&", "Allocator", ";", "collect", "(", ")", ";", "common", "(", ")", ";", "NodeToValueMap", "Loc", ";", "computeNodePlacement", "(", "Loc", ")", ";", "materialize", "(", "Loc", ")", ";", "removeDeadCode", "(", ")", ";", "verifyFunction", "(", "F", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "isTargetMachO", "(", ")", "?", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", ":", "(", "LittleEndian", "?", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", ":", "\"E-m:e-i64:64-i128:128-n32:64-S128\"", ")", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", "&", "DL", ")", ",", "TLInfo", "(", "TM", ")", "{", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", "\"E-m:e-i64:64-i128:128-n32:64-S128\"" ]

[]

[ "<s>", "enum", "reg_class", "alpha_preferred_reload_class", "(", "rtx", "x", ",", "enum", "reg_class", "rclass", ")", "{", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "rclass", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "if", "(", "rclass", "==", "FLOAT_REGS", ")", "return", "NO_REGS", ";", "if", "(", "rclass", "==", "ALL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "(", "rclass", "==", "ALL_REGS", "?", "GENERAL_REGS", ":", "rclass", ")", ";", "return", "rclass", ";", "}", "</s>" ]

[ "On", "the", "Alpha", ",", "all", "(", "non-symbolic", ")", "constants", "except", "zero", "go", "into", "a", "floating-point", "register", "via", "memory", ".", "Note", "that", "we", "can", "not", "return", "anything", "that", "is", "not", "a", "subset", "of", "CLASS", ",", "and", "that", "some", "symbolic", "constants", "can", "not", "be", "dropped", "to", "memory", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isCoalescableExtInstr", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "DstReg", ",", "unsigned", "&", "SubIdx", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "case", "X86", "::", "MOVZX64rr8", ":", "if", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVZX64rr16", ":", "case", "X86", "::", "MOVSX64rr32", ":", "case", "X86", "::", "MOVZX64rr32", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "getSubReg", "(", ")", ")", "return", "false", ";", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "0", ")", ";", "case", "X86", "::", "MOVSX16rr8", ":", "case", "X86", "::", "MOVZX16rr8", ":", "case", "X86", "::", "MOVSX32rr8", ":", "case", "X86", "::", "MOVZX32rr8", ":", "case", "X86", "::", "MOVSX64rr8", ":", "case", "X86", "::", "MOVZX64rr8", ":", "SubIdx", "=", "X86", "::", "sub_8bit", ";", "break", ";", "case", "X86", "::", "MOVSX32rr16", ":", "case", "X86", "::", "MOVZX32rr16", ":", "case", "X86", "::", "MOVSX64rr16", ":", "case", "X86", "::", "MOVZX64rr16", ":", "SubIdx", "=", "X86", "::", "sub_16bit", ";", "break", ";", "case", "X86", "::", "MOVSX64rr32", ":", "case", "X86", "::", "MOVZX64rr32", ":", "SubIdx", "=", "X86", "::", "sub_32bit", ";", "break", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "isCoalescableExtInstr", "-", "Return", "true", "if", "the", "instruction", "is", "a", "``", "coalescable", "''", "extension", "instruction", "." ]

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "X86", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "0", "1", "1", "0", "0", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "X86::sub_8bit", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "X86::sub_16bit", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "X86::sub_32bit" ]

[]

[ "<s>", "MVT", "BPFTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", "VT", ")", "const", "{", "return", "(", "getHasAlu32", "(", ")", "&&", "VT", "==", "MVT", "::", "i32", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "checkMAIHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "mayLoadOrStore", "(", ")", "&&", "checkMAILdStHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "static", "void", "push_regs", "(", "HARD_REG_SET", "*", "mask", ",", "bool", "interrupt_handler", ")", "{", "bool", "skip_fpscr", "=", "false", ";", "for", "(", "int", "i", "=", "interrupt_handler", "?", "LAST_BANKED_REG", "+", "1", ":", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "==", "FIRST_FP_REG", "&&", "interrupt_handler", "&&", "TARGET_FMOVD", "&&", "hard_reg_set_intersect_p", "(", "*", "mask", ",", "reg_class_contents", "[", "DF_REGS", "]", ")", ")", "{", "HARD_REG_SET", "unsaved", ";", "push", "(", "FPSCR_REG", ")", ";", "COMPL_HARD_REG_SET", "(", "unsaved", ",", "*", "mask", ")", ";", "fpscr_set_from_mem", "(", "NORMAL_MODE", "(", "FP_MODE", ")", ",", "unsaved", ")", ";", "skip_fpscr", "=", "true", ";", "}", "if", "(", "i", "!=", "PR_REG", "&&", "(", "i", "!=", "FPSCR_REG", "||", "!", "skip_fpscr", ")", "&&", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "{", "if", "(", "!", "(", "sh_cfun_resbank_handler_p", "(", ")", "&&", "(", "(", "i", ">=", "FIRST_GENERAL_REG", "&&", "i", "<", "LAST_GENERAL_REG", ")", "||", "i", "==", "MACH_REG", "||", "i", "==", "MACL_REG", "||", "i", "==", "GBR_REG", ")", ")", ")", "push", "(", "i", ")", ";", "}", "}", "if", "(", "interrupt_handler", ")", "{", "bool", "use_movml", "=", "false", ";", "if", "(", "TARGET_SH2A", ")", "{", "unsigned", "int", "count", "=", "0", ";", "for", "(", "int", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "count", "++", ";", "else", "break", ";", "if", "(", "count", "==", "LAST_BANKED_REG", "-", "FIRST_BANKED_REG", "+", "1", ")", "use_movml", "=", "true", ";", "}", "if", "(", "sh_cfun_resbank_handler_p", "(", ")", ")", ";", "else", "if", "(", "use_movml", ")", "{", "rtx", "x", ",", "mem", ",", "reg", ",", "set", ";", "rtx", "sp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "STACK_POINTER_REGNUM", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "x", "=", "gen_movml_push_banked", "(", "sp_reg", ")", ";", "x", "=", "emit_frame_insn", "(", "x", ")", ";", "for", "(", "int", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "sp_reg", ",", "i", "*", "4", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "set", "=", "gen_rtx_SET", "(", "sp_reg", ",", "plus_constant", "(", "Pmode", ",", "sp_reg", ",", "-", "32", ")", ")", ";", "add_reg_note", "(", "x", ",", "REG_CFA_ADJUST_CFA", ",", "set", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "else", "for", "(", "int", "i", "=", "FIRST_BANKED_REG", ";", "i", "<=", "LAST_BANKED_REG", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "i", ")", ")", "push", "(", "i", ")", ";", "}", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "mask", ",", "PR_REG", ")", "&&", "!", "sh_cfun_resbank_handler_p", "(", ")", ")", "push", "(", "PR_REG", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "push", "the", "regs", "specified", "in", "the", "mask", ".", "remember", "that", "the", "mask", "is", "of", "the", "internal", "shape", "of", "the", "regs", ",", "not", "the", "external", "shape", "-", "so", "go", "through", "the", "renumber", "vector" ]

[ "sh", "1", "0", "0", "1", "4", "32" ]

[]

[ "<s>", "static", "bool", "hasTailCall", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpc", "=", "I", "->", "getOpcode", "(", ")", ";", "return", "RetOpc", "==", "Hexagon", "::", "PS_tailcall_i", "||", "RetOpc", "==", "Hexagon", "::", "PS_tailcall_r", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "function", "contains", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon::PS_tailcall_i", "Hexagon::PS_tailcall_r" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "if", "(", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", ";", "return", "false", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tMOVr", "&&", "!", "Subtarget", ".", "hasV6Ops", "(", ")", ")", "{", "if", "(", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Non-flag-setting Thumb1 mov is v6-only\"", ";", "return", "false", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "{", "for", "(", "int", "i", "=", "2", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "isImplicit", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "<", "ARM", "::", "R0", "||", "Reg", ">", "ARM", "::", "R7", ")", "{", "if", "(", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "&&", "Reg", "==", "ARM", "::", "LR", ")", "&&", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", "&&", "Reg", "==", "ARM", "::", "PC", ")", ")", "{", "ErrInfo", "=", "\"Unsupported register in Thumb1 push/pop\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "ARM", "ARM", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", "ARM::tMOVr", "ARM::hGPRRegClass", "0", "ARM::hGPRRegClass", "1", "\"Non-flag-setting Thumb1 mov is v6-only\"", "ARM::tPUSH", "ARM::tPOP", "ARM::tPOP_RET", "2", "ARM::R0", "ARM::R7", "ARM::tPUSH", "ARM::LR", "ARM::tPOP_RET", "ARM::PC", "\"Unsupported register in Thumb1 push/pop\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "PostRAMachineSinkingID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "TargetPassConfig", "::", "addPostRegAlloc", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "uint64_t", "R600MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "HAS_NATIVE_OPERANDS", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "return", "getHWReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCSymbolRefExpr", "*", "Expr", "=", "cast", "<", "MCSymbolRefExpr", ">", "(", "MO", ".", "getExpr", "(", ")", ")", ";", "const", "unsigned", "offset", "=", "(", "&", "MO", "==", "&", "MI", ".", "getOperand", "(", "0", ")", ")", "?", "0", ":", "4", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "offset", ",", "Expr", ",", "FK_SecRel_4", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "return", "0", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "0", "0", "4", "0" ]

[]

[ "<s>", "MachineInstr", "*", "X86FrameLowering", "::", "emitStackProbe", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "DebugLoc", "DL", ",", "bool", "InProlog", ")", "const", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "isTargetWindowsCoreCLR", "(", ")", ")", "{", "if", "(", "InProlog", ")", "{", "return", "emitStackProbeInlineStub", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "true", ")", ";", "}", "else", "{", "return", "emitStackProbeInline", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "false", ")", ";", "}", "}", "else", "{", "return", "emitStackProbeCall", "(", "MF", ",", "MBB", ",", "MBBI", ",", "DL", ",", "InProlog", ")", ";", "}", "}", "</s>" ]

[ "Emit", "target", "stack", "probe", "code", "." ]

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

[]

[ "<s>", "static", "void", "rs6000_free_sched_context", "(", "void", "*", "_sc", ")", "{", "gcc_assert", "(", "_sc", "!=", "NULL", ")", ";", "free", "(", "_sc", ")", ";", "}", "</s>" ]

[ "Free", "_SC", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createRISCVExpandPseudoPass", "(", ")", ")", ";", "addPass", "(", "createPULPFixupHwLoops", "(", ")", ")", ";", "addPass", "(", "createRISCVExpandAtomicPseudoPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

[ "RI5CY", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "&&", "!", "Outs", ".", "empty", "(", ")", ")", "{", "report_fatal_error", "(", "\"ISRs cannot return any value\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "unsigned", "Opc", "=", "(", "CallConv", "==", "CallingConv", "::", "MSP430_INTR", "?", "MSP430ISD", "::", "RETI_FLAG", ":", "MSP430ISD", "::", "RET_FLAG", ")", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "\"ISRs cannot return any value\"", "MSP430", "0", "0", "\"Can only return in registers!\"", "1", "MSP430", "MSP430ISD::RETI_FLAG", "MSP430ISD::RET_FLAG", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "parseDirectiveGpWord", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".word\"", ")", "{", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mips_hack_stocg\"", ")", "return", "parseDirectiveMipsHackStocg", "(", ")", ";", "if", "(", "IDVal", "==", "\".mips_hack_elf_flags\"", ")", "return", "parseDirectiveMipsHackELFFlags", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "Mips", "Mips", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"", "\".word\"", "4", "\".mips_hack_stocg\"", "Mips", "\".mips_hack_elf_flags\"", "Mips" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "R600" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "(", "RC", "->", "hasSuperClassEq", "(", "&", "ARM", "::", "tGPRRegClass", ")", "||", "(", "Register", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "&&", "\"Unknown regclass!\"", ")", ";", "if", "(", "RC", "->", "hasSuperClassEq", "(", "&", "ARM", "::", "tGPRRegClass", ")", "||", "(", "Register", "::", "isPhysicalRegister", "(", "DestReg", ")", "&&", "isARMLowRegister", "(", "DestReg", ")", ")", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tLDRspi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM", "\"Unknown regclass!\"", "ARM::tGPRRegClass", "ARM", "ARM::tLDRspi", "0", "ARMCC::AL" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "int", "arc_unalign_branch_p", "(", "rtx", "branch", ")", "{", "rtx", "note", ";", "if", "(", "!", "TARGET_UNALIGN_BRANCH", ")", "return", "0", ";", "if", "(", "get_attr_delay_slot_filled", "(", "branch", ")", "==", "DELAY_SLOT_FILLED_YES", "&&", "!", "NEXT_INSN", "(", "branch", ")", "->", "deleted", "(", ")", ")", "return", "0", ";", "note", "=", "find_reg_note", "(", "branch", ",", "REG_BR_PROB", ",", "0", ")", ";", "return", "(", "!", "note", "||", "(", "arc_unalign_prob_threshold", "&&", "!", "br_prob_note_reliable_p", "(", "note", ")", ")", "||", "INTVAL", "(", "XEXP", "(", "note", ",", "0", ")", ")", "<", "arc_unalign_prob_threshold", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "iff", "BRANCH", "should", "be", "unaligned", "if", "possible", "by", "upsizing", "a", "previous", "instruction", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "Reloc", "::", "Model", "R", "=", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ";", "if", "(", "!", "X86", "::", "isOffsetSuitableForCodeModel", "(", "AM", ".", "BaseOffs", ",", "M", ",", "AM", ".", "BaseGV", "!=", "nullptr", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "unsigned", "GVFlags", "=", "Subtarget", "->", "ClassifyGlobalReference", "(", "AM", ".", "BaseGV", ",", "getTargetMachine", "(", ")", ")", ";", "if", "(", "isGlobalStubReference", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "isGlobalRelativeToPICBase", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "(", "M", "!=", "CodeModel", "::", "Small", "||", "R", "!=", "Reloc", "::", "Static", ")", "&&", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "Scale", ">", "1", ")", ")", "return", "false", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "case", "3", ":", "case", "5", ":", "case", "9", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "X86::isOffsetSuitableForCodeModel", "1", "0", "1", "2", "4", "8", "3", "5", "9" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "PerformEXTRACT_VECTOR_ELTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "VSELECT", ":", "case", "ISD", "::", "SELECT", ":", "return", "PerformSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "CMOV", ":", "return", "PerformCMOVCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "PerformAddCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SUB", ":", "return", "PerformSubCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "ADC", ":", "return", "PerformADCCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMulCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformAndCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformOrCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "XOR", ":", "return", "PerformXorCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "PerformLOADCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "PerformSTORECombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "PerformSINT_TO_FPCombine", "(", "N", ",", "DAG", ",", "this", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "PerformFADDCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "PerformFSUBCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "X86ISD", "::", "FXOR", ":", "case", "X86ISD", "::", "FOR", ":", "return", "PerformFORCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "FAND", ":", "return", "PerformFANDCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "BT", ":", "return", "PerformBTCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "VZEXT_MOVL", ":", "return", "PerformVZEXT_MOVLCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "PerformZExtCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "PerformSExtCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "PerformTruncateCombine", "(", "N", ",", "DAG", ",", "DCI", ")", ";", "case", "X86ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DAG", ")", ";", "case", "X86ISD", "::", "SHUFP", ":", "case", "X86ISD", "::", "PALIGN", ":", "case", "X86ISD", "::", "UNPCKH", ":", "case", "X86ISD", "::", "UNPCKL", ":", "case", "X86ISD", "::", "MOVHLPS", ":", "case", "X86ISD", "::", "MOVLHPS", ":", "case", "X86ISD", "::", "PSHUFD", ":", "case", "X86ISD", "::", "PSHUFHW", ":", "case", "X86ISD", "::", "PSHUFLW", ":", "case", "X86ISD", "::", "MOVSS", ":", "case", "X86ISD", "::", "MOVSD", ":", "case", "X86ISD", "::", "VPERMILP", ":", "case", "X86ISD", "::", "VPERM2X128", ":", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "PerformShuffleCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::EXTRACT_VECTOR_ELT", "ISD::VSELECT", "ISD::SELECT", "X86ISD::CMOV", "ISD::ADD", "ISD::SUB", "X86ISD::ADC", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::LOAD", "ISD::STORE", "ISD::SINT_TO_FP", "ISD::FADD", "ISD::FSUB", "X86ISD::FXOR", "X86ISD::FOR", "X86ISD::FAND", "X86ISD::BT", "X86ISD::VZEXT_MOVL", "ISD::ZERO_EXTEND", "ISD::SIGN_EXTEND", "ISD::TRUNCATE", "X86ISD::SETCC", "X86ISD::SHUFP", "X86ISD::PALIGN", "X86ISD::UNPCKH", "X86ISD::UNPCKL", "X86ISD::MOVHLPS", "X86ISD::MOVLHPS", "X86ISD::PSHUFD", "X86ISD::PSHUFHW", "X86ISD::PSHUFLW", "X86ISD::MOVSS", "X86ISD::MOVSD", "X86ISD::VPERMILP", "X86ISD::VPERM2X128", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "static", "rtx", "m32c_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "fprintf", "(", "stderr", ",", "\"m32c_legitimize_address for mode %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "FB_REGNO", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "-", "128", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">", "(", "128", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", "{", "rtx", "temp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "copy_rtx", "(", "x", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "XEXP", "(", "x", ",", "0", ")", "=", "temp", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "Implements", "LEGITIMIZE_ADDRESS", ".", "The", "only", "address", "we", "really", "have", "to", "worry", "about", "is", "frame", "base", "offsets", ",", "as", "$", "fb", "has", "a", "limited", "displacement", "range", ".", "We", "deal", "with", "this", "by", "attempting", "to", "reload", "$", "fb", "itself", "into", "an", "address", "register", ";", "that", "seems", "to", "result", "in", "the", "best", "code", "." ]

[ "m32c", "\"m32c_legitimize_address for mode %s\\n\"", "\"\\n\"", "0", "0", "1", "1", "128", "1", "128", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "CodeModel", "::", "Model", "M", "=", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ";", "Reloc", "::", "Model", "R", "=", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", ";", "if", "(", "!", "X86", "::", "isOffsetSuitableForCodeModel", "(", "AM", ".", "BaseOffs", ",", "M", ",", "AM", ".", "BaseGV", "!=", "nullptr", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "unsigned", "GVFlags", "=", "Subtarget", "->", "ClassifyGlobalReference", "(", "AM", ".", "BaseGV", ",", "getTargetMachine", "(", ")", ")", ";", "if", "(", "isGlobalStubReference", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "isGlobalRelativeToPICBase", "(", "GVFlags", ")", ")", "return", "false", ";", "if", "(", "(", "M", "!=", "CodeModel", "::", "Small", "||", "R", "!=", "Reloc", "::", "Static", ")", "&&", "Subtarget", "->", "is64Bit", "(", ")", "&&", "(", "AM", ".", "BaseOffs", "||", "AM", ".", "Scale", ">", "1", ")", ")", "return", "false", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "4", ":", "case", "8", ":", "break", ";", "case", "3", ":", "case", "5", ":", "case", "9", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "X86", "X86", "X86::isOffsetSuitableForCodeModel", "1", "0", "1", "2", "4", "8", "3", "5", "9" ]

[]

[ "<s>", "static", "void", "rs6000_finish_cost", "(", "void", "*", "data", ",", "unsigned", "*", "prologue_cost", ",", "unsigned", "*", "body_cost", ",", "unsigned", "*", "epilogue_cost", ")", "{", "rs6000_cost_data", "*", "cost_data", "=", "(", "rs6000_cost_data", "*", ")", "data", ";", "if", "(", "cost_data", "->", "loop_info", ")", "{", "rs6000_adjust_vect_cost_per_loop", "(", "cost_data", ")", ";", "rs6000_density_test", "(", "cost_data", ")", ";", "}", "if", "(", "cost_data", "->", "loop_info", ")", "{", "loop_vec_info", "vec_info", "=", "loop_vec_info_for_loop", "(", "cost_data", "->", "loop_info", ")", ";", "if", "(", "!", "rs6000_vect_nonmem", "&&", "LOOP_VINFO_VECT_FACTOR", "(", "vec_info", ")", "==", "2", "&&", "LOOP_REQUIRES_VERSIONING", "(", "vec_info", ")", ")", "cost_data", "->", "cost", "[", "vect_body", "]", "+=", "10000", ";", "}", "*", "prologue_cost", "=", "cost_data", "->", "cost", "[", "vect_prologue", "]", ";", "*", "body_cost", "=", "cost_data", "->", "cost", "[", "vect_body", "]", ";", "*", "epilogue_cost", "=", "cost_data", "->", "cost", "[", "vect_epilogue", "]", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.finish_cost", "." ]

[ "rs6000", "2", "10000" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "MCInst", "const", "&", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "MBlazeTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDNode", "*", "Node", "=", "LowerLOAD", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ".", "getNode", "(", ")", ";", "if", "(", "!", "Node", ")", "return", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Node", ",", "0", ")", ")", ";", "Results", ".", "push_back", "(", "SDValue", "(", "Node", ",", "1", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "1", ")", ",", "SDValue", "(", "Node", ",", "1", ")", ")", ";", "return", ";", "}", "case", "ISD", "::", "STORE", ":", "{", "SDValue", "Lowered", "=", "LowerSTORE", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "Lowered", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Lowered", ")", ";", "return", ";", "}", "default", ":", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "AMDGPU", "AMDGPU", "ISD::SIGN_EXTEND_INREG", "ISD::LOAD", "0", "0", "1", "1", "1", "ISD::STORE", "0" ]

[]

[ "<s>", "bool", "F2003fInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "F2003f", "F2003f" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonRemoveExtendArgs", "(", "TM", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "\"After hexagon peephole pass\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon peephole pass\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "ST", "->", "hasAVX", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "cast", "<", "FixedVectorType", ">", "(", "DataTy", ")", "->", "getNumElements", "(", ")", "==", "1", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isHalfTy", "(", ")", "&&", "ST", "->", "hasBWI", "(", ")", "&&", "ST", "->", "hasFP16", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", "||", "(", "(", "IntWidth", "==", "8", "||", "IntWidth", "==", "16", ")", "&&", "ST", "->", "hasBWI", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "32", "64", "8", "16" ]

[]

[ "<s>", "static", "bool", "indirectable_address_p", "(", "rtx", "x", ",", "bool", "strict", ",", "bool", "indirect", ")", "{", "if", "(", "indirectable_constant_address_p", "(", "x", ",", "indirect", ")", "||", "BASE_REGISTER_P", "(", "x", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", "||", "!", "BASE_REGISTER_P", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", "||", "(", "flag_pic", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "false", ";", "return", "indirectable_constant_address_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "indirect", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "X", "is", "an", "address", "which", "can", "be", "indirected", ".", "External", "symbols", "could", "be", "in", "a", "sharable", "image", "library", ",", "so", "we", "disallow", "those", "." ]

[ "vax", "0", "1", "1" ]

[]

[ "<s>", "bool", "aarch64_sve_float_mul_immediate_p", "(", "rtx", "x", ")", "{", "rtx", "elt", ";", "return", "(", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "CONST_DOUBLE_P", "(", "elt", ")", "&&", "(", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "&", "dconsthalf", ")", "||", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "elt", ")", ",", "&", "dconst2", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "operand", "for", "an", "SVE", "FMUL", "instruction", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "return", "33", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "RISCV", "RISCV", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "33", "1" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "ST", "->", "hasAVX", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "cast", "<", "FixedVectorType", ">", "(", "DataTy", ")", "->", "getNumElements", "(", ")", "==", "1", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", "||", "(", "(", "IntWidth", "==", "8", "||", "IntWidth", "==", "16", ")", "&&", "ST", "->", "hasBWI", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "32", "64", "8", "16" ]

[]

[ "<s>", "bool", "isLegalNTStore", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "if", "(", "auto", "*", "DataTypeVTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "DataType", ")", ")", "{", "unsigned", "NumElements", "=", "DataTypeVTy", "->", "getNumElements", "(", ")", ";", "unsigned", "EltSize", "=", "DataTypeVTy", "->", "getElementType", "(", ")", "->", "getScalarSizeInBits", "(", ")", ";", "return", "NumElements", ">", "1", "&&", "isPowerOf2_64", "(", "NumElements", ")", "&&", "EltSize", ">=", "8", "&&", "EltSize", "<=", "128", "&&", "isPowerOf2_64", "(", "EltSize", ")", ";", "}", "return", "BaseT", "::", "isLegalNTStore", "(", "DataType", ",", "Alignment", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "nontemporal", "store", "." ]

[ "AArch64", "1", "8", "128" ]

[]

[ "<s>", "void", "TVMTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "if", "(", "!", "Res", ".", "getNode", "(", ")", ")", "return", ";", "assert", "(", "(", "N", "->", "getNumValues", "(", ")", "<=", "Res", "->", "getNumValues", "(", ")", ")", "&&", "\"Lowering returned the wrong number of results!\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "N", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "TVM", "TVM", "0", "\"Lowering returned the wrong number of results!\"", "0" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "Subtarget", "=", "&", "F", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "F", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "F", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "unsigned", "aarch64_add_stmt_cost", "(", "class", "vec_info", "*", "vinfo", ",", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "tree", "vectype", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "auto", "*", "costs", "=", "static_cast", "<", "aarch64_vector_costs", "*", ">", "(", "data", ")", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "int", "stmt_cost", "=", "aarch64_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "loop_vec_info", "loop_vinfo", "=", "dyn_cast", "<", "loop_vec_info", ">", "(", "vinfo", ")", ";", "bb_vec_info", "bb_vinfo", "=", "dyn_cast", "<", "bb_vec_info", ">", "(", "vinfo", ")", ";", "if", "(", "!", "costs", "->", "analyzed_vinfo", "&&", "aarch64_use_new_vector_costs_p", "(", ")", ")", "{", "if", "(", "loop_vinfo", ")", "aarch64_analyze_loop_vinfo", "(", "loop_vinfo", ",", "costs", ")", ";", "else", "aarch64_analyze_bb_vinfo", "(", "bb_vinfo", ",", "costs", ")", ";", "costs", "->", "analyzed_vinfo", "=", "true", ";", "}", "if", "(", "stmt_info", "&&", "aarch64_use_new_vector_costs_p", "(", ")", ")", "{", "if", "(", "vectype", "&&", "aarch64_sve_only_stmt_p", "(", "stmt_info", ",", "vectype", ")", ")", "costs", "->", "saw_sve_only_op", "=", "true", ";", "stmt_cost", "=", "aarch64_detect_scalar_stmt_subtype", "(", "vinfo", ",", "kind", ",", "stmt_info", ",", "stmt_cost", ")", ";", "if", "(", "vectype", "&&", "costs", "->", "vec_flags", ")", "stmt_cost", "=", "aarch64_detect_vector_stmt_subtype", "(", "vinfo", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "where", ",", "stmt_cost", ")", ";", "}", "if", "(", "stmt_info", "&&", "vectype", "&&", "aarch64_sve_mode_p", "(", "TYPE_MODE", "(", "vectype", ")", ")", ")", "stmt_cost", "=", "aarch64_sve_adjust_stmt_cost", "(", "vinfo", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "stmt_cost", ")", ";", "if", "(", "stmt_info", "&&", "aarch64_use_new_vector_costs_p", "(", ")", ")", "{", "stmt_cost", "=", "aarch64_adjust_stmt_cost", "(", "kind", ",", "stmt_info", ",", "vectype", ",", "stmt_cost", ")", ";", "auto", "*", "issue_info", "=", "aarch64_tune_params", ".", "vec_costs", "->", "issue_info", ";", "if", "(", "loop_vinfo", "&&", "issue_info", "&&", "costs", "->", "vec_flags", "&&", "where", "==", "vect_body", "&&", "vectype", "&&", "stmt_cost", "!=", "0", ")", "{", "aarch64_count_ops", "(", "vinfo", ",", "costs", ",", "count", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "0", ",", "&", "costs", "->", "scalar_ops", ",", "issue_info", "->", "scalar", ",", "vect_nunits_for_cost", "(", "vectype", ")", ")", ";", "if", "(", "aarch64_sve_mode_p", "(", "vinfo", "->", "vector_mode", ")", "&&", "issue_info", "->", "sve", ")", "{", "aarch64_count_ops", "(", "vinfo", ",", "costs", ",", "count", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "VEC_ADVSIMD", ",", "&", "costs", "->", "advsimd_ops", ",", "issue_info", "->", "advsimd", ",", "aarch64_estimated_sve_vq", "(", ")", ")", ";", "aarch64_count_ops", "(", "vinfo", ",", "costs", ",", "count", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "VEC_ANY_SVE", ",", "&", "costs", "->", "sve_ops", ",", "issue_info", "->", "sve", ",", "1", ")", ";", "}", "else", "aarch64_count_ops", "(", "vinfo", ",", "costs", ",", "count", ",", "kind", ",", "stmt_info", ",", "vectype", ",", "VEC_ADVSIMD", ",", "&", "costs", "->", "advsimd_ops", ",", "issue_info", "->", "advsimd", ",", "1", ")", ";", "}", "if", "(", "where", "==", "vect_body", "&&", "costs", "->", "unrolled_advsimd_niters", ")", "costs", "->", "unrolled_advsimd_stmts", "+=", "count", "*", "costs", "->", "unrolled_advsimd_niters", ";", "}", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "vinfo", ",", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "costs", "->", "region", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "aarch64", "0", "0", "0", "1", "1", "50" ]

[]

[ "<s>", "static", "bool", "riscv_classify_address", "(", "struct", "riscv_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "case", "LO_SUM", ":", "info", "->", "type", "=", "ADDRESS_LO_SUM", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "info", "->", "symbol_type", "=", "riscv_classify_symbolic_expression", "(", "info", "->", "offset", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_lo_sum_p", "(", "info", "->", "symbol_type", ",", "mode", ",", "info", "->", "offset", ")", ")", ";", "case", "CONST_INT", ":", "info", "->", "type", "=", "ADDRESS_CONST_INT", ";", "return", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

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

[]

[ "<s>", "static", "unsigned", "long", "arm_isr_value", "(", "tree", "argument", ")", "{", "const", "isr_attribute_arg", "*", "ptr", ";", "const", "char", "*", "arg", ";", "if", "(", "argument", "==", "NULL_TREE", ")", "return", "ARM_FT_ISR", ";", "if", "(", "TREE_VALUE", "(", "argument", ")", "==", "NULL_TREE", "||", "TREE_CODE", "(", "TREE_VALUE", "(", "argument", ")", ")", "!=", "STRING_CST", ")", "return", "ARM_FT_UNKNOWN", ";", "arg", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "argument", ")", ")", ";", "for", "(", "ptr", "=", "isr_attribute_args", ";", "ptr", "->", "arg", "!=", "NULL", ";", "ptr", "++", ")", "if", "(", "streq", "(", "arg", ",", "ptr", "->", "arg", ")", ")", "return", "ptr", "->", "return_value", ";", "return", "ARM_FT_UNKNOWN", ";", "}", "</s>" ]

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

[ "arm" ]

[]

[ "<s>", "Register", "PPCTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "bool", "IsDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "bool", "is64Bit", "=", "isPPC64", "&&", "VT", "==", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "!", "is64Bit", "&&", "VT", "!=", "LLT", "::", "scalar", "(", "32", ")", ")", "report_fatal_error", "(", "\"Invalid register global variable type\"", ")", ";", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"r1\"", ",", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ")", ".", "Case", "(", "\"r2\"", ",", "(", "IsDarwinABI", "||", "isPPC64", ")", "?", "Register", "(", ")", ":", "PPC", "::", "R2", ")", ".", "Case", "(", "\"r13\"", ",", "(", "!", "isPPC64", "&&", "IsDarwinABI", ")", "?", "Register", "(", ")", ":", "(", "is64Bit", "?", "PPC", "::", "X13", ":", "PPC", "::", "R13", ")", ")", ".", "Default", "(", "Register", "(", ")", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "64", "32", "\"Invalid register global variable type\"", "\"r1\"", "PPC::X1", "PPC::R1", "\"r2\"", "PPC", "PPC::R2", "\"r13\"", "PPC", "PPC::X13", "PPC::R13", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "rtx", "emit_frame_save", "(", "rtx", "frame_reg", ",", "machine_mode", "mode", ",", "unsigned", "int", "regno", ",", "int", "offset", ",", "HOST_WIDE_INT", "frame_reg_to_sp", ")", "{", "rtx", "reg", ",", "insn", ";", "gcc_checking_assert", "(", "!", "(", "(", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_VSX", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "mode", ")", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "mode", "==", "DFmode", ")", "||", "(", "TARGET_SPE_ABI", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", "&&", "!", "SPE_CONST_OFFSET_OK", "(", "offset", ")", ")", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "reg", ",", "frame_reg", ",", "offset", ")", ")", ";", "return", "rs6000_frame_related", "(", "insn", ",", "frame_reg", ",", "frame_reg_to_sp", ",", "NULL_RTX", ",", "NULL_RTX", ")", ";", "}", "</s>" ]

[ "Save", "a", "register", "into", "the", "frame", ",", "and", "emit", "RTX_FRAME_RELATED_P", "notes", ".", "Save", "REGNO", "into", "[", "FRAME_REG", "+", "OFFSET", "]", "in", "mode", "MODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "rtx", "fusion_wrap_memory_address", "(", "rtx", "old_mem", ")", "{", "rtx", "old_addr", "=", "XEXP", "(", "old_mem", ",", "0", ")", ";", "rtvec", "v", "=", "gen_rtvec", "(", "1", ",", "old_addr", ")", ";", "rtx", "new_addr", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "v", ",", "UNSPEC_FUSION_ADDIS", ")", ";", "return", "replace_equiv_address_nv", "(", "old_mem", ",", "new_addr", ",", "false", ")", ";", "}", "</s>" ]

[ "Wrap", "a", "TOC", "address", "that", "can", "be", "fused", "to", "indicate", "that", "special", "fusion", "processing", "is", "needed", "." ]

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

[]

[ "<s>", "bool", "aarch64_sve_arith_immediate_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "negate_p", ")", "{", "rtx", "elt", "=", "unwrap_const_vec_duplicate", "(", "x", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "elt", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "elt", ")", ";", "if", "(", "negate_p", ")", "val", "=", "-", "val", ";", "val", "&=", "GET_MODE_MASK", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "if", "(", "val", "&", "0xff", ")", "return", "IN_RANGE", "(", "val", ",", "0", ",", "0xff", ")", ";", "return", "IN_RANGE", "(", "val", ",", "0", ",", "0xff00", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "the", "SVE", "ADD", "and", "SUB", "instructions", ".", "Negate", "X", "first", "if", "NEGATE_P", "is", "true", "." ]

[ "aarch64", "0xff", "0", "0xff", "0", "0xff00" ]

[]

[ "<s>", "void", "i386_pe_seh_cold_init", "(", "FILE", "*", "f", ",", "const", "char", "*", "name", ")", "{", "struct", "seh_frame_state", "*", "seh", ";", "HOST_WIDE_INT", "alloc_offset", ",", "offset", ";", "if", "(", "!", "TARGET_SEH", ")", "return", ";", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "seh", "=", "cfun", "->", "machine", "->", "seh", ";", "fputs", "(", "\"\\t.seh_proc\\t\"", ",", "f", ")", ";", "assemble_name", "(", "f", ",", "name", ")", ";", "fputc", "(", "'\\n'", ",", "f", ")", ";", "if", "(", "crtl", "->", "accesses_prior_frames", ")", "alloc_offset", "=", "seh", "->", "cfa_offset", ";", "else", "alloc_offset", "=", "seh", "->", "sp_offset", ";", "offset", "=", "alloc_offset", "-", "INCOMING_FRAME_SP_OFFSET", ";", "if", "(", "offset", ">", "0", "&&", "offset", "<", "SEH_MAX_FRAME_SIZE", ")", "fprintf", "(", "f", ",", "\"\\t.seh_stackalloc\\t\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "seh", "->", "reg_offset", "[", "regno", "]", ">", "0", ")", "{", "fputs", "(", "(", "SSE_REGNO_P", "(", "regno", ")", "?", "\"\\t.seh_savexmm\\t\"", ":", "GENERAL_REGNO_P", "(", "regno", ")", "?", "\"\\t.seh_savereg\\t\"", ":", "(", "gcc_unreachable", "(", ")", ",", "\"\"", ")", ")", ",", "f", ")", ";", "print_reg", "(", "gen_rtx_REG", "(", "DImode", ",", "regno", ")", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "alloc_offset", "-", "seh", "->", "reg_offset", "[", "regno", "]", ")", ";", "}", "if", "(", "seh", "->", "cfa_reg", "!=", "stack_pointer_rtx", ")", "{", "offset", "=", "alloc_offset", "-", "seh", "->", "cfa_offset", ";", "gcc_assert", "(", "(", "offset", "&", "15", ")", "==", "0", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "offset", ",", "0", ",", "240", ")", ")", ";", "fputs", "(", "\"\\t.seh_setframe\\t\"", ",", "f", ")", ";", "print_reg", "(", "seh", "->", "cfa_reg", ",", "0", ",", "f", ")", ";", "fprintf", "(", "f", ",", "\", \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "}", "if", "(", "crtl", "->", "accesses_prior_frames", ")", "{", "offset", "=", "seh", "->", "sp_offset", "-", "alloc_offset", ";", "if", "(", "offset", ">", "0", "&&", "offset", "<", "SEH_MAX_FRAME_SIZE", ")", "fprintf", "(", "f", ",", "\"\\t.seh_stackalloc\\t\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "offset", ")", ";", "}", "fputs", "(", "\"\\t.seh_endprologue\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Emit", "assembler", "directives", "to", "reconstruct", "the", "SEH", "state", "." ]

[ "i386", "\"\\t.seh_proc\\t\"", "0", "\"\\t.seh_stackalloc\\t\"", "\"\\n\"", "0", "0", "\"\\t.seh_savexmm\\t\"", "\"\\t.seh_savereg\\t\"", "\"\"", "0", "\", \"", "\"\\n\"", "15", "0", "0", "240", "\"\\t.seh_setframe\\t\"", "0", "\", \"", "\"\\n\"", "0", "\"\\t.seh_stackalloc\\t\"", "\"\\n\"", "\"\\t.seh_endprologue\\n\"" ]

[]

[ "<s>", "static", "bool", "arm_cannot_copy_insn_p", "(", "rtx", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "SET", ")", "{", "rtx", "rhs", "=", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "rhs", ")", "==", "UNSPEC", "&&", "XINT", "(", "rhs", ",", "1", ")", "==", "UNSPEC_PIC_BASE", ")", "return", "TRUE", ";", "if", "(", "GET_CODE", "(", "rhs", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "rhs", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "rhs", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_PIC_BASE", ")", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "Must", "not", "copy", "any", "rtx", "that", "uses", "a", "pc-relative", "address", "." ]

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

[]

[ "<s>", "void", "AMDGPUPALMetadata", "::", "reset", "(", ")", "{", "MsgPackDoc", ".", "clear", "(", ")", ";", "Registers", "=", "MsgPackDoc", ".", "getEmptyNode", "(", ")", ";", "HwStages", "=", "MsgPackDoc", ".", "getEmptyNode", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "dimode_scalar_to_vector_candidate_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "def_set", ")", "return", "false", ";", "if", "(", "has_non_address_hard_reg", "(", "insn", ")", ")", "return", "false", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", "return", "convertible_comparison_p", "(", "insn", ")", ";", "if", "(", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "src", ")", ")", "||", "GET_MODE", "(", "dst", ")", "!=", "DImode", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "dst", ")", "&&", "!", "MEM_P", "(", "dst", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ",", "0", ",", "63", ")", ")", "return", "false", ";", "break", ";", "case", "PLUS", ":", "case", "MINUS", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "NEG", ":", "case", "NOT", ":", "break", ";", "case", "REG", ":", "return", "true", ";", "case", "MEM", ":", "case", "CONST_INT", ":", "return", "REG_P", "(", "dst", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "AND", "||", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "NOT", "||", "!", "REG_P", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ")", ")", ")", "return", "false", ";", "if", "(", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "||", "(", "GET_CODE", "(", "src", ")", "!=", "NEG", "&&", "GET_CODE", "(", "src", ")", "!=", "NOT", "&&", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "DImode", "version", "of", "scalar_to_vector_candidate_p", "." ]

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

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", "->", "isDarwin", "(", ")", ")", "RegName", "=", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'U'", ":", "case", "'X'", ":", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"r0\"", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "if", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "AMDGPU", "::", "SP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getScratchRSrcReg", "(", ")", "!=", "AMDGPU", "::", "PRIVATE_RSRC_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "if", "(", "Info", "->", "getFrameOffsetReg", "(", ")", "!=", "AMDGPU", "::", "FP_REG", ")", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "Info", "->", "limitOccupancy", "(", "MF", ")", ";", "if", "(", "ST", ".", "isWave32", "(", ")", "&&", "!", "MF", ".", "empty", "(", ")", ")", "{", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstNonDebugInstr", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ")", ",", "AMDGPU", "::", "VCC_HI", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "TII", "->", "fixImplicitOperands", "(", "MI", ")", ";", "}", "}", "}", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::FP_REG", "SI", "AMDGPU::VCC_HI" ]

[]

[ "<s>", "rtx", "aarch64_ptrue_reg", "(", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_BOOL", ")", ";", "rtx", "reg", "=", "force_reg", "(", "VNx16BImode", ",", "CONSTM1_RTX", "(", "VNx16BImode", ")", ")", ";", "return", "gen_lowpart", "(", "mode", ",", "reg", ")", ";", "}", "</s>" ]

[ "Return", "an", "all-true", "predicate", "register", "of", "mode", "MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "unsigned", "Size", "=", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "?", "4", ":", "8", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "Size", "-", "i", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "Idx", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "IsLittleEndian", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", ">>", "8", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", ">>", "8", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", "&", "0xFF", ";", "}", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "4", "8", "0", "8", "8", "8", "2", "0xFF", "3", "8", "2", "8", "3", "0xFF" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", "::", "MC_PATTERN", ">", "&", "Patterns", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "if", "(", "!", "Root", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "Options", ".", "UnsafeFPMath", ")", "return", "false", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableInstSimplify", ")", "addPass", "(", "createInstSimplifyLegacyPass", "(", ")", ")", ";", "addPass", "(", "createDeadCodeEliminationPass", "(", ")", ")", ";", "}", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableInitialCFGCleanup", ")", "addPass", "(", "createCFGSimplificationPass", "(", "SimplifyCFGOptions", "(", ")", ".", "forwardSwitchCondToPhi", "(", "true", ")", ".", "convertSwitchToLookupTable", "(", "true", ")", ".", "needCanonicalLoops", "(", "false", ")", ".", "hoistCommonInsts", "(", "true", ")", ".", "sinkCommonInsts", "(", "true", ")", ")", ")", ";", "if", "(", "EnableLoopPrefetch", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "EnableCommGEP", ")", "addPass", "(", "createHexagonCommonGEP", "(", ")", ")", ";", "if", "(", "EnableGenExtract", ")", "addPass", "(", "createHexagonGenExtract", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "emitValueImpl", "(", "const", "MCExpr", "*", "Value", ",", "unsigned", "Size", ",", "SMLoc", "Loc", ")", "override", "{", "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast_or_null", "<", "MCSymbolRefExpr", ">", "(", "Value", ")", ")", "{", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_ARM_SBREL", "&&", "!", "(", "Size", "==", "4", ")", ")", "{", "getContext", "(", ")", ".", "reportError", "(", "Loc", ",", "\"relocated expression must be 32-bit\"", ")", ";", "return", ";", "}", "getOrCreateDataFragment", "(", ")", ";", "}", "emitDataMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "emitValueImpl", "(", "Value", ",", "Size", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Overriding", "these", "functions", "allows", "us", "to", "dismiss", "all", "labels", "that", "are", "candidates", "for", "marking", "as", "microMIPS", "when", ".word/.long/.4byte", "etc", "directives", "are", "emitted", "." ]

[ "ARM", "ARM", "4", "\"relocated expression must be 32-bit\"" ]

[]

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

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

[ "Videocore", "Videocore" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "aarch64_move_imm", "(", "HOST_WIDE_INT", "val", ",", "machine_mode", "mode", ")", "{", "scalar_int_mode", "int_mode", ";", "if", "(", "!", "is_a", "<", "scalar_int_mode", ">", "(", "mode", ",", "&", "int_mode", ")", ")", "return", "false", ";", "if", "(", "aarch64_movw_imm", "(", "val", ",", "int_mode", ")", "||", "aarch64_movw_imm", "(", "~", "val", ",", "int_mode", ")", ")", "return", "1", ";", "return", "aarch64_bitmask_imm", "(", "val", ",", "int_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "is", "an", "immediate", "that", "can", "be", "loaded", "into", "a", "register", "in", "a", "single", "instruction", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "MCSymbol", "*", "Z80MCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "!=", "0", ")", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "return", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "\"Unknown target flag on GV operand\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "CAHPTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "BB", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "CAHP", "::", "Select_GPR_Using_CC_GPR", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "++", "BB", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "*", "HeadMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TailMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "IfFalseMBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "IfFalseMBB", ")", ";", "F", "->", "insert", "(", "I", ",", "TailMBB", ")", ";", "TailMBB", "->", "splice", "(", "TailMBB", "->", "begin", "(", ")", ",", "HeadMBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "HeadMBB", "->", "end", "(", ")", ")", ";", "TailMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "HeadMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "IfFalseMBB", ")", ";", "HeadMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "unsigned", "LHS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "RHS", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "auto", "CC", "=", "static_cast", "<", "ISD", "::", "CondCode", ">", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "unsigned", "Opcode", "=", "getBranchOpcodeForIntCondCode", "(", "CC", ")", ";", "BuildMI", "(", "HeadMBB", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "LHS", ")", ".", "addReg", "(", "RHS", ")", ".", "addMBB", "(", "TailMBB", ")", ";", "IfFalseMBB", "->", "addSuccessor", "(", "TailMBB", ")", ";", "BuildMI", "(", "*", "TailMBB", ",", "TailMBB", "->", "begin", "(", ")", ",", "DL", ",", "TII", ".", "get", "(", "CAHP", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "HeadMBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "5", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "IfFalseMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "TailMBB", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "CAHP::Select_GPR_Using_CC_GPR", "\"Unexpected instr type to insert\"", "1", "2", "ISD::CondCode", "3", "CAHP::PHI", "0", "4", "5" ]

[]

[ "<s>", "void", "dump", "(", "raw_ostream", "&", "os", ",", "unsigned", "indent", ")", "const", "{", "printID", "(", "os", ".", "indent", "(", "indent", ")", ")", "<<", "\":\\n\"", ";", "os", ".", "indent", "(", "indent", "+", "2", ")", "<<", "\"Definitions:{\"", ";", "for", "(", "auto", "def", ":", "Definitions", ")", "{", "os", "<<", "\"(\"", "<<", "def", ".", "predicate", "<<", "\", \"", "<<", "def", ".", "guard", "<<", "\", \"", "<<", "def", ".", "useBlock", "<<", "\"), \"", ";", "}", "os", "<<", "\"}\\n\"", ";", "os", ".", "indent", "(", "indent", "+", "2", ")", "<<", "\"ExitTargets:{\"", ";", "for", "(", "auto", "t", ":", "ExitTargets", ")", "{", "os", "<<", "t", "<<", "\", \"", ";", "}", "os", "<<", "\"}\\n\"", ";", "os", ".", "indent", "(", "indent", "+", "2", ")", "<<", "\"Successors:{\"", ";", "for", "(", "auto", "t", ":", "Successors", ")", "{", "os", "<<", "\"(\"", "<<", "t", ".", "first", "<<", "\", \"", "<<", "t", ".", "second", "<<", "\"), \"", ";", "}", "os", "<<", "\"}\\n\"", ";", "os", ".", "indent", "(", "indent", "+", "2", ")", "<<", "\"Remnants:{\"", ";", "for", "(", "auto", "t", ":", "Remnants", ")", "{", "os", "<<", "t", "<<", "\", \"", ";", "}", "os", "<<", "\"}\\n\"", ";", "printInstructions", "(", "os", ",", "indent", "+", "2", ")", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "Patmos", "\":\\n\"", "2", "\"Definitions:{\"", "\"(\"", "\", \"", "\", \"", "\"), \"", "\"}\\n\"", "2", "\"ExitTargets:{\"", "\", \"", "\"}\\n\"", "2", "\"Successors:{\"", "\"(\"", "\", \"", "\"), \"", "\"}\\n\"", "2", "\"Remnants:{\"", "\", \"", "\"}\\n\"", "2" ]

[]

[ "<s>", "static", "void", "rl78_alloc_physical_registers_umul", "(", "rtx_insn", "*", "insn", ")", "{", "rtx_insn", "*", "prev", "=", "prev_nonnote_nondebug_insn", "(", "insn", ")", ";", "rtx", "first", ";", "int", "tmp_id", ";", "rtx", "saved_op1", ";", "OP", "(", "0", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "0", ")", ",", "BC", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "1", ")", ",", "DE", ",", "insn", ")", ";", "OP", "(", "2", ")", "=", "transcode_memory_rtx", "(", "OP", "(", "2", ")", ",", "HL", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "recog_data", ".", "constraints", "[", "1", "]", "[", "0", "]", "==", "'%'", "&&", "is_virtual_register", "(", "OP", "(", "1", ")", ")", "&&", "!", "is_virtual_register", "(", "OP", "(", "2", ")", ")", "&&", "!", "CONSTANT_P", "(", "OP", "(", "2", ")", ")", ")", "{", "rtx", "tmp", "=", "OP", "(", "1", ")", ";", "OP", "(", "1", ")", "=", "OP", "(", "2", ")", ";", "OP", "(", "2", ")", "=", "tmp", ";", "}", "OP", "(", "0", ")", "=", "move_from_acc", "(", "0", ",", "insn", ")", ";", "tmp_id", "=", "get_max_insn_count", "(", ")", ";", "saved_op1", "=", "OP", "(", "1", ")", ";", "if", "(", "rtx_equal_p", "(", "OP", "(", "1", ")", ",", "OP", "(", "2", ")", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "OP", "(", "2", ")", ")", "==", "QImode", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "insn", ")", ";", "OP", "(", "1", ")", "=", "A", ";", "}", "else", "OP", "(", "1", ")", "=", "move_to_acc", "(", "1", ",", "insn", ")", ";", "MAYBE_OK", "(", "insn", ")", ";", "if", "(", "tmp_id", "==", "get_max_insn_count", "(", ")", ")", "force_into_acc", "(", "saved_op1", ",", "insn", ")", ";", "if", "(", "prev", ")", "first", "=", "next_nonnote_nondebug_insn", "(", "prev", ")", ";", "else", "for", "(", "first", "=", "insn", ";", "prev_nonnote_nondebug_insn", "(", "first", ")", ";", "first", "=", "prev_nonnote_nondebug_insn", "(", "first", ")", ")", ";", "OP", "(", "2", ")", "=", "move_to_x", "(", "2", ",", "first", ")", ";", "MUST_BE_OK", "(", "insn", ")", ";", "}", "</s>" ]

[ "Like", "op2", ",", "but", "AX", "=", "A", "*", "X", "." ]

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

[]

[ "<s>", "const", "uint16_t", "*", "HSAILRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "0" ]

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "bool", "ir_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "false", ";", "return", "(", "REG_P", "(", "XEXP", "(", "op", ",", "0", ")", ")", "&&", "z8k_reg_ok_for_base_p", "(", "XEXP", "(", "op", ",", "0", ")", ")", ")", "||", "(", "reload_in_progress", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "op", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ";", "}", "</s>" ]

[ "Also", "accept", "(", "MEM", "(", "pseudo", ")", ")", "here", "during", "reload", ",", "because", "the", "pseudo", "is", "guaranteed", "to", "be", "reloaded", "into", "a", "PTR", "reg", "." ]

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

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "DL", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "getArgumentList", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "1", ",", "DL", ",", "F", ")", ";", "ArgInfos", ".", "push_back", "(", "AInfo", ")", ";", "Idx", "++", ";", "}", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "CC_X86", ",", "DL", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "0", "1", "X86" ]

[]

[ "<s>", "bool", "arc_raw_symbolic_reference_mentioned_p", "(", "rtx", "op", ",", "bool", "skip_local", ")", "{", "register", "const", "char", "*", "fmt", ";", "register", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "UNSPEC", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "return", "!", "skip_local", "||", "!", "decl", "||", "!", "default_binds_local_p", "(", "decl", ")", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "register", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "arc_raw_symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "arc_raw_symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ",", "skip_local", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "a", "SYMBOL_REF", "that", "is", "not", "wrapped", "in", "an", "unspec", ".", "If", "SKIP_LOCAL", "is", "true", ",", "skip", "symbols", "that", "bind", "locally", ".", "This", "is", "used", "further", "down", "in", "this", "file", ",", "and", ",", "without", "SKIP_LOCAL", ",", "in", "the", "addsi3", "/", "subsi3", "expanders", "when", "generating", "PIC", "code", "." ]

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

[]

[ "<s>", "void", "ix86_expand_sse2_abs", "(", "rtx", "target", ",", "rtx", "input", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "rtx", "tmp0", ",", "tmp1", ",", "x", ";", "switch", "(", "mode", ")", "{", "case", "E_V4SImode", ":", "tmp0", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFTRT", ",", "input", ",", "GEN_INT", "(", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", "-", "1", ")", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "tmp1", "=", "expand_simple_binop", "(", "mode", ",", "XOR", ",", "tmp0", ",", "input", ",", "NULL", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "x", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "tmp1", ",", "tmp0", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "E_V8HImode", ":", "tmp0", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "input", ",", "NULL_RTX", ",", "0", ")", ";", "x", "=", "expand_simple_binop", "(", "mode", ",", "SMAX", ",", "tmp0", ",", "input", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "E_V16QImode", ":", "tmp0", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "input", ",", "NULL_RTX", ",", "0", ")", ";", "x", "=", "expand_simple_binop", "(", "V16QImode", ",", "UMIN", ",", "tmp0", ",", "input", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "x", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "x", ")", ";", "}", "</s>" ]

[ "Calculate", "integer", "abs", "(", ")", "using", "only", "SSE2", "instructions", "." ]

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

[]

[ "<s>", "static", "void", "avr_asm_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "cfun", "->", "machine", "->", "is_naked", ")", "{", "fputs", "(", "\"/* prologue: naked */\\n\"", ",", "file", ")", ";", "}", "else", "{", "if", "(", "cfun", "->", "machine", "->", "is_interrupt", ")", "{", "fputs", "(", "\"/* prologue: Interrupt */\\n\"", ",", "file", ")", ";", "}", "else", "if", "(", "cfun", "->", "machine", "->", "is_signal", ")", "{", "fputs", "(", "\"/* prologue: Signal */\\n\"", ",", "file", ")", ";", "}", "else", "fputs", "(", "\"/* prologue: function */\\n\"", ",", "file", ")", ";", "}", "if", "(", "ACCUMULATE_OUTGOING_ARGS", ")", "fprintf", "(", "file", ",", "\"/* outgoing args size = %d */\\n\"", ",", "avr_outgoing_args_size", "(", ")", ")", ";", "fprintf", "(", "file", ",", "\"/* frame size = \"", "HOST_WIDE_INT_PRINT_DEC", "\" */\\n\"", ",", "(", "HOST_WIDE_INT", ")", "get_frame_size", "(", ")", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "gasisr", ".", "yes", ")", "{", "fprintf", "(", "file", ",", "\"/* stack size = %d */\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d\\n\"", ",", "cfun", "->", "machine", "->", "stack_usage", ")", ";", "}", "else", "{", "int", "used_by_gasisr", "=", "3", "+", "(", "cfun", "->", "machine", "->", "gasisr", ".", "regno", "!=", "AVR_TMP_REGNO", ")", ";", "int", "to", "=", "cfun", "->", "machine", "->", "stack_usage", ";", "int", "from", "=", "to", "-", "used_by_gasisr", ";", "fprintf", "(", "file", ",", "\"/* stack size = %d...%d */\\n\"", ",", "from", ",", "to", ")", ";", "fprintf", "(", "file", ",", "\".L__stack_usage = %d + __gcc_isr.n_pushed\\n\"", ",", "from", ")", ";", "}", "}", "</s>" ]

[ "Output", "summary", "at", "end", "of", "function", "prologue", "." ]

[ "avr", "\"/* prologue: naked */\\n\"", "\"/* prologue: Interrupt */\\n\"", "\"/* prologue: Signal */\\n\"", "\"/* prologue: function */\\n\"", "\"/* outgoing args size = %d */\\n\"", "\"/* frame size = \"", "\" */\\n\"", "\"/* stack size = %d */\\n\"", "\".L__stack_usage = %d\\n\"", "3", "\"/* stack size = %d...%d */\\n\"", "\".L__stack_usage = %d + __gcc_isr.n_pushed\\n\"" ]

[]

[ "<s>", "void", "rs6000_xcoff_declare_function_name", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "tree", "decl", ")", "{", "char", "*", "buffer", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "name", ")", "+", "1", ")", ";", "char", "*", "p", ";", "int", "dollar_inside", "=", "0", ";", "struct", "declare_alias_data", "data", "=", "{", "file", ",", "false", "}", ";", "strcpy", "(", "buffer", ",", "name", ")", ";", "p", "=", "strchr", "(", "buffer", ",", "'$'", ")", ";", "while", "(", "p", ")", "{", "*", "p", "=", "'_'", ";", "dollar_inside", "++", ";", "p", "=", "strchr", "(", "p", "+", "1", ",", "'$'", ")", ";", "}", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "{", "if", "(", "!", "RS6000_WEAK", "||", "!", "DECL_WEAK", "(", "decl", ")", ")", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.globl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "rs6000_xcoff_visibility", "(", "decl", ")", ",", "file", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "else", "{", "if", "(", "dollar_inside", ")", "{", "fprintf", "(", "file", ",", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.rename %s,\\\"%s\\\"\\n\"", ",", "buffer", ",", "name", ")", ";", "}", "fputs", "(", "\"\\t.lglobl .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "fputs", "(", "\"\\t.csect \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\n\"", ":", "\",3\\n\"", ",", "file", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "buffer", ")", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long .\"", ":", "\"\\t.llong .\"", ",", "file", ")", ";", "RS6000_OUTPUT_BASENAME", "(", "file", ",", "buffer", ")", ";", "fputs", "(", "\", TOC[tc0], 0\\n\"", ",", "file", ")", ";", "in_section", "=", "NULL", ";", "switch_to_section", "(", "function_section", "(", "decl", ")", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "buffer", ")", ";", "data", ".", "function_descriptor", "=", "true", ";", "symtab_node", "::", "get", "(", "decl", ")", "->", "call_for_symbol_and_aliases", "(", "rs6000_declare_alias", ",", "&", "data", ",", "true", ")", ";", "if", "(", "!", "DECL_IGNORED_P", "(", "decl", ")", ")", "{", "if", "(", "dwarf_debuginfo_p", "(", ")", ")", "{", "name", "=", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "name", ")", ";", "fprintf", "(", "file", ",", "\"\\t.function .%s,.%s,2,0\\n\"", ",", "name", ",", "name", ")", ";", "}", "}", "return", ";", "}", "</s>" ]

[ "This", "macro", "produces", "the", "initial", "definition", "of", "a", "function", "name", ".", "On", "the", "RS/6000", ",", "we", "need", "to", "place", "an", "extra", "'", ".", "'", "in", "the", "function", "name", "and", "output", "the", "function", "descriptor", ".", "Dollar", "signs", "are", "converted", "to", "underscores", ".", "The", "csect", "for", "the", "function", "will", "have", "already", "been", "created", "when", "text_section", "was", "selected", ".", "We", "do", "have", "to", "go", "back", "to", "that", "csect", ",", "however", ".", "The", "third", "and", "fourth", "parameters", "to", "the", ".function", "pseudo-op", "(", "16", "and", "044", ")", "are", "placeholders", "which", "no", "longer", "have", "any", "use", ".", "Because", "AIX", "assembler", "'s", ".set", "command", "has", "unexpected", "semantics", ",", "we", "output", "all", "aliases", "as", "alternative", "labels", "in", "front", "of", "the", "definition", "." ]

[ "rs6000", "1", "0", "1", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.globl .\"", "\"\\t.rename .%s,\\\".%s\\\"\\n\"", "\"\\t.rename %s,\\\"%s\\\"\\n\"", "\"\\t.lglobl .\"", "\"\\t.csect \"", "\"\\n\"", "\",3\\n\"", "\"\\t.long .\"", "\"\\t.llong .\"", "\", TOC[tc0], 0\\n\"", "\"\\t.function .%s,.%s,2,0\\n\"" ]

[]

[ "<s>", "static", "int", "ix86_multiplication_cost", "(", "const", "struct", "processor_costs", "*", "cost", ",", "enum", "machine_mode", "mode", ")", "{", "machine_mode", "inner_mode", "=", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "if", "(", "SSE_FLOAT_MODE_SSEMATH_OR_HF_P", "(", "mode", ")", ")", "return", "inner_mode", "==", "DFmode", "?", "cost", "->", "mulsd", ":", "cost", "->", "mulss", ";", "else", "if", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "cost", "->", "fmul", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "ix86_vec_cost", "(", "mode", ",", "inner_mode", "==", "DFmode", "?", "cost", "->", "mulsd", ":", "cost", "->", "mulss", ")", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "if", "(", "TARGET_AVX512DQ", ")", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", ")", ";", "if", "(", "mode", "==", "V16QImode", "||", "mode", "==", "V32QImode", ")", "{", "int", "extra", "=", "11", ";", "if", "(", "TARGET_XOP", "&&", "mode", "==", "V16QImode", ")", "extra", "=", "5", ";", "else", "if", "(", "TARGET_SSSE3", ")", "extra", "=", "6", ";", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "extra", ")", ";", "}", "else", "if", "(", "mode", "==", "V2DImode", "||", "mode", "==", "V4DImode", ")", "{", "if", "(", "TARGET_XOP", "&&", "mode", "==", "V2DImode", ")", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "3", ")", ";", "else", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", "*", "3", "+", "cost", "->", "sse_op", "*", "5", ")", ";", "}", "else", "if", "(", "mode", "==", "V4SImode", "&&", "!", "(", "TARGET_SSE4_1", "||", "TARGET_AVX", ")", ")", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", "*", "2", "+", "cost", "->", "sse_op", "*", "5", ")", ";", "else", "return", "ix86_vec_cost", "(", "mode", ",", "cost", "->", "mulss", ")", ";", "}", "else", "return", "(", "cost", "->", "mult_init", "[", "MODE_INDEX", "(", "mode", ")", "]", "+", "cost", "->", "mult_bit", "*", "7", ")", ";", "}", "</s>" ]

[ "Return", "cost", "of", "multiplication", "in", "MODE", "." ]

[ "i386", "11", "5", "6", "2", "2", "3", "3", "5", "2", "5", "7" ]

[]

[ "<s>", "static", "void", "expand_interrupt_handler_epilogue", "(", "rtx", "spreg", ",", "e_funkind", "fkind", ")", "{", "int", "i", ";", "rtx", "postinc1", "=", "gen_rtx_POST_INC", "(", "SImode", ",", "spreg", ")", ";", "rtx", "postinc", "=", "gen_rtx_MEM", "(", "SImode", ",", "postinc1", ")", ";", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "bool", "all", "=", "lookup_attribute", "(", "\"saveall\"", ",", "attrs", ")", "!=", "NULL_TREE", ";", "MEM_VOLATILE_P", "(", "postinc", ")", "=", "1", ";", "do_unlink", "(", "spreg", ",", "get_frame_size", "(", ")", ",", "all", ")", ";", "if", "(", "lookup_attribute", "(", "\"nesting\"", ",", "attrs", ")", ")", "{", "rtx", "srcreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "(", "fkind", "==", "EXCPT_HANDLER", "?", "REG_RETX", ":", "fkind", "==", "NMI_HANDLER", "?", "REG_RETN", ":", "REG_RETI", ")", ")", ";", "emit_move_insn", "(", "srcreg", ",", "postinc", ")", ";", "}", "if", "(", "!", "current_function_is_leaf", ")", "all", "=", "true", ";", "for", "(", "i", "=", "REG_CC", "-", "1", ";", "i", ">", "REG_P7", ";", "i", "--", ")", "if", "(", "all", "||", "regs_ever_live", "[", "i", "]", "||", "(", "!", "leaf_function_p", "(", ")", "&&", "call_used_regs", "[", "i", "]", ")", ")", "{", "if", "(", "i", "==", "REG_A0", "||", "i", "==", "REG_A1", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "PDImode", ",", "postinc1", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "PDImode", ",", "i", ")", ",", "mem", ")", ";", "}", "else", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ",", "postinc", ")", ";", "}", "expand_epilogue_reg_restore", "(", "spreg", ",", "all", ",", "true", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "REG_ASTAT", ")", ",", "postinc", ")", ";", "if", "(", "fkind", "==", "EXCPT_HANDLER", ")", "emit_insn", "(", "gen_addsi3", "(", "spreg", ",", "spreg", ",", "GEN_INT", "(", "12", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_return_internal", "(", "GEN_INT", "(", "fkind", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "an", "epilogue", "suitable", "for", "a", "function", "of", "kind", "FKIND", ".", "This", "is", "called", "for", "interrupt", "and", "exception", "handler", "epilogues", ".", "SPREG", "contains", "(", "reg", ":", "SI", "REG_SP", ")", "." ]

[ "bfin", "\"saveall\"", "1", "\"nesting\"", "1", "1", "12" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isFsqrtCheap", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "f16", ")", "return", "true", ";", "if", "(", "DAG", ".", "doesNodeExist", "(", "X86ISD", "::", "FRSQRT", ",", "DAG", ".", "getVTList", "(", "VT", ")", ",", "Op", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "Subtarget", ".", "hasFastVectorFSQRT", "(", ")", ";", "return", "Subtarget", ".", "hasFastScalarFSQRT", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SQRT", "(", "X", ")", "should", "n't", "be", "replaced", "with", "X", "*", "RSQRT", "(", "X", ")", "." ]

[ "X86", "X86", "MVT::f16", "X86ISD::FRSQRT" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "OR", ":", "return", "PerformORCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "PerformShiftCombine", "(", "N", ",", "DCI", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "PerformIntrinsicCombine", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "AArch64ISD", "::", "NEON_VDUPLANE", ":", "return", "CombineVLDDUP", "(", "N", ",", "DCI", ")", ";", "case", "AArch64ISD", "::", "NEON_LD2DUP", ":", "case", "AArch64ISD", "::", "NEON_LD3DUP", ":", "case", "AArch64ISD", "::", "NEON_LD4DUP", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "Intrinsic", "::", "arm_neon_vld1", ":", "case", "Intrinsic", "::", "arm_neon_vld2", ":", "case", "Intrinsic", "::", "arm_neon_vld3", ":", "case", "Intrinsic", "::", "arm_neon_vld4", ":", "case", "Intrinsic", "::", "arm_neon_vst1", ":", "case", "Intrinsic", "::", "arm_neon_vst2", ":", "case", "Intrinsic", "::", "arm_neon_vst3", ":", "case", "Intrinsic", "::", "arm_neon_vst4", ":", "case", "Intrinsic", "::", "arm_neon_vld2lane", ":", "case", "Intrinsic", "::", "arm_neon_vld3lane", ":", "case", "Intrinsic", "::", "arm_neon_vld4lane", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_vld1x4", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x2", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x3", ":", "case", "Intrinsic", "::", "aarch64_neon_vst1x4", ":", "case", "Intrinsic", "::", "arm_neon_vst2lane", ":", "case", "Intrinsic", "::", "arm_neon_vst3lane", ":", "case", "Intrinsic", "::", "arm_neon_vst4lane", ":", "return", "CombineBaseUpdate", "(", "N", ",", "DCI", ")", ";", "default", ":", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::AND", "ISD::OR", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::INTRINSIC_WO_CHAIN", "AArch64ISD::NEON_VDUPLANE", "AArch64ISD::NEON_LD2DUP", "AArch64ISD::NEON_LD3DUP", "AArch64ISD::NEON_LD4DUP", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::arm_neon_vld1", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "Intrinsic::arm_neon_vst1", "Intrinsic::arm_neon_vst2", "Intrinsic::arm_neon_vst3", "Intrinsic::arm_neon_vst4", "Intrinsic::arm_neon_vld2lane", "Intrinsic::arm_neon_vld3lane", "Intrinsic::arm_neon_vld4lane", "Intrinsic::aarch64_neon_vld1x2", "Intrinsic::aarch64_neon_vld1x3", "Intrinsic::aarch64_neon_vld1x4", "Intrinsic::aarch64_neon_vst1x2", "Intrinsic::aarch64_neon_vst1x3", "Intrinsic::aarch64_neon_vst1x4", "Intrinsic::arm_neon_vst2lane", "Intrinsic::arm_neon_vst3lane", "Intrinsic::arm_neon_vst4lane" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "getSize", "(", ")", ")", "return", "MCID", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "INLINEASM", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "0", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "return", "getInstBundleLength", "(", "MI", ")", ";", "case", "ARM", "::", "MOVi16_ga_pcrel", ":", "case", "ARM", "::", "MOVTi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVi16_ga_pcrel", ":", "case", "ARM", "::", "t2MOVTi16_ga_pcrel", ":", "return", "4", ";", "case", "ARM", "::", "MOVi32imm", ":", "case", "ARM", "::", "t2MOVi32imm", ":", "return", "8", ";", "case", "ARM", "::", "CONSTPOOL_ENTRY", ":", "case", "ARM", "::", "JUMPTABLE_INSTS", ":", "case", "ARM", "::", "JUMPTABLE_ADDRS", ":", "case", "ARM", "::", "JUMPTABLE_TBB", ":", "case", "ARM", "::", "JUMPTABLE_TBH", ":", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "case", "ARM", "::", "Int_eh_sjlj_longjmp", ":", "return", "16", ";", "case", "ARM", "::", "tInt_eh_sjlj_longjmp", ":", "return", "10", ";", "case", "ARM", "::", "tInt_WIN_eh_sjlj_longjmp", ":", "return", "12", ";", "case", "ARM", "::", "Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "Int_eh_sjlj_setjmp_nofp", ":", "return", "20", ";", "case", "ARM", "::", "tInt_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp", ":", "case", "ARM", "::", "t2Int_eh_sjlj_setjmp_nofp", ":", "return", "12", ";", "case", "ARM", "::", "SPACE", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::INLINEASM", "0", "0", "ARM::MOVi16_ga_pcrel", "ARM::MOVTi16_ga_pcrel", "ARM::t2MOVi16_ga_pcrel", "ARM::t2MOVTi16_ga_pcrel", "4", "ARM::MOVi32imm", "ARM::t2MOVi32imm", "8", "ARM::CONSTPOOL_ENTRY", "ARM::JUMPTABLE_INSTS", "ARM::JUMPTABLE_ADDRS", "ARM::JUMPTABLE_TBB", "ARM::JUMPTABLE_TBH", "2", "ARM::Int_eh_sjlj_longjmp", "16", "ARM::tInt_eh_sjlj_longjmp", "10", "ARM::tInt_WIN_eh_sjlj_longjmp", "12", "ARM::Int_eh_sjlj_setjmp", "ARM::Int_eh_sjlj_setjmp_nofp", "20", "ARM::tInt_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp", "ARM::t2Int_eh_sjlj_setjmp_nofp", "12", "ARM::SPACE", "1" ]

[]

[ "<s>", "int", "m32c_prepare_move", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "far_addr_space_p", "(", "operands", "[", "0", "]", ")", "&&", "CONSTANT_P", "(", "operands", "[", "1", "]", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ",", "operands", "[", "1", "]", ")", ";", "}", "if", "(", "TARGET_A16", "&&", "mode", "==", "PSImode", ")", "return", "m32c_split_move", "(", "operands", ",", "mode", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "&&", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "==", "PRE_MODIFY", ")", ")", "{", "rtx", "pmv", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "rtx", "dest_reg", "=", "XEXP", "(", "pmv", ",", "0", ")", ";", "rtx", "dest_mod", "=", "XEXP", "(", "pmv", ",", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest_reg", ",", "dest_mod", ")", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_MEM", "(", "mode", ",", "dest_reg", ")", ";", "}", "if", "(", "can_create_pseudo_p", "(", ")", "&&", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "copy_to_mode_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Used", "to", "emit", "move", "instructions", ".", "We", "split", "some", "moves", ",", "and", "avoid", "mem-mem", "moves", "." ]

[ "m32c", "0", "1", "1", "0", "1", "1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "isFPVectorizationPotentiallyUnsafe", "(", ")", "{", "return", "!", "ST", "->", "isTargetDarwin", "(", ")", "&&", "!", "ST", "->", "hasMVEFloatOps", "(", ")", ";", "}", "</s>" ]

[ "Indicate", "that", "it", "is", "potentially", "unsafe", "to", "automatically", "vectorize", "floating-point", "operations", "because", "the", "semantics", "of", "vector", "and", "scalar", "floating-point", "semantics", "may", "differ", "." ]

[ "ARM" ]

[]

[ "<s>", "RegisterAggr", "&", "RegisterAggr", "::", "insert", "(", "const", "RegisterAggr", "&", "RG", ")", "{", "for", "(", "std", "::", "pair", "<", "RegisterId", ",", "LaneBitmask", ">", "P", ":", "RG", ".", "Masks", ")", "insert", "(", "RegisterRef", "(", "P", ".", "first", ",", "P", ".", "second", ")", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

[ "<s>", "uint64_t", "BPFAbstractMemberAccess", "::", "getConstant", "(", "const", "Value", "*", "IndexValue", ")", "{", "const", "ConstantInt", "*", "CV", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "IndexValue", ")", ";", "assert", "(", "CV", ")", ";", "return", "CV", "->", "getValue", "(", ")", ".", "getZExtValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "large", "constant", "at", "the", "given", "index", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteral", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteralV216", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2FP16", ":", "{", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::OPERAND_REG_INLINE_AC_INT32", "AMDGPU::OPERAND_REG_INLINE_AC_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_AC_INT16", "AMDGPU::isInlinableIntLiteral", "AMDGPU::OPERAND_REG_IMM_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_AC_V2INT16", "AMDGPU::isInlinableIntLiteralV216", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "AMDGPU::OPERAND_REG_INLINE_AC_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_IMM_V2FP16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::OPERAND_REG_INLINE_AC_V2FP16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "SU", "->", "isScheduled", ")", "return", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Preds", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Preds", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "PredReadyCycle", "=", "I", "->", "getSUnit", "(", ")", "->", "TopReadyCycle", ";", "unsigned", "MinLatency", "=", "I", "->", "getMinLatency", "(", ")", ";", "Top", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Top", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "TopReadyCycle", "<", "PredReadyCycle", "+", "MinLatency", ")", "SU", "->", "TopReadyCycle", "=", "PredReadyCycle", "+", "MinLatency", ";", "}", "Top", ".", "releaseNode", "(", "SU", ",", "SU", "->", "TopReadyCycle", ")", ";", "}", "</s>" ]

[ "SU", "has", "had", "all", "predecessor", "dependencies", "resolved", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "ix86_simd_clone_adjust", "(", "struct", "cgraph_node", "*", "node", ")", "{", "const", "char", "*", "str", "=", "NULL", ";", "gcc_assert", "(", "node", "->", "decl", "==", "cfun", "->", "decl", ")", ";", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "str", "=", "\"sse2\"", ";", "break", ";", "case", "'c'", ":", "if", "(", "!", "TARGET_AVX", ")", "str", "=", "\"avx\"", ";", "break", ";", "case", "'d'", ":", "if", "(", "!", "TARGET_AVX2", ")", "str", "=", "\"avx2\"", ";", "break", ";", "case", "'e'", ":", "if", "(", "!", "TARGET_AVX512F", ")", "str", "=", "\"avx512f\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "str", "==", "NULL", ")", "return", ";", "push_cfun", "(", "NULL", ")", ";", "tree", "args", "=", "build_tree_list", "(", "NULL_TREE", ",", "build_string", "(", "strlen", "(", "str", ")", ",", "str", ")", ")", ";", "bool", "ok", "=", "ix86_valid_target_attribute_p", "(", "node", "->", "decl", ",", "NULL", ",", "args", ",", "0", ")", ";", "gcc_assert", "(", "ok", ")", ";", "pop_cfun", "(", ")", ";", "ix86_reset_previous_fndecl", "(", ")", ";", "ix86_set_current_function", "(", "node", "->", "decl", ")", ";", "}", "</s>" ]

[ "Add", "target", "attribute", "to", "SIMD", "clone", "NODE", "if", "needed", "." ]

[ "i386", "\"sse2\"", "\"avx\"", "\"avx2\"", "\"avx512f\"", "0" ]

[]

[ "<s>", "void", "HSAILMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "APFloat", "&", "FloatValue", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "if", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEsingle", ")", "MCOp", "=", "MCOperand", "::", "createFPImm", "(", "FloatValue", ".", "convertToFloat", "(", ")", ")", ";", "else", "if", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEdouble", ")", "MCOp", "=", "MCOperand", "::", "createFPImm", "(", "FloatValue", ".", "convertToDouble", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unhandled floating point type\"", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "SmallString", "<", "256", ">", "Name", ";", "AP", ".", "getHSAILMangledName", "(", "Name", ",", "GV", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "getOrCreateSymbol", "(", "Twine", "(", "'%'", ")", "+", "MO", ".", "getSymbolName", "(", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_MCSymbol", ":", "{", "MCSymbol", "*", "Sym", "=", "MO", ".", "getMCSymbol", "(", ")", ";", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_TargetIndex", ":", "{", "llvm_unreachable", "(", "\"Don't know how to lower target index\"", ")", ";", "break", ";", "}", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "\"unknown operand type\"", "\"Unhandled floating point type\"", "256", "HSAIL", "\"Don't know how to lower target index\"" ]

[]

[ "<s>", "static", "void", "ix86_init_large_pic_reg", "(", "unsigned", "int", "tmp_regno", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "tmp_reg", ";", "gcc_assert", "(", "Pmode", "==", "DImode", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_PRESERVE_P", "(", "label", ")", "=", "1", ";", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "tmp_regno", ")", ";", "gcc_assert", "(", "REGNO", "(", "pic_offset_table_rtx", ")", "!=", "tmp_regno", ")", ";", "emit_insn", "(", "gen_set_rip_rex64", "(", "pic_offset_table_rtx", ",", "label", ")", ")", ";", "emit_insn", "(", "gen_set_got_offset_rex64", "(", "tmp_reg", ",", "label", ")", ")", ";", "emit_insn", "(", "ix86_gen_add3", "(", "pic_offset_table_rtx", ",", "pic_offset_table_rtx", ",", "tmp_reg", ")", ")", ";", "}", "</s>" ]

[ "Initialize", "large", "model", "PIC", "register", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "PTXMCAsmStreamer", "::", "Finish", "(", ")", "{", "}", "</s>" ]

[ "Finish", "-", "Do", "final", "processing", "and", "write", "the", "object", "to", "the", "output", "stream", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "cond", ",", "rtx", "label", ")", "{", "rtx", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "cond", ",", "label", ",", "pc_rtx", ")", ";", "rtx_insn", "*", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "x", ")", ")", ";", "add_reg_br_prob_note", "(", "insn", ",", "profile_probability", "::", "very_unlikely", "(", ")", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "alpha" ]

[]