Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AArch64AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "sparc_init_pic_reg", "(", "void", ")", "{", "edge", "entry_edge", ";", "rtx_insn", "*", "seq", ";", "if", "(", "!", "flag_pic", "||", "(", "!", "crtl", "->", "uses_pic_offset_table", "&&", "!", "optimize", ")", ")", "return", ";", "start_sequence", "(", ")", ";", "load_got_register", "(", ")", ";", "if", "(", "!", "TARGET_VXWORKS_RTP", ")", "emit_move_insn", "(", "pic_offset_table_rtx", ",", "got_register_rtx", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "entry_edge", "=", "single_succ_edge", "(", "ENTRY_BLOCK_PTR_FOR_FN", "(", "cfun", ")", ")", ";", "insert_insn_on_edge", "(", "seq", ",", "entry_edge", ")", ";", "commit_one_edge_insertion", "(", "entry_edge", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_PIC_REG", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "int", "rs6000_darwin64_struct_check_p", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "return", "rs6000_darwin64_abi", "&&", "(", "(", "mode", "==", "BLKmode", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "0", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", "==", "8", ")", ")", "?", "1", ":", "0", ";", "}", "</s>" ]

[ "Check", "for", "an", "item", "that", "needs", "to", "be", "considered", "specially", "under", "the", "darwin", "64", "bit", "ABI", ".", "These", "are", "record", "types", "where", "the", "mode", "is", "BLK", "or", "the", "structure", "is", "8", "bytes", "in", "size", "." ]

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

[]

[ "<s>", "bool", "NVPTXReplaceImageHandles", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "InstrsToRemove", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "Changed", "|=", "processInstr", "(", "MI", ")", ";", "for", "(", "MachineInstr", "*", "MI", ":", "InstrsToRemove", ")", "{", "unsigned", "DefReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "use_nodbg_empty", "(", "DefReg", ")", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "ATTRIBUTE_UNUSED", "nios2_init_libfuncs", "(", "void", ")", "{", "init_sync_libfuncs", "(", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_LIBFUNCS", "." ]

[ "nios2" ]

[]

[ "<s>", "const", "uint32_t", "*", "SparcRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "return", "CSR_RegMask", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "v850_conditional_register_usage", "(", "void", ")", "{", "if", "(", "TARGET_APP_REGS", ")", "{", "fixed_regs", "[", "2", "]", "=", "0", ";", "call_used_regs", "[", "2", "]", "=", "0", ";", "fixed_regs", "[", "5", "]", "=", "0", ";", "call_used_regs", "[", "5", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CONDITIONAL_REGISTER_USAGE", ".", "If", "TARGET_APP_REGS", "is", "not", "defined", "then", "add", "r2", "and", "r5", "to", "the", "pool", "of", "fixed", "registers", ".", "See", "PR", "14505", "." ]

[ "v850", "2", "0", "2", "0", "5", "0", "5", "1" ]

[]

[ "<s>", "static", "void", "ix86_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ",", "const", "bool", "int_registers_saved", ")", "{", "const", "HOST_WIDE_INT", "probe_interval", "=", "get_probe_interval", "(", ")", ";", "if", "(", "size", "<=", "6", "*", "probe_interval", ")", "{", "HOST_WIDE_INT", "i", ";", "for", "(", "i", "=", "probe_interval", ";", "i", "<", "size", ";", "i", "+=", "probe_interval", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "i", ")", ")", ")", ";", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "first", "+", "size", ")", ")", ")", ";", "}", "else", "{", "gcc_assert", "(", "int_registers_saved", ")", ";", "HOST_WIDE_INT", "rounded_size", ",", "last", ";", "struct", "scratch_reg", "sr", ";", "get_scratch_register_on_entry", "(", "&", "sr", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "probe_interval", ")", ";", "emit_move_insn", "(", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "first", ")", ")", ";", "last", "=", "first", "+", "rounded_size", ";", "emit_insn", "(", "gen_probe_stack_range", "(", "Pmode", ",", "sr", ".", "reg", ",", "sr", ".", "reg", ",", "GEN_INT", "(", "-", "last", ")", ")", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "emit_stack_probe", "(", "plus_constant", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sr", ".", "reg", ")", ",", "rounded_size", "-", "size", ")", ")", ";", "release_scratch_register_on_entry", "(", "&", "sr", ",", "size", ",", "true", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "i386", "6" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDValue", "Val", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADDE", ":", "return", "performADDECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "Val", "=", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "OR", ":", "Val", "=", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SUBE", ":", "return", "performSUBECombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "performMULCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "this", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "performSHLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRA", ":", "return", "performSRACombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SRL", ":", "return", "performSRLCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "performVSELECTCombine", "(", "N", ",", "DAG", ")", ";", "case", "ISD", "::", "XOR", ":", "Val", "=", "performXORCombine", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SETCC", ":", "Val", "=", "performSETCCCombine", "(", "N", ",", "DAG", ")", ";", "break", ";", "}", "if", "(", "Val", ".", "getNode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nMipsSE DAG Combine:\\n\"", ";", "N", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n=> \\n\"", ";", "Val", ".", "getNode", "(", ")", "->", "printrWithDepth", "(", "dbgs", "(", ")", ",", "&", "DAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Val", ";", "}", "return", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "N", ",", "DCI", ")", ";", "}", "</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", "." ]

[ "Mips", "Mips", "ISD::ADDE", "ISD::AND", "ISD::OR", "ISD::SUBE", "ISD::MUL", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::VSELECT", "ISD::XOR", "ISD::SETCC", "\"\\nMipsSE DAG Combine:\\n\"", "\"\\n=> \\n\"", "\"\\n\"", "Mips" ]

[]

[ "<s>", "StringRef", "RISCVMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "case", "VK_RISCV_Invalid", ":", "case", "VK_RISCV_None", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_RISCV_LO", ":", "return", "\"lo\"", ";", "case", "VK_RISCV_HI", ":", "return", "\"hi\"", ";", "case", "VK_RISCV_PCREL_LO", ":", "return", "\"pcrel_lo\"", ";", "case", "VK_RISCV_PCREL_HI", ":", "return", "\"pcrel_hi\"", ";", "case", "VK_RISCV_GOT_HI", ":", "return", "\"got_pcrel_hi\"", ";", "case", "VK_RISCV_TPREL_LO", ":", "return", "\"tprel_lo\"", ";", "case", "VK_RISCV_TPREL_HI", ":", "return", "\"tprel_hi\"", ";", "case", "VK_RISCV_TPREL_ADD", ":", "return", "\"tprel_add\"", ";", "case", "VK_RISCV_TLS_GOT_HI", ":", "return", "\"tls_ie_pcrel_hi\"", ";", "case", "VK_RISCV_TLS_GD_HI", ":", "return", "\"tls_gd_pcrel_hi\"", ";", "case", "VK_RISCV_CALL", ":", "return", "\"call\"", ";", "case", "VK_RISCV_CALL_PLT", ":", "return", "\"call_plt\"", ";", "case", "VK_RISCV_32_PCREL", ":", "return", "\"32_pcrel\"", ";", "}", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"Invalid ELF symbol kind\"", "RISCV", "\"lo\"", "RISCV", "\"hi\"", "RISCV", "\"pcrel_lo\"", "RISCV", "\"pcrel_hi\"", "RISCV", "\"got_pcrel_hi\"", "RISCV", "\"tprel_lo\"", "RISCV", "\"tprel_hi\"", "RISCV", "\"tprel_add\"", "RISCV", "\"tls_ie_pcrel_hi\"", "RISCV", "\"tls_gd_pcrel_hi\"", "RISCV", "\"call\"", "RISCV", "\"call_plt\"", "RISCV", "\"32_pcrel\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::LDri", "0", "SP::FPRegsRegisterClass", "SP::LDFri", "0", "SP::DFPRegsRegisterClass", "SP::LDDFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "enum", "ivms_arg_type", "ia64_arg_type", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "return", "FS", ";", "case", "DFmode", ":", "return", "FT", ";", "default", ":", "return", "I64", ";", "}", "}", "</s>" ]

[ "Return", "ivms_arg_type", "based", "on", "machine_mode", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "AArch64RegisterBankInfo", "::", "applyMappingImpl", "(", "const", "OperandsMapper", "&", "OpdMapper", ")", "const", "{", "switch", "(", "OpdMapper", ".", "getMI", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_OR", ":", "case", "TargetOpcode", "::", "G_BITCAST", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "assert", "(", "(", "OpdMapper", ".", "getInstrMapping", "(", ")", ".", "getID", "(", ")", ">=", "1", "&&", "OpdMapper", ".", "getInstrMapping", "(", ")", ".", "getID", "(", ")", "<=", "4", ")", "&&", "\"Don't know how to handle that ID\"", ")", ";", "return", "applyDefaultMapping", "(", "OpdMapper", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Don't know how to handle that operation\"", ")", ";", "}", "}", "</s>" ]

[ "See", "RegisterBankInfo", ":", ":applyMapping", "." ]

[ "AArch64", "AArch64", "1", "4", "\"Don't know how to handle that ID\"", "\"Don't know how to handle that operation\"" ]

[]

[ "<s>", "static", "void", "rs6000_emit_msub", "(", "rtx", "target", ",", "rtx", "m1", ",", "rtx", "m2", ",", "rtx", "a", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "rtx", "dst", ";", "if", "(", "optab_handler", "(", "fms_optab", ",", "mode", ")", "!=", "CODE_FOR_nothing", ")", "dst", "=", "expand_ternary_op", "(", "mode", ",", "fms_optab", ",", "m1", ",", "m2", ",", "a", ",", "target", ",", "0", ")", ";", "else", "{", "a", "=", "expand_unop", "(", "mode", ",", "neg_optab", ",", "a", ",", "NULL_RTX", ",", "0", ")", ";", "dst", "=", "expand_ternary_op", "(", "mode", ",", "fma_optab", ",", "m1", ",", "m2", ",", "a", ",", "target", ",", "0", ")", ";", "}", "gcc_assert", "(", "dst", "!=", "NULL", ")", ";", "if", "(", "dst", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "dst", ")", ";", "}", "</s>" ]

[ "Generate", "a", "FMSUB", "instruction", ":", "dst", "=", "fma", "(", "m1", ",", "m2", ",", "-a", ")", "." ]

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

[]

[ "<s>", "BitVector", "BPFRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "BPF", "::", "W10", ")", ";", "markSuperRegs", "(", "Reserved", ",", "BPF", "::", "W11", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::W10", "BPF::W11" ]

[]

[ "<s>", "MachineInstr", "*", "AlphaInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "Alpha", "::", "BISr", ":", "case", "Alpha", "::", "CPYSS", ":", "case", "Alpha", "::", "CPYST", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "if", "(", "Ops", "[", "0", "]", "==", "0", ")", "{", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "Opc", "=", "(", "Opc", "==", "Alpha", "::", "BISr", ")", "?", "Alpha", "::", "STQ", ":", "(", "(", "Opc", "==", "Alpha", "::", "CPYSS", ")", "?", "Alpha", "::", "STS", ":", "Alpha", "::", "STT", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "InReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "}", "else", "{", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "Opc", "=", "(", "Opc", "==", "Alpha", "::", "BISr", ")", "?", "Alpha", "::", "LDQ", ":", "(", "(", "Opc", "==", "Alpha", "::", "CPYSS", ")", "?", "Alpha", "::", "LDS", ":", "Alpha", "::", "LDT", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "OutReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "}", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Alpha", "Alpha", "1", "Alpha::BISr", "Alpha::CPYSS", "Alpha::CPYST", "1", "2", "0", "0", "1", "1", "Alpha::BISr", "Alpha::STQ", "Alpha::CPYSS", "Alpha::STS", "Alpha::STT", "Alpha::F31", "0", "0", "Alpha::BISr", "Alpha::LDQ", "Alpha::CPYSS", "Alpha::LDS", "Alpha::LDT", "Alpha::F31" ]

[]

[ "<s>", "static", "bool", "ia64_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "size", "==", "POINTER_SIZE", "/", "BITS_PER_UNIT", "&&", "!", "(", "TARGET_NO_PIC", "||", "TARGET_AUTO_PIC", ")", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "x", ")", ")", "{", "static", "const", "char", "*", "const", "directive", "[", "2", "]", "[", "2", "]", "=", "{", "{", "\"\\tdata8.ua\\t@fptr(\"", ",", "\"\\tdata4.ua\\t@fptr(\"", "}", ",", "{", "\"\\tdata8\\t@fptr(\"", ",", "\"\\tdata4\\t@fptr(\"", "}", "}", ";", "fputs", "(", "directive", "[", "(", "aligned_p", "!=", "0", ")", "]", "[", "POINTER_SIZE", "==", "32", "]", ",", "asm_out_file", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fputs", "(", "\")\\n\"", ",", "asm_out_file", ")", ";", "return", "true", ";", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "Handle", "word-sized", "aligned", "objects", "and", "detect", "the", "cases", "when", "@", "fptr", "is", "needed", "." ]

[ "ia64", "2", "2", "\"\\tdata8.ua\\t@fptr(\"", "\"\\tdata4.ua\\t@fptr(\"", "\"\\tdata8\\t@fptr(\"", "\"\\tdata4\\t@fptr(\"", "0", "32", "\")\\n\"" ]

[]

[ "<s>", "void", "m32r_init", "(", "void", ")", "{", "init_reg_tables", "(", ")", ";", "memset", "(", "m32r_punct_chars", ",", "0", ",", "sizeof", "(", "m32r_punct_chars", ")", ")", ";", "m32r_punct_chars", "[", "'#'", "]", "=", "1", ";", "m32r_punct_chars", "[", "'@'", "]", "=", "1", ";", "if", "(", "!", "g_switch_set", ")", "g_switch_value", "=", "SDATA_DEFAULT_SIZE", ";", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "m32r", "0", "1", "1" ]

[]

[ "<s>", "static", "void", "lm32_block_move_inline", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "alignment", ")", "{", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "switch", "(", "alignment", ")", "{", "case", "1", ":", "bits", "=", "8", ";", "break", ";", "case", "2", ":", "bits", "=", "16", ";", "break", ";", "default", ":", "bits", "=", "32", ";", "break", ";", "}", "mode", "=", "int_mode_for_size", "(", "bits", ",", "0", ")", ".", "require", "(", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "}", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "emit_move_insn", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "RETURN_BEGIN", ")", ";", "}", "}", "</s>" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

[ "lm32", "1", "8", "2", "16", "32", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "ARMSubtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "return", "RegBankInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "information", "for", "the", "register", "banks", "is", "available", ",", "return", "it", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "MCS51InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "MCS51", "::", "LDDRdPtrQ", ":", "case", "MCS51", "::", "LDDWRdYQ", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51::LDDRdPtrQ", "MCS51::LDDWRdYQ", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "FPGATTIImpl", "::", "isTypeLegal", "(", "Type", "*", "Ty", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "FPGA", "FPGA" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "!", "BitVector", "::", "any", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "AMDGPUISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "AMDGPUISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "RETURN", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "SETCC", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RCP_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "FMUL_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "FFBH_I32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "NODE_NAME_CASE", "(", "KILL", ")", "case", "AMDGPUISD", "::", "FIRST_MEM_OPCODE_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "case", "AMDGPUISD", "::", "LAST_AMDGPU_ISD_NUMBER", ":", "break", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "PPCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF8", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "TM", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MTCRF8", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "const", "char", "*", "ashrhi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "scratch", "=", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", ";", "int", "ldi_ok", "=", "test_hard_reg_class", "(", "LD_REGS", ",", "operands", "[", "0", "]", ")", ";", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "case", "4", ":", "case", "5", ":", "break", ";", "case", "6", ":", "if", "(", "optimize_size", ")", "break", ";", "*", "len", "=", "8", ";", "return", "(", "\"mov __tmp_reg__,%A0\"", "CR_TAB", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl __tmp_reg__\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"lsl __tmp_reg__\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"rol %B0\"", ")", ";", "case", "7", ":", "*", "len", "=", "4", ";", "return", "(", "\"lsl %A0\"", "CR_TAB", "\"mov %A0,%B0\"", "CR_TAB", "\"rol %A0\"", "CR_TAB", "\"sbc %B0,%B0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "==", "reg1", ")", "return", "*", "len", "=", "3", ",", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %A0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"sbrc %A0,7\"", "CR_TAB", "\"dec %B0\"", ")", ";", "}", "case", "9", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "10", ":", "*", "len", "=", "5", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "11", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x20\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", "&&", "scratch", ")", "break", ";", "*", "len", "=", "6", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "12", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x10\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", "&&", "scratch", ")", "break", ";", "*", "len", "=", "7", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "13", ":", "if", "(", "AVR_HAVE_MUL", "&&", "ldi_ok", ")", "{", "*", "len", "=", "5", ";", "return", "(", "\"ldi %A0,0x08\"", "CR_TAB", "\"muls %B0,%A0\"", "CR_TAB", "\"mov %A0,r1\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"clr __zero_reg__\"", ")", ";", "}", "if", "(", "optimize_size", ")", "break", ";", "*", "len", "=", "8", ";", "return", "(", "\"mov %A0,%B0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"sbc %B0,%B0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", "CR_TAB", "\"asr %A0\"", ")", ";", "case", "14", ":", "*", "len", "=", "5", ";", "return", "(", "\"lsl %B0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"lsl %B0\"", "CR_TAB", "\"mov %B0,%A0\"", "CR_TAB", "\"rol %A0\"", ")", ";", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "16", ")", "break", ";", "case", "15", ":", "return", "*", "len", "=", "3", ",", "(", "\"lsl %B0\"", "CR_TAB", "\"sbc %A0,%A0\"", "CR_TAB", "\"mov %B0,%A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"asr %B0\"", "CR_TAB", "\"ror %A0\"", ",", "insn", ",", "operands", ",", "len", ",", "2", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "16bit", "arithmetic", "shift", "right", "(", "(", "signed", "short", ")", "x", ">", ">", "i", ")" ]

[ "avr", "2", "0", "2", "4", "5", "6", "8", "\"mov __tmp_reg__,%A0\"", "\"mov %A0,%B0\"", "\"lsl __tmp_reg__\"", "\"rol %A0\"", "\"sbc %B0,%B0\"", "\"lsl __tmp_reg__\"", "\"rol %A0\"", "\"rol %B0\"", "7", "4", "\"lsl %A0\"", "\"mov %A0,%B0\"", "\"rol %A0\"", "\"sbc %B0,%B0\"", "8", "0", "1", "3", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "4", "\"mov %A0,%B1\"", "\"clr %B0\"", "\"sbrc %A0,7\"", "\"dec %B0\"", "9", "4", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "10", "5", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "11", "5", "\"ldi %A0,0x20\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "6", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "12", "5", "\"ldi %A0,0x10\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "7", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "13", "5", "\"ldi %A0,0x08\"", "\"muls %B0,%A0\"", "\"mov %A0,r1\"", "\"sbc %B0,%B0\"", "\"clr __zero_reg__\"", "8", "\"mov %A0,%B0\"", "\"lsl %B0\"", "\"sbc %B0,%B0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "\"asr %A0\"", "14", "5", "\"lsl %B0\"", "\"sbc %A0,%A0\"", "\"lsl %B0\"", "\"mov %B0,%A0\"", "\"rol %A0\"", "2", "16", "15", "3", "\"lsl %B0\"", "\"sbc %A0,%A0\"", "\"mov %B0,%A0\"", "\"asr %B0\"", "\"ror %A0\"", "2", "\"\"" ]

[]

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

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

[ "Dcpu16", "DCPU16", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "DCPU16::J", "DCPU16::SP", "1", "1", "DCPU16::ADD16ri", "DCPU16::MOV16rr", "0", "0", "0", "DCPU16::SUB16ri", "DCPU16::ADD16ri", "1" ]

[]

[ "<s>", "enum", "tail_policy", "get_prefer_tail_policy", "(", ")", "{", "return", "TAIL_ANY", ";", "}", "</s>" ]

[ "Get", "prefer", "tail", "policy", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "Ret", "=", "PPCAsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "for", "(", "MCSymbol", "*", "Sym", ":", "ExtSymSDNodeSymbols", ")", "OutStreamer", "->", "emitSymbolAttribute", "(", "Sym", ",", "MCSA_Extern", ")", ";", "return", "Ret", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

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

[]

[ "<s>", "void", "AArch64AsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "int64_t", "SignedValue", "=", "static_cast", "<", "int64_t", ">", "(", "Value", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "Ctx", ",", "TheTriple", ",", "IsResolved", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FulleSizeInBytes", "=", "getFixupKindContainereSizeInBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "FulleSizeInBytes", "==", "0", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "else", "{", "assert", "(", "(", "Offset", "+", "FulleSizeInBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FulleSizeInBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "FulleSizeInBytes", "-", "1", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "AArch64MCExpr", "::", "VariantKind", "RefKind", "=", "static_cast", "<", "AArch64MCExpr", "::", "VariantKind", ">", "(", "Target", ".", "getRefKind", "(", ")", ")", ";", "if", "(", "RefKind", "&", "AArch64MCExpr", "::", "VK_SABS", ")", "{", "if", "(", "SignedValue", "<", "0", ")", "Data", "[", "Offset", "+", "3", "]", "&=", "~", "(", "1", "<<", "6", ")", ";", "else", "Data", "[", "Offset", "+", "3", "]", "|=", "(", "1", "<<", "6", ")", ";", "}", "}", "</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", "." ]

[ "AArch64", "AArch64", "\"Invalid fixup offset!\"", "0", "0", "8", "0xff", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "1", "8", "0xff", "AArch64", "AArch64", "AArch64", "0", "3", "1", "6", "3", "1", "6" ]

[]

[ "<s>", "unsigned", "PHILinearize", "::", "getNumSources", "(", "unsigned", "DestReg", ")", "{", "return", "phiInfoElementGetSources", "(", "findPHIInfoElement", "(", "DestReg", ")", ")", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "source", "registers", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "unsigned", "int", "s390_get_vstring_flags", "(", "int", "ob_fcode", ")", "{", "unsigned", "int", "flags", "=", "0", ";", "switch", "(", "ob_fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_cc", ":", "flags", "|=", "__VSTRING_FLAG_IN", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "ob_fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_cc", ":", "flags", "|=", "__VSTRING_FLAG_RT", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "ob_fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx_cc", ":", "flags", "|=", "__VSTRING_FLAG_ZS", ";", "break", ";", "default", ":", "break", ";", "}", "switch", "(", "ob_fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_eq_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_find_any_ne_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_or_0_idx_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmprg_cc", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_cmpnrg_cc", ":", "flags", "|=", "__VSTRING_FLAG_CS", ";", "break", ";", "default", ":", "break", ";", "}", "return", "flags", ";", "}", "</s>" ]

[ "Return", "the", "flags", "value", "to", "be", "used", "for", "string", "low-level", "builtins", "when", "expanded", "from", "overloaded", "builtin", "OB_FCODE", "." ]

[ "s390", "0" ]

[]

[ "<s>", "void", "SNESInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "Op", ".", "getImm", "(", ")", ";", "O", "<<", "'.'", ";", "if", "(", "Imm", ">=", "0", ")", "O", "<<", "'+'", ";", "O", "<<", "Imm", ";", "}", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"Unknown pcrel immediate operand\"", ")", ";", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "SNES", "SNES", "0", "\"Unknown pcrel immediate operand\"" ]

[]

[ "<s>", "void", "aarch64_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "old_out", ",", "rtx", "new_out", ",", "rtx", "mem", ",", "rtx", "value", ",", "rtx", "model_rtx", ",", "rtx", "cond", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "machine_mode", "wmode", "=", "(", "mode", "==", "DImode", "?", "DImode", ":", "SImode", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "x", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "if", "(", "new_out", ")", "new_out", "=", "gen_lowpart", "(", "wmode", ",", "new_out", ")", ";", "if", "(", "old_out", ")", "old_out", "=", "gen_lowpart", "(", "wmode", ",", "old_out", ")", ";", "else", "old_out", "=", "new_out", ";", "value", "=", "simplify_gen_subreg", "(", "wmode", ",", "value", ",", "mode", ",", "0", ")", ";", "aarch64_emit_load_exclusive", "(", "mode", ",", "old_out", ",", "mem", ",", "model_rtx", ")", ";", "switch", "(", "code", ")", "{", "case", "SET", ":", "new_out", "=", "value", ";", "break", ";", "case", "NOT", ":", "x", "=", "gen_rtx_AND", "(", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_NOT", "(", "wmode", ",", "new_out", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "break", ";", "case", "MINUS", ":", "if", "(", "CONST_INT_P", "(", "value", ")", ")", "{", "value", "=", "GEN_INT", "(", "-", "INTVAL", "(", "value", ")", ")", ";", "code", "=", "PLUS", ";", "}", "default", ":", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "wmode", ",", "old_out", ",", "value", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_out", ",", "x", ")", ")", ";", "break", ";", "}", "aarch64_emit_store_exclusive", "(", "mode", ",", "cond", ",", "mem", ",", "gen_lowpart", "(", "mode", ",", "new_out", ")", ",", "model_rtx", ")", ";", "x", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "cond", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "aarch64_emit_unlikely_jump", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Split", "an", "atomic", "operation", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "int", "reg_unused_after", "(", "rtx", "insn", ",", "rtx", "reg", ")", "{", "return", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", "||", "(", "REG_P", "(", "reg", ")", "&&", "_reg_unused_after", "(", "insn", ",", "reg", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]

[ "avr" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "joinRegisterPartsIntoValue", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "const", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "EVT", "ValueVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "bool", "IsABIRegCopy", "=", "CC", ".", "hasValue", "(", ")", ";", "if", "(", "IsABIRegCopy", "&&", "(", "ValueVT", "==", "MVT", "::", "f16", "||", "ValueVT", "==", "MVT", "::", "bf16", ")", "&&", "PartVT", "==", "MVT", "::", "f32", ")", "{", "unsigned", "ValueBits", "=", "ValueVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "PartBits", "=", "PartVT", ".", "getSizeInBits", "(", ")", ";", "SDValue", "Val", "=", "Parts", "[", "0", "]", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "MVT", "::", "getIntegerVT", "(", "PartBits", ")", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "getIntegerVT", "(", "ValueBits", ")", ",", "Val", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "ValueVT", ",", "Val", ")", ";", "return", "Val", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Target-specific", "combining", "of", "register", "parts", "into", "its", "original", "value", "." ]

[ "ARM", "ARM", "MVT::f16", "MVT::bf16", "MVT::f32", "0", "ISD::BITCAST", "MVT::getIntegerVT", "ISD::TRUNCATE", "MVT::getIntegerVT", "ISD::BITCAST" ]

[]

[ "<s>", "bool", "TPCTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDValue", "Ptr", ";", "unsigned", "AS", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "AS", "=", "LD", "->", "getAddressSpace", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "AS", "=", "ST", "->", "getAddressSpace", "(", ")", ";", "}", "else", "return", "false", ";", "if", "(", "AS", "!=", "3", ")", "return", "false", ";", "if", "(", "!", "getIndexedAddressParts", "(", "Op", ",", "Base", ",", "Offset", ",", "DAG", ")", ")", "return", "false", ";", "if", "(", "Ptr", "!=", "Base", ")", "return", "false", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "TPC", "TPC", "ISD::MemIndexedMode", "3", "ISD::POST_INC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumT", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumF", ")", "const", "{", "return", "NumT", "&&", "NumF", "&&", "NumT", "<=", "2", "&&", "NumF", "<=", "2", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

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

[]

[ "<s>", "const", "MipsTargetLowering", "*", "MipsTargetLowering", "::", "create", "(", "const", "MipsTargetMachine", "&", "TM", ",", "const", "MipsSubtarget", "&", "STI", ")", "{", "if", "(", "STI", ".", "inMips16Mode", "(", ")", ")", "return", "createMips16TargetLowering", "(", "TM", ",", "STI", ")", ";", "return", "createMipsSETargetLowering", "(", "TM", ",", "STI", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

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

[]

[ "<s>", "static", "rtx", "mips16_local_alias", "(", "rtx", "func", ")", "{", "if", "(", "mips16_local_aliases", "==", "NULL", ")", "mips16_local_aliases", "=", "hash_map", "<", "nofree_string_hash", ",", "rtx", ">", "::", "create_ggc", "(", "37", ")", ";", "bool", "existed", ";", "const", "char", "*", "func_name", "=", "XSTR", "(", "func", ",", "0", ")", ";", "rtx", "*", "slot", "=", "&", "mips16_local_aliases", "->", "get_or_insert", "(", "func_name", ",", "&", "existed", ")", ";", "gcc_assert", "(", "slot", "!=", "NULL", ")", ";", "if", "(", "!", "existed", ")", "{", "rtx", "local", ";", "func_name", "=", "targetm", ".", "strip_name_encoding", "(", "XSTR", "(", "func", ",", "0", ")", ")", ";", "const", "char", "*", "local_name", "=", "ACONCAT", "(", "(", "\"__fn_local_\"", ",", "func_name", ",", "NULL", ")", ")", ";", "local", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "local_name", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "local", ")", "=", "SYMBOL_REF_FLAGS", "(", "func", ")", "|", "SYMBOL_FLAG_LOCAL", ";", "*", "slot", "=", "local", ";", "}", "return", "*", "slot", ";", "}", "</s>" ]

[ "FUNC", "is", "the", "symbol", "for", "a", "locally-defined", "hard-float", "MIPS16", "function", ".", "Return", "a", "local", "alias", "for", "it", ",", "creating", "a", "new", "one", "if", "necessary", "." ]

[ "mips", "37", "0", "0", "\"__fn_local_\"" ]

[]

[ "<s>", "void", "RISCVELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "rtx", "bfin_gen_compare", "(", "rtx", "cmp", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "enum", "rtx_code", "code1", ",", "code2", ";", "rtx", "op0", "=", "XEXP", "(", "cmp", ",", "0", ")", ",", "op1", "=", "XEXP", "(", "cmp", ",", "1", ")", ";", "rtx", "tem", "=", "bfin_cc_rtx", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "cmp", ")", ";", "if", "(", "GET_MODE", "(", "op0", ")", "==", "BImode", ")", "{", "gcc_assert", "(", "(", "code", "==", "NE", "||", "code", "==", "EQ", ")", "&&", "op1", "==", "const0_rtx", ")", ";", "tem", "=", "op0", ",", "code2", "=", "code", ";", "}", "else", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "LT", ":", "case", "LE", ":", "case", "LEU", ":", "case", "LTU", ":", "code1", "=", "code", ";", "code2", "=", "NE", ";", "break", ";", "default", ":", "code1", "=", "reverse_condition", "(", "code", ")", ";", "code2", "=", "EQ", ";", "break", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tem", ",", "gen_rtx_fmt_ee", "(", "code1", ",", "BImode", ",", "op0", ",", "op1", ")", ")", ")", ";", "}", "return", "gen_rtx_fmt_ee", "(", "code2", ",", "BImode", ",", "tem", ",", "CONST0_RTX", "(", "BImode", ")", ")", ";", "}", "</s>" ]

[ "Emit", "rtl", "for", "a", "comparison", "operation", "CMP", "in", "mode", "MODE", ".", "Operands", "have", "been", "stored", "in", "bfin_compare_op0", "and", "bfin_compare_op1", "already", "." ]

[ "bfin", "0", "1" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "is64Bit", "(", ")", ")", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes_64", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "else", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Shrink-wrapping not yet supported\"", "NVPTX", "NVPTX::Int64RegsRegClass", "NVPTX::cvta_local_yes_64", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::Int32RegsRegClass", "NVPTX::cvta_local_yes", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "SparcMCExpr", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Mips", "Mips", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "Mips", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "static", "void", "nios2_alternate_compare_const", "(", "enum", "rtx_code", "code", ",", "rtx", "op", ",", "enum", "rtx_code", "*", "alt_code", ",", "rtx", "*", "alt_op", ",", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "op", ")", ")", ";", "HOST_WIDE_INT", "opval", "=", "INTVAL", "(", "op", ")", ";", "enum", "rtx_code", "scode", "=", "signed_condition", "(", "code", ")", ";", "bool", "dec_p", "=", "(", "scode", "==", "LT", "||", "scode", "==", "GE", ")", ";", "if", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "{", "*", "alt_code", "=", "code", ";", "*", "alt_op", "=", "op", ";", "return", ";", "}", "*", "alt_op", "=", "(", "dec_p", "?", "gen_int_mode", "(", "opval", "-", "1", ",", "mode", ")", ":", "gen_int_mode", "(", "opval", "+", "1", ",", "mode", ")", ")", ";", "*", "alt_code", "=", "reverse_condition", "(", "swap_condition", "(", "code", ")", ")", ";", "{", "unsigned", "HOST_WIDE_INT", "alt_opval", "=", "INTVAL", "(", "*", "alt_op", ")", ";", "if", "(", "code", "==", "scode", ")", "alt_opval", "^=", "(", "1", "<<", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "1", ")", ")", ";", "alt_opval", "&=", "GET_MODE_MASK", "(", "mode", ")", ";", "gcc_assert", "(", "dec_p", "?", "alt_opval", "!=", "GET_MODE_MASK", "(", "mode", ")", ":", "alt_opval", "!=", "0", ")", ";", "}", "}", "</s>" ]

[ "Return", "in", "*", "ALT_CODE", "and", "*", "ALT_OP", ",", "an", "alternate", "equivalent", "constant", "comparison", ",", "e.g", ".", ">", "=", "1", "into", ">", "0", "." ]

[ "nios2", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "c6x_mark_reg_read", "(", "rtx", "reg", ",", "bool", "cross", ")", "{", "unsigned", "regno", "=", "REGNO", "(", "reg", ")", ";", "unsigned", "nregs", "=", "REG_NREGS", "(", "reg", ")", ";", "while", "(", "nregs", "--", ">", "0", ")", "c6x_mark_regno_read", "(", "regno", "+", "nregs", ",", "cross", ")", ";", "}", "</s>" ]

[ "Note", "that", "REG", "is", "read", "in", "the", "insn", "being", "examined", ".", "If", "CROSS", ",", "it", "means", "the", "access", "is", "through", "a", "cross", "path", ".", "Update", "the", "temporary", "reg", "access", "arrays", ",", "and", "set", "REG_ACCESS_STALL", "if", "the", "insn", "ca", "n't", "be", "issued", "in", "the", "current", "cycle", "." ]

[ "c6x", "0" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64ISD", "::", "CSEL", ":", "{", "APInt", "KnownZero2", ",", "KnownOne2", ";", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "1", ")", ",", "KnownZero2", ",", "KnownOne2", ",", "Depth", "+", "1", ")", ";", "KnownZero", "&=", "KnownZero2", ";", "KnownOne", "&=", "KnownOne2", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "aarch64_ldaxr", ":", "case", "Intrinsic", "::", "aarch64_ldxr", ":", "{", "unsigned", "BitWidth", "=", "KnownOne", ".", "getBitWidth", "(", ")", ";", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_umaxv", ":", "case", "Intrinsic", "::", "aarch64_neon_uminv", ":", "{", "MVT", "VT", "=", "Op", ".", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "unsigned", "BitWidth", "=", "KnownZero", ".", "getBitWidth", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i8", "||", "VT", "==", "MVT", "::", "v16i8", ")", "{", "assert", "(", "BitWidth", ">=", "8", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "8", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i16", ")", "{", "assert", "(", "BitWidth", ">=", "16", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "KnownZero", "|=", "Mask", ";", "}", "break", ";", "}", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AArch64", "AArch64", "AArch64ISD::CSEL", "0", "1", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "0", "Intrinsic::aarch64_neon_umaxv", "Intrinsic::aarch64_neon_uminv", "1", "MVT::v8i8", "MVT::v16i8", "8", "\"Unexpected width!\"", "8", "MVT::v4i16", "MVT::v8i16", "16", "\"Unexpected width!\"", "16" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "MachineLoopInfo", "::", "iterator", "I", "=", "MLI", "->", "begin", "(", ")", ",", "E", "=", "MLI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineLoop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "Changed", "|=", "convertToHardwareLoop", "(", "L", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "bool", "ContiguousRegs", "=", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "SuperReg", "=", "uniqueSuperReg", "(", "Reg", ",", "TRI", ")", ";", "bool", "CanUseDblStore", "=", "false", ";", "const", "TargetRegisterClass", "*", "SuperRegClass", "=", "0", ";", "if", "(", "ContiguousRegs", "&&", "(", "i", "<", "CSI", ".", "size", "(", ")", "-", "1", ")", ")", "{", "unsigned", "SuperRegNext", "=", "uniqueSuperReg", "(", "CSI", "[", "i", "+", "1", "]", ".", "getReg", "(", ")", ",", "TRI", ")", ";", "SuperRegClass", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "SuperReg", ")", ";", "CanUseDblStore", "=", "(", "SuperRegNext", "==", "SuperReg", ")", ";", "}", "if", "(", "CanUseDblStore", ")", "{", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "SuperReg", ",", "true", ",", "CSI", "[", "i", "+", "1", "]", ".", "getFrameIdx", "(", ")", ",", "SuperRegClass", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "SuperReg", ")", ";", "++", "i", ";", "}", "else", "{", "ContiguousRegs", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Lanai" ]

[]

[ "<s>", "void", "rs6000_disqualify_components", "(", "sbitmap", "components", ",", "edge", "e", ",", "sbitmap", "edge_components", ",", "bool", ")", "{", "if", "(", "bitmap_bit_p", "(", "edge_components", ",", "0", ")", "&&", "bitmap_bit_p", "(", "DF_LIVE_IN", "(", "e", "->", "dest", ")", ",", "0", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Disqualifying LR because GPR0 is live \"", "\"on entry to bb %d\\n\"", ",", "e", "->", "dest", "->", "index", ")", ";", "bitmap_clear_bit", "(", "components", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS", "." ]

[ "rs6000", "0", "0", "\"Disqualifying LR because GPR0 is live \"", "\"on entry to bb %d\\n\"", "0" ]

[]

[ "<s>", "unsigned", "MipsFastISel", "::", "fastEmitInst_rr", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "unsigned", "Op1", ")", "{", "if", "(", "MachineInstOpcode", "==", "Mips", "::", "MUL", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "II", ".", "getNumDefs", "(", ")", ")", ";", "Op1", "=", "constrainOperandRegClass", "(", "II", ",", "Op1", ",", "II", ".", "getNumDefs", "(", ")", "+", "1", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addReg", "(", "Op1", ")", ".", "addReg", "(", "Mips", "::", "HI0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ".", "addReg", "(", "Mips", "::", "LO0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "return", "ResultReg", ";", "}", "return", "FastISel", "::", "fastEmitInst_rr", "(", "MachineInstOpcode", ",", "RC", ",", "Op0", ",", "Op1", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::MUL", "1", "Mips::HI0", "Mips::LO0" ]

[]

[ "<s>", "void", "ELFMBlazeAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "unsigned", "Size", "=", "getFixupKindSize", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "char", "*", "data", "=", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ";", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Cannot fixup unknown value.\"", ")", ";", "case", "1", ":", "llvm_unreachable", "(", "\"Cannot fixup 1 byte value.\"", ")", ";", "case", "8", ":", "llvm_unreachable", "(", "\"Cannot fixup 8 byte value.\"", ")", ";", "case", "4", ":", "*", "(", "data", "+", "7", ")", "=", "uint8_t", "(", "Value", ")", ";", "*", "(", "data", "+", "6", ")", "=", "uint8_t", "(", "Value", ">>", "8", ")", ";", "*", "(", "data", "+", "3", ")", "=", "uint8_t", "(", "Value", ">>", "16", ")", ";", "*", "(", "data", "+", "2", ")", "=", "uint8_t", "(", "Value", ">>", "24", ")", ";", "break", ";", "case", "2", ":", "*", "(", "data", "+", "3", ")", "=", "uint8_t", "(", "Value", ">>", "0", ")", ";", "*", "(", "data", "+", "2", ")", "=", "uint8_t", "(", "Value", ">>", "8", ")", ";", "}", "}", "</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", "." ]

[ "MBlaze", "MBlaze", "\"Invalid fixup offset!\"", "\"Cannot fixup unknown value.\"", "1", "\"Cannot fixup 1 byte value.\"", "8", "\"Cannot fixup 8 byte value.\"", "4", "7", "6", "8", "3", "16", "2", "24", "2", "3", "0", "2", "8" ]

[]

[ "<s>", "unsigned", "MipsAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "JALR_HB", ":", "case", "Mips", "::", "JALRC_HB_MMR6", ":", "case", "Mips", "::", "JALRC_MMR6", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "return", "Match_RequiresDifferentSrcAndDst", ";", "return", "Match_Success", ";", "case", "Mips", "::", "LWP_MM", ":", "case", "Mips", "::", "LWP_MMR6", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "return", "Match_RequiresDifferentSrcAndDst", ";", "return", "Match_Success", ";", "case", "Mips", "::", "BLEZC", ":", "case", "Mips", "::", "BGEZC", ":", "case", "Mips", "::", "BGTZC", ":", "case", "Mips", "::", "BLTZC", ":", "case", "Mips", "::", "BEQZC", ":", "case", "Mips", "::", "BNEZC", ":", "case", "Mips", "::", "BLEZC64", ":", "case", "Mips", "::", "BGEZC64", ":", "case", "Mips", "::", "BGTZC64", ":", "case", "Mips", "::", "BLTZC64", ":", "case", "Mips", "::", "BEQZC64", ":", "case", "Mips", "::", "BNEZC64", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO_64", ")", "return", "Match_RequiresNoZeroRegister", ";", "return", "Match_Success", ";", "case", "Mips", "::", "BGEC", ":", "case", "Mips", "::", "BLTC", ":", "case", "Mips", "::", "BGEUC", ":", "case", "Mips", "::", "BLTUC", ":", "case", "Mips", "::", "BEQC", ":", "case", "Mips", "::", "BNEC", ":", "case", "Mips", "::", "BGEC64", ":", "case", "Mips", "::", "BLTC64", ":", "case", "Mips", "::", "BGEUC64", ":", "case", "Mips", "::", "BLTUC64", ":", "case", "Mips", "::", "BEQC64", ":", "case", "Mips", "::", "BNEC64", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO_64", ")", "return", "Match_RequiresNoZeroRegister", ";", "if", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO", "||", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO_64", ")", "return", "Match_RequiresNoZeroRegister", ";", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", "return", "Match_RequiresDifferentOperands", ";", "return", "Match_Success", ";", "default", ":", "return", "Match_Success", ";", "}", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "Mips", "Mips", "Mips::JALR_HB", "Mips::JALRC_HB_MMR6", "Mips::JALRC_MMR6", "0", "1", "Mips::LWP_MM", "Mips::LWP_MMR6", "0", "2", "Mips::BLEZC", "Mips::BGEZC", "Mips::BGTZC", "Mips::BLTZC", "Mips::BEQZC", "Mips::BNEZC", "Mips::BLEZC64", "Mips::BGEZC64", "Mips::BGTZC64", "Mips::BLTZC64", "Mips::BEQZC64", "Mips::BNEZC64", "0", "Mips::ZERO", "0", "Mips::ZERO_64", "Mips::BGEC", "Mips::BLTC", "Mips::BGEUC", "Mips::BLTUC", "Mips::BEQC", "Mips::BNEC", "Mips::BGEC64", "Mips::BLTC64", "Mips::BGEUC64", "Mips::BLTUC64", "Mips::BEQC64", "Mips::BNEC64", "0", "Mips::ZERO", "0", "Mips::ZERO_64", "1", "Mips::ZERO", "1", "Mips::ZERO_64", "0", "1" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "AArch64", "::", "FP", ":", "AArch64", "::", "SP", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64::FP", "AArch64::SP" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "AVR" ]

[]

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "rtx", "m68k_move_to_reg", "(", "rtx", "x", ",", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "reg", "==", "NULL_RTX", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "}", "insn", "=", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Move", "X", "to", "a", "register", "and", "add", "REG_EQUAL", "note", "pointing", "to", "ORIG", ".", "If", "REG", "is", "non-null", ",", "use", "it", ";", "generate", "new", "pseudo", "otherwise", "." ]

[ "m68k" ]

[]

[ "<s>", "static", "bool", "aarch64_expand_sve_widened_duplicate", "(", "rtx", "dest", ",", "scalar_int_mode", "src_mode", ",", "rtx", "src", ")", "{", "if", "(", "src_mode", "!=", "TImode", ")", "{", "poly_uint64", "count", "=", "exact_div", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", ",", "GET_MODE_SIZE", "(", "src_mode", ")", ")", ";", "machine_mode", "dup_mode", "=", "mode_for_vector", "(", "src_mode", ",", "count", ")", ".", "require", "(", ")", ";", "emit_move_insn", "(", "gen_lowpart", "(", "dup_mode", ",", "dest", ")", ",", "gen_const_vec_duplicate", "(", "dup_mode", ",", "src", ")", ")", ";", "return", "true", ";", "}", "src", "=", "force_const_mem", "(", "src_mode", ",", "src", ")", ";", "if", "(", "!", "src", ")", "return", "false", ";", "if", "(", "!", "aarch64_sve_ld1r_operand_p", "(", "src", ")", ")", "{", "rtx", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "src", "=", "replace_equiv_address", "(", "src", ",", "addr", ")", ";", "}", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "unsigned", "int", "elem_bytes", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "machine_mode", "pred_mode", "=", "aarch64_sve_pred_mode", "(", "elem_bytes", ")", ".", "require", "(", ")", ";", "rtx", "ptrue", "=", "force_reg", "(", "pred_mode", ",", "CONSTM1_RTX", "(", "pred_mode", ")", ")", ";", "src", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "ptrue", ",", "src", ")", ",", "UNSPEC_LD1RQ", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "src", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "duplicate", "SRC", "into", "SVE", "register", "DEST", ",", "given", "that", "SRC", "is", "an", "integer", "of", "mode", "INT_MODE", ".", "Return", "true", "on", "success", "." ]

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

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "MipsAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "return", "StringSwitch", "<", "Optional", "<", "MCFixupKind", ">>", "(", "Name", ")", ".", "Case", "(", "\"R_MIPS_NONE\"", ",", "FK_NONE", ")", ".", "Case", "(", "\"R_MIPS_32\"", ",", "FK_Data_4", ")", ".", "Case", "(", "\"R_MIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_PAGE", ")", ".", "Case", "(", "\"R_MIPS_CALL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL_HI16", ")", ".", "Case", "(", "\"R_MIPS_CALL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL_LO16", ")", ".", "Case", "(", "\"R_MIPS_CALL16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_CALL16", ")", ".", "Case", "(", "\"R_MIPS_GOT16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT", ")", ".", "Case", "(", "\"R_MIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_PAGE", ")", ".", "Case", "(", "\"R_MIPS_GOT_OFST\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_OFST", ")", ".", "Case", "(", "\"R_MIPS_GOT_DISP\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_DISP", ")", ".", "Case", "(", "\"R_MIPS_GOT_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_HI16", ")", ".", "Case", "(", "\"R_MIPS_GOT_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOT_LO16", ")", ".", "Case", "(", "\"R_MIPS_TLS_GOTTPREL\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_GOTTPREL", ")", ".", "Case", "(", "\"R_MIPS_TLS_DTPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_DTPREL_HI", ")", ".", "Case", "(", "\"R_MIPS_TLS_DTPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_DTPREL_LO", ")", ".", "Case", "(", "\"R_MIPS_TLS_GD\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TLSGD", ")", ".", "Case", "(", "\"R_MIPS_TLS_LDM\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TLSLDM", ")", ".", "Case", "(", "\"R_MIPS_TLS_TPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TPREL_HI", ")", ".", "Case", "(", "\"R_MIPS_TLS_TPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_TPREL_LO", ")", ".", "Case", "(", "\"R_MICROMIPS_CALL16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_CALL16", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_DISP\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_PAGE\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT_OFST\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ")", ".", "Case", "(", "\"R_MICROMIPS_GOT16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOT16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_GOTTPREL\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_GOTTPREL", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_DTPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_DTPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_LO16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_GD\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_LDM\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_TPREL_HI16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_HI16", ")", ".", "Case", "(", "\"R_MICROMIPS_TLS_TPREL_LO16\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_LO16", ")", ".", "Case", "(", "\"R_MIPS_JALR\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_JALR", ")", ".", "Case", "(", "\"R_MICROMIPS_JALR\"", ",", "(", "MCFixupKind", ")", "Mips", "::", "fixup_MICROMIPS_JALR", ")", ".", "Default", "(", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"R_MIPS_NONE\"", "\"R_MIPS_32\"", "\"R_MIPS_GOT_PAGE\"", "Mips::fixup_Mips_GOT_PAGE", "\"R_MIPS_CALL_HI16\"", "Mips::fixup_Mips_CALL_HI16", "\"R_MIPS_CALL_LO16\"", "Mips::fixup_Mips_CALL_LO16", "\"R_MIPS_CALL16\"", "Mips::fixup_Mips_CALL16", "\"R_MIPS_GOT16\"", "Mips::fixup_Mips_GOT", "\"R_MIPS_GOT_PAGE\"", "Mips::fixup_Mips_GOT_PAGE", "\"R_MIPS_GOT_OFST\"", "Mips::fixup_Mips_GOT_OFST", "\"R_MIPS_GOT_DISP\"", "Mips::fixup_Mips_GOT_DISP", "\"R_MIPS_GOT_HI16\"", "Mips::fixup_Mips_GOT_HI16", "\"R_MIPS_GOT_LO16\"", "Mips::fixup_Mips_GOT_LO16", "\"R_MIPS_TLS_GOTTPREL\"", "Mips::fixup_Mips_GOTTPREL", "\"R_MIPS_TLS_DTPREL_HI16\"", "Mips::fixup_Mips_DTPREL_HI", "\"R_MIPS_TLS_DTPREL_LO16\"", "Mips::fixup_Mips_DTPREL_LO", "\"R_MIPS_TLS_GD\"", "Mips::fixup_Mips_TLSGD", "\"R_MIPS_TLS_LDM\"", "Mips::fixup_Mips_TLSLDM", "\"R_MIPS_TLS_TPREL_HI16\"", "Mips::fixup_Mips_TPREL_HI", "\"R_MIPS_TLS_TPREL_LO16\"", "Mips::fixup_Mips_TPREL_LO", "\"R_MICROMIPS_CALL16\"", "Mips::fixup_MICROMIPS_CALL16", "\"R_MICROMIPS_GOT_DISP\"", "Mips::fixup_MICROMIPS_GOT_DISP", "\"R_MICROMIPS_GOT_PAGE\"", "Mips::fixup_MICROMIPS_GOT_PAGE", "\"R_MICROMIPS_GOT_OFST\"", "Mips::fixup_MICROMIPS_GOT_OFST", "\"R_MICROMIPS_GOT16\"", "Mips::fixup_MICROMIPS_GOT16", "\"R_MICROMIPS_TLS_GOTTPREL\"", "Mips::fixup_MICROMIPS_GOTTPREL", "\"R_MICROMIPS_TLS_DTPREL_HI16\"", "Mips::fixup_MICROMIPS_TLS_DTPREL_HI16", "\"R_MICROMIPS_TLS_DTPREL_LO16\"", "Mips::fixup_MICROMIPS_TLS_DTPREL_LO16", "\"R_MICROMIPS_TLS_GD\"", "Mips::fixup_MICROMIPS_TLS_GD", "\"R_MICROMIPS_TLS_LDM\"", "Mips::fixup_MICROMIPS_TLS_LDM", "\"R_MICROMIPS_TLS_TPREL_HI16\"", "Mips::fixup_MICROMIPS_TLS_TPREL_HI16", "\"R_MICROMIPS_TLS_TPREL_LO16\"", "Mips::fixup_MICROMIPS_TLS_TPREL_LO16", "\"R_MIPS_JALR\"", "Mips::fixup_Mips_JALR", "\"R_MICROMIPS_JALR\"", "Mips::fixup_MICROMIPS_JALR" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "auto", "Attr", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "static", "int", "bfin_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "int", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "int", "bytes_left", "=", "get_cumulative_args", "(", "cum", ")", "->", "nregs", "*", "UNITS_PER_WORD", ";", "if", "(", "bytes", "==", "-", "1", ")", "return", "0", ";", "if", "(", "bytes_left", "==", "0", ")", "return", "0", ";", "if", "(", "bytes", ">", "bytes_left", ")", "return", "bytes_left", ";", "return", "0", ";", "}", "</s>" ]

[ "For", "an", "arg", "passed", "partly", "in", "registers", "and", "partly", "in", "memory", ",", "this", "is", "the", "number", "of", "bytes", "passed", "in", "registers", ".", "For", "args", "passed", "entirely", "in", "registers", "or", "entirely", "in", "memory", ",", "zero", ".", "Refer", "VDSP", "C", "Compiler", "manual", ",", "our", "ABI", ".", "First", "3", "words", "are", "in", "registers", ".", "So", ",", "if", "a", "an", "argument", "is", "larger", "than", "the", "registers", "available", ",", "it", "will", "span", "the", "register", "and", "stack", "." ]

[ "bfin", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "tree", "resolve_vec_cmpne", "(", "resolution", "*", "res", ",", "tree", "*", "args", ",", "tree", "*", "types", ",", "location_t", "loc", ")", "{", "if", "(", "TREE_CODE", "(", "types", "[", "0", "]", ")", "!=", "VECTOR_TYPE", "||", "!", "lang_hooks", ".", "types_compatible_p", "(", "types", "[", "0", "]", ",", "types", "[", "1", "]", ")", ")", "{", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "machine_mode", "arg0_elt_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "types", "[", "0", "]", ")", ")", ";", "if", "(", "!", "TARGET_P9_VECTOR", "||", "arg0_elt_mode", "==", "DImode", "||", "arg0_elt_mode", "==", "TImode", "||", "arg0_elt_mode", "==", "SFmode", "||", "arg0_elt_mode", "==", "DFmode", ")", "{", "switch", "(", "arg0_elt_mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "{", "vec", "<", "tree", ",", "va_gc", ">", "*", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "0", "]", ")", ";", "vec_safe_push", "(", "params", ",", "args", "[", "1", "]", ")", ";", "tree", "decl", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_CMPEQ", "]", ";", "tree", "call", "=", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "decl", ",", "params", ")", ";", "call", "=", "save_expr", "(", "call", ")", ";", "params", "=", "make_tree_vector", "(", ")", ";", "vec_safe_push", "(", "params", ",", "call", ")", ";", "vec_safe_push", "(", "params", ",", "call", ")", ";", "decl", "=", "rs6000_builtin_decls", "[", "RS6000_OVLD_VEC_NOR", "]", ";", "*", "res", "=", "resolved", ";", "return", "altivec_resolve_overloaded_builtin", "(", "loc", ",", "decl", ",", "params", ")", ";", "}", "default", ":", "*", "res", "=", "resolved_bad", ";", "return", "error_mark_node", ";", "}", "}", "*", "res", "=", "unresolved", ";", "return", "error_mark_node", ";", "}", "</s>" ]

[ "Resolve", "an", "overloaded", "vec_cmpne", "call", "and", "return", "a", "tree", "expression", "for", "the", "resolved", "call", "if", "successful", ".", "ARGS", "contains", "the", "arguments", "to", "the", "call", ".", "TYPES", "contains", "their", "types", ".", "RES", "must", "be", "set", "to", "indicate", "the", "status", "of", "the", "resolution", "attempt", ".", "LOC", "contains", "statement", "location", "information", "." ]

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

[]

[ "<s>", "rtx", "alpha_legitimize_reload_address", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind_levels", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "x", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "<", "FIRST_PSEUDO_REGISTER", "&&", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "HOST_WIDE_INT", "low", "=", "(", "(", "val", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "HOST_WIDE_INT", "high", "=", "(", "(", "(", "val", "-", "low", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "high", "+", "low", "!=", "val", ")", "return", "NULL_RTX", ";", "x", "=", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "gen_rtx_PLUS", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "GEN_INT", "(", "high", ")", ")", ",", "GEN_INT", "(", "low", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "NULL_RTX", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "NULL", ",", "BASE_REG_CLASS", ",", "GET_MODE", "(", "x", ")", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "type", ")", ";", "return", "x", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Try", "a", "machine-dependent", "way", "of", "reloading", "an", "illegitimate", "address", "operand", ".", "If", "we", "find", "one", ",", "push", "the", "reload", "and", "return", "the", "new", "rtx", "." ]

[ "alpha", "0", "0", "0", "0", "1", "1", "0", "0", "0", "0", "0", "0", "0", "1", "1", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0", "0", "0" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMipsModuleISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMipsSEISelDag", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "NoTrapAfterNoreturn", "=", "true", ";", "}", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", ")", "setGlobalISel", "(", "true", ")", ";", "setMachineOutliner", "(", "true", ")", ";", "}", "</s>" ]

[ "Create", "an", "AArch64", "architecture", "model", "." ]

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

[]

[ "<s>", "StringRef", "getSymbol", "(", ")", "const", "{", "return", "S", ";", "}", "</s>" ]

[ "Get", "the", "target", "address", "and", "flags", "for", "the", "named", "symbol", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "assert", "(", "!", "RegAllocPass", "&&", "\"NVPTX uses no regalloc!\"", ")", ";", "addPass", "(", "&", "StrongPHIEliminationID", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

[ "NVPTX", "NVPTX", "\"NVPTX uses no regalloc!\"" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "XCoreFunctionInfo", "*", "XFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFrameInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "!", "isVarArg", ")", "CCInfo", ".", "AllocateStack", "(", "XFI", "->", "getReturnStackOffset", "(", ")", ",", "4", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_XCore", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "MemOpChains", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"Can't return value from vararg function in memory\"", ")", ";", "}", "int", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ObjSize", ",", "Offset", ",", "false", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "OutVals", "[", "i", "]", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ")", ";", "}", "if", "(", "!", "MemOpChains", ".", "empty", "(", ")", ")", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "MemOpChains", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "!", "VA", ".", "isRegLoc", "(", ")", ")", "continue", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "XCoreISD", "::", "RETSP", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::OutputArg", "XCore", "XCore", "16", "4", "XCore", "4", "1", "0", "MVT::i32", "4", "0", "\"Can't return value from vararg function in memory\"", "8", "MVT::i32", "ISD::TokenFactor", "MVT::Other", "0", "1", "0", "XCoreISD::RETSP", "MVT::Other" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"m0\"", ",", "AMDGPU", "::", "M0", ")", ".", "Case", "(", "\"exec\"", ",", "AMDGPU", "::", "EXEC", ")", ".", "Case", "(", "\"exec_lo\"", ",", "AMDGPU", "::", "EXEC_LO", ")", ".", "Case", "(", "\"exec_hi\"", ",", "AMDGPU", "::", "EXEC_HI", ")", ".", "Case", "(", "\"flat_scratch\"", ",", "AMDGPU", "::", "FLAT_SCR", ")", ".", "Case", "(", "\"flat_scratch_lo\"", ",", "AMDGPU", "::", "FLAT_SCR_LO", ")", ".", "Case", "(", "\"flat_scratch_hi\"", ",", "AMDGPU", "::", "FLAT_SCR_HI", ")", ".", "Default", "(", "AMDGPU", "::", "NoRegister", ")", ";", "if", "(", "Reg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "if", "(", "(", "Subtarget", "->", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", "||", "Subtarget", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX10", ")", "&&", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "regsOverlap", "(", "Reg", ",", "AMDGPU", "::", "FLAT_SCR", ")", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\" for subtarget.\"", ")", ")", ";", "}", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "M0", ":", "case", "AMDGPU", "::", "EXEC_LO", ":", "case", "AMDGPU", "::", "EXEC_HI", ":", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "return", "Reg", ";", "break", ";", "case", "AMDGPU", "::", "EXEC", ":", "case", "AMDGPU", "::", "FLAT_SCR", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "Reg", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"missing register type checking\"", ")", ";", "}", "report_fatal_error", "(", "Twine", "(", "\"invalid type for register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"m0\"", "AMDGPU::M0", "\"exec\"", "AMDGPU::EXEC", "\"exec_lo\"", "AMDGPU::EXEC_LO", "\"exec_hi\"", "AMDGPU::EXEC_HI", "\"flat_scratch\"", "AMDGPU::FLAT_SCR", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_hi\"", "AMDGPU::FLAT_SCR_HI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "\"invalid register name \\\"\"", "\"\\\".\"", "AMDGPU", "AMDGPU", "AMDGPU::FLAT_SCR", "\"invalid register \\\"\"", "\"\\\" for subtarget.\"", "AMDGPU::M0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::FLAT_SCR_LO", "AMDGPU::FLAT_SCR_HI", "32", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "64", "\"missing register type checking\"", "\"invalid type for register \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "isVarArg", "=", "AFI", "->", "getVarArgsRegSaveSize", "(", ")", ">", "0", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Restores", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs", ",", "CSI", ",", "TRI", ")", ";", "unsigned", "PopOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDMIA_UPD", ":", "ARM", "::", "LDMIA_UPD", ";", "unsigned", "LdrOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2LDR_POST", ":", "ARM", "::", "LDR_POST_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VLDMDIA_UPD", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "isVarArg", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea2Register", ",", "0", ")", ";", "emitPopInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PopOpc", ",", "LdrOpc", ",", "isVarArg", ",", "false", ",", "&", "isARMArea1Register", ",", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM::t2LDMIA_UPD", "ARM::LDMIA_UPD", "ARM::t2LDR_POST", "ARM::LDR_POST_IMM", "ARM::VLDMDIA_UPD", "0", "ARM", "ARM", "0", "ARM", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "unicosmk_unique_section", "(", "tree", "decl", ",", "int", "reloc", "ATTRIBUTE_UNUSED", ")", "{", "const", "char", "*", "name", ";", "int", "len", ";", "gcc_assert", "(", "decl", ")", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "default_strip_name_encoding", "(", "name", ")", ";", "len", "=", "strlen", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "{", "char", "*", "string", ";", "string", "=", "alloca", "(", "len", "+", "6", ")", ";", "sprintf", "(", "string", ",", "\"code@%s\"", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", "+", "5", ",", "string", ")", ";", "}", "else", "if", "(", "TREE_PUBLIC", "(", "decl", ")", ")", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", ",", "name", ")", ";", "else", "{", "char", "*", "string", ";", "string", "=", "alloca", "(", "len", "+", "6", ")", ";", "sprintf", "(", "string", ",", "\"data@%s\"", ",", "name", ")", ";", "DECL_SECTION_NAME", "(", "decl", ")", "=", "build_string", "(", "len", "+", "5", ",", "string", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "section", "name", "for", "decl", "and", "associate", "it", "with", "the", "declaration", "." ]

[ "alpha", "6", "\"code@%s\"", "5", "6", "\"data@%s\"", "5" ]

[]

[ "<s>", "bool", "gen_ldm_seq", "(", "rtx", "*", "operands", ",", "int", "nops", ",", "bool", "sort_regs", ")", "{", "int", "regs", "[", "MAX_LDM_STM_OPS", "]", ",", "mem_order", "[", "MAX_LDM_STM_OPS", "]", ";", "rtx", "mems", "[", "MAX_LDM_STM_OPS", "]", ";", "int", "i", ",", "j", ",", "base_reg", ";", "rtx", "base_reg_rtx", ";", "HOST_WIDE_INT", "offset", ";", "int", "write_back", "=", "FALSE", ";", "int", "ldm_case", ";", "rtx", "addr", ";", "ldm_case", "=", "load_multiple_sequence", "(", "operands", ",", "nops", ",", "regs", ",", "mem_order", ",", "&", "base_reg", ",", "&", "offset", ",", "!", "sort_regs", ")", ";", "if", "(", "ldm_case", "==", "0", ")", "return", "false", ";", "if", "(", "sort_regs", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nops", "-", "1", ";", "i", "++", ")", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "nops", ";", "j", "++", ")", "if", "(", "regs", "[", "i", "]", ">", "regs", "[", "j", "]", ")", "{", "int", "t", "=", "regs", "[", "i", "]", ";", "regs", "[", "i", "]", "=", "regs", "[", "j", "]", ";", "regs", "[", "j", "]", "=", "t", ";", "}", "base_reg_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "base_reg", ")", ";", "if", "(", "TARGET_THUMB1", ")", "{", "gcc_assert", "(", "peep2_reg_dead_p", "(", "nops", ",", "base_reg_rtx", ")", ")", ";", "gcc_assert", "(", "ldm_case", "==", "1", "||", "ldm_case", "==", "5", ")", ";", "write_back", "=", "TRUE", ";", "}", "if", "(", "ldm_case", "==", "5", ")", "{", "rtx", "newbase", "=", "TARGET_THUMB1", "?", "base_reg_rtx", ":", "gen_rtx_REG", "(", "SImode", ",", "regs", "[", "0", "]", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "newbase", ",", "base_reg_rtx", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "offset", "=", "0", ";", "if", "(", "!", "TARGET_THUMB1", ")", "{", "base_reg", "=", "regs", "[", "0", "]", ";", "base_reg_rtx", "=", "newbase", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nops", ";", "i", "++", ")", "{", "addr", "=", "plus_constant", "(", "Pmode", ",", "base_reg_rtx", ",", "offset", "+", "i", "*", "4", ")", ";", "mems", "[", "i", "]", "=", "adjust_automodify_address_nv", "(", "operands", "[", "nops", "+", "mem_order", "[", "i", "]", "]", ",", "SImode", ",", "addr", ",", "0", ")", ";", "}", "emit_insn", "(", "arm_gen_load_multiple_1", "(", "nops", ",", "regs", ",", "mems", ",", "base_reg_rtx", ",", "write_back", "?", "offset", "+", "i", "*", "4", ":", "0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Called", "from", "a", "peephole2", "expander", "to", "turn", "a", "sequence", "of", "loads", "into", "an", "LDM", "instruction", ".", "OPERANDS", "are", "the", "operands", "found", "by", "the", "peephole", "matcher", ";", "NOPS", "indicates", "how", "many", "separate", "loads", "we", "are", "trying", "to", "combine", ".", "SORT_REGS", "is", "true", "if", "we", "can", "reorder", "the", "registers", "because", "they", "are", "used", "commutatively", "subsequently", ".", "Returns", "true", "iff", "we", "could", "generate", "a", "new", "instruction", "." ]

[ "arm", "0", "0", "1", "1", "1", "5", "5", "0", "0", "0", "0", "4", "0", "4", "0" ]

[]

[ "<s>", "void", "ARMConstantPoolMBB", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "O", "<<", "\"BB#\"", "<<", "MBB", "->", "getNumber", "(", ")", ";", "ARMConstantPoolValue", "::", "print", "(", "O", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"BB#\"", "ARM" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "setVarMap", "(", ")", ";", "bool", "Res", "=", "false", ";", "std", "::", "string", "Name", ";", "Type", "*", "Tys", "[", "1", "]", ";", "Type", "*", "I8Ty", "=", "Type", "::", "getInt8Ty", "(", "M", ".", "getContext", "(", ")", ")", ";", "Function", "*", "ReflectFunction", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "5", ";", "++", "i", ")", "{", "Tys", "[", "0", "]", "=", "PointerType", "::", "get", "(", "I8Ty", ",", "i", ")", ";", "Name", "=", "Intrinsic", "::", "getName", "(", "Intrinsic", "::", "nvvm_reflect", ",", "Tys", ")", ";", "ReflectFunction", "=", "M", ".", "getFunction", "(", "Name", ")", ";", "if", "(", "ReflectFunction", "!=", "0", ")", "{", "Res", "|=", "handleFunction", "(", "ReflectFunction", ")", ";", "}", "}", "ReflectFunction", "=", "M", ".", "getFunction", "(", "NVVM_REFLECT_FUNCTION", ")", ";", "if", "(", "ReflectFunction", "!=", "0", ")", "Res", "|=", "handleFunction", "(", "ReflectFunction", ")", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "NVPTX", "1", "0", "5", "0", "Intrinsic::getName", "Intrinsic::nvvm_reflect", "0", "0" ]

[]

[ "<s>", "static", "tree", "altivec_build_resolved_builtin", "(", "tree", "*", "args", ",", "int", "n", ",", "const", "struct", "altivec_builtin_types", "*", "desc", ")", "{", "tree", "impl_fndecl", "=", "rs6000_builtin_decls", "[", "desc", "->", "overloaded_code", "]", ";", "tree", "ret_type", "=", "rs6000_builtin_type", "(", "desc", "->", "ret_type", ")", ";", "tree", "argtypes", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "impl_fndecl", ")", ")", ";", "tree", "arg_type", "[", "3", "]", ";", "tree", "call", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "arg_type", "[", "i", "]", "=", "TREE_VALUE", "(", "argtypes", ")", ",", "argtypes", "=", "TREE_CHAIN", "(", "argtypes", ")", ";", "if", "(", "desc", "->", "code", "==", "ALTIVEC_BUILTIN_VEC_VCMPGE_P", "&&", "desc", "->", "overloaded_code", "!=", "ALTIVEC_BUILTIN_VCMPGEFP_P", "&&", "desc", "->", "overloaded_code", "!=", "VSX_BUILTIN_XVCMPGEDP_P", ")", "{", "tree", "t", ";", "t", "=", "args", "[", "2", "]", ",", "args", "[", "2", "]", "=", "args", "[", "1", "]", ",", "args", "[", "1", "]", "=", "t", ";", "t", "=", "arg_type", "[", "2", "]", ",", "arg_type", "[", "2", "]", "=", "arg_type", "[", "1", "]", ",", "arg_type", "[", "1", "]", "=", "t", ";", "args", "[", "0", "]", "=", "fold_build2", "(", "BIT_XOR_EXPR", ",", "TREE_TYPE", "(", "args", "[", "0", "]", ")", ",", "args", "[", "0", "]", ",", "build_int_cst", "(", "NULL_TREE", ",", "2", ")", ")", ";", "}", "switch", "(", "n", ")", "{", "case", "0", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "0", ")", ";", "break", ";", "case", "1", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "1", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ")", ";", "break", ";", "case", "2", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "2", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ")", ";", "break", ";", "case", "3", ":", "call", "=", "build_call_expr", "(", "impl_fndecl", ",", "3", ",", "fully_fold_convert", "(", "arg_type", "[", "0", "]", ",", "args", "[", "0", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "1", "]", ",", "args", "[", "1", "]", ")", ",", "fully_fold_convert", "(", "arg_type", "[", "2", "]", ",", "args", "[", "2", "]", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "fold_convert", "(", "ret_type", ",", "call", ")", ";", "}", "</s>" ]

[ "Build", "a", "tree", "for", "a", "function", "call", "to", "an", "Altivec", "non-overloaded", "builtin", ".", "The", "overloaded", "builtin", "that", "matched", "the", "types", "and", "args", "is", "described", "by", "DESC", ".", "The", "N", "arguments", "are", "given", "in", "ARGS", ",", "respectively", ".", "Actually", "the", "only", "thing", "it", "does", "is", "calling", "fold_convert", "on", "ARGS", ",", "with", "a", "small", "exception", "for", "vec_", "{", "all", ",", "any", "}", "_", "{", "ge", ",", "le", "}", "predicates", "." ]

[ "powerpcspe", "3", "0", "2", "2", "1", "1", "2", "2", "1", "1", "0", "0", "0", "2", "0", "0", "1", "1", "0", "0", "2", "2", "0", "0", "1", "1", "3", "3", "0", "0", "1", "1", "2", "2" ]

[]

[ "<s>", "static", "bool", "arc_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "V4HImode", ":", "case", "V2SImode", ":", "return", "TARGET_PLUS_QMACW", ";", "case", "V4SImode", ":", "case", "V8HImode", ":", "return", "TARGET_SIMD_SET", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "arc" ]

[]

[ "<s>", "static", "bool", "m68k_interrupt_function_p", "(", "tree", "func", ")", "{", "tree", "a", ";", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "a", "=", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "DECL_ATTRIBUTES", "(", "func", ")", ")", ";", "return", "(", "a", "!=", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "FUNC", "is", "an", "interrupt", "function", "as", "specified", "by", "the", "``", "interrupt_handler", "''", "attribute", "." ]

[ "m68k", "\"interrupt_handler\"" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "MI", ".", "isFullCopy", "(", ")", ")", "continue", ";", "MachineOperand", "&", "DstMO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "SrcMO", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "IsVSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "IsVSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "{", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "&", "PPC", "::", "VSLRCRegClass", ";", "assert", "(", "(", "IsF8Reg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSFReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "&&", "\"Unknown source for a VSX copy\"", ")", ";", "unsigned", "NewVReg", "=", "MRI", ".", "createVirtualRegister", "(", "SrcRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "SUBREG_TO_REG", ")", ",", "NewVReg", ")", ".", "addImm", "(", "1", ")", ".", "addOperand", "(", "SrcMO", ")", ".", "addImm", "(", "PPC", "::", "sub_64", ")", ";", "SrcMO", ".", "setReg", "(", "NewVReg", ")", ";", "}", "else", "if", "(", "!", "IsVSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "IsVSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "{", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "&", "PPC", "::", "VSLRCRegClass", ";", "assert", "(", "(", "IsF8Reg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSFReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "&&", "\"Unknown destination for a VSX copy\"", ")", ";", "unsigned", "NewVReg", "=", "MRI", ".", "createVirtualRegister", "(", "DstRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVReg", ")", ".", "addOperand", "(", "SrcMO", ")", ";", "SrcMO", ".", "setReg", "(", "NewVReg", ")", ";", "SrcMO", ".", "setSubReg", "(", "PPC", "::", "sub_64", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "0", "1", "PPC::VSLRCRegClass", "\"Unknown source for a VSX copy\"", "1", "PPC::sub_64", "PPC::VSLRCRegClass", "\"Unknown destination for a VSX copy\"", "PPC::sub_64" ]

[]

[ "<s>", "MCObjectWriter", "*", "LanaiAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createLanaiELFObjectWriter", "(", "OS", ",", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "OSType", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

[ "<s>", "void", "X86AvoidSFBPass", "::", "buildCopy", "(", "MachineInstr", "*", "LoadInst", ",", "unsigned", "NLoadOpcode", ",", "int64_t", "LoadDisp", ",", "MachineInstr", "*", "StoreInst", ",", "unsigned", "NStoreOpcode", ",", "int64_t", "StoreDisp", ",", "unsigned", "Size", ",", "int64_t", "LMMOffset", ",", "int64_t", "SMMOffset", ")", "{", "MachineOperand", "&", "LoadBase", "=", "getBaseOperand", "(", "LoadInst", ")", ";", "MachineOperand", "&", "StoreBase", "=", "getBaseOperand", "(", "StoreInst", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "LoadInst", "->", "getParent", "(", ")", ";", "MachineMemOperand", "*", "LMMO", "=", "*", "LoadInst", "->", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "SMMO", "=", "*", "StoreInst", "->", "memoperands_begin", "(", ")", ";", "Register", "Reg1", "=", "MRI", "->", "createVirtualRegister", "(", "TII", "->", "getRegClass", "(", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "0", ",", "TRI", ",", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", ";", "MachineInstr", "*", "NewLoad", "=", "BuildMI", "(", "*", "MBB", ",", "LoadInst", ",", "LoadInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "Reg1", ")", ".", "add", "(", "LoadBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "LoadDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "LMMO", ",", "LMMOffset", ",", "Size", ")", ")", ";", "if", "(", "LoadBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewLoad", ")", ".", "setIsKill", "(", "false", ")", ";", "LLVM_DEBUG", "(", "NewLoad", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "auto", "PrevInstrIt", "=", "skipDebugInstructionsBackward", "(", "std", "::", "prev", "(", "MachineBasicBlock", "::", "instr_iterator", "(", "StoreInst", ")", ")", ",", "MBB", "->", "instr_begin", "(", ")", ")", ";", "if", "(", "PrevInstrIt", ".", "getNodePtr", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "MachineInstr", "*", "NewStore", "=", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "if", "(", "StoreBase", ".", "isReg", "(", ")", ")", "getBaseOperand", "(", "NewStore", ")", ".", "setIsKill", "(", "false", ")", ";", "MachineOperand", "&", "StoreSrcVReg", "=", "StoreInst", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ";", "assert", "(", "StoreSrcVReg", ".", "isReg", "(", ")", "&&", "\"Expected virtual register\"", ")", ";", "NewStore", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "setIsKill", "(", "StoreSrcVReg", ".", "isKill", "(", ")", ")", ";", "LLVM_DEBUG", "(", "NewStore", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "COPY", "Op", "." ]

[ "X86", "X86", "0", "1", "X86::NoRegister", "X86::NoRegister", "1", "X86::NoRegister", "X86::NoRegister", "X86::AddrNumOperands", "\"Expected virtual register\"", "X86::AddrNumOperands" ]

[]

[ "<s>", "static", "bool", "tile_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "return", "mode", "==", "V4QImode", "||", "mode", "==", "V2HImode", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTOR_MODE_SUPPORTED_P", "." ]

[ "tilepro" ]

[]

[ "<s>", "static", "void", "addUses", "(", "const", "MachineInstr", "&", "MI", ",", "SmallVectorImpl", "<", "const", "MachineInstr", "*", ">", "&", "Worklist", ",", "MachineRegisterInfo", "&", "MRI", ")", "{", "for", "(", "auto", "&", "UserOp", ":", "MRI", ".", "reg_operands", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "const", "auto", "*", "User", "=", "UserOp", ".", "getParent", "(", ")", ";", "if", "(", "User", "==", "&", "MI", ")", "continue", ";", "Worklist", ".", "push_back", "(", "User", ")", ";", "}", "}", "</s>" ]

[ "Add", "uses", "to", "the", "set", "." ]

[ "RISCV", "0" ]

[]

[ "<s>", "void", "sh_set_return_address", "(", "rtx", "ra", ",", "rtx", "tmp", ")", "{", "HARD_REG_SET", "live_regs_mask", ";", "int", "d", ";", "int", "pr_reg", "=", "TARGET_SHMEDIA", "?", "PR_MEDIA_REG", ":", "PR_REG", ";", "int", "pr_offset", ";", "d", "=", "calc_live_regs", "(", "&", "live_regs_mask", ")", ";", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "live_regs_mask", ",", "pr_reg", ")", ")", "{", "rtx", "rr", ";", "if", "(", "TARGET_SHMEDIA", ")", "{", "int", "rr_regno", "=", "sh_media_register_for_return", "(", ")", ";", "if", "(", "rr_regno", "<", "0", ")", "rr_regno", "=", "pr_reg", ";", "rr", "=", "gen_rtx_REG", "(", "DImode", ",", "rr_regno", ")", ";", "}", "else", "rr", "=", "gen_rtx_REG", "(", "SImode", ",", "pr_reg", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "rr", ",", "ra", ")", ")", ";", "emit_use", "(", "rr", ")", ";", "return", ";", "}", "if", "(", "TARGET_SH5", ")", "{", "int", "offset", ";", "save_schedule", "schedule", ";", "save_entry", "*", "entry", ";", "entry", "=", "sh5_schedule_saves", "(", "&", "live_regs_mask", ",", "&", "schedule", ",", "0", ")", ";", "offset", "=", "entry", "[", "1", "]", ".", "offset", ";", "for", "(", ";", "entry", "->", "mode", "!=", "VOIDmode", ";", "entry", "--", ")", "if", "(", "entry", "->", "reg", "==", "pr_reg", ")", "goto", "found", ";", "gcc_unreachable", "(", ")", ";", "found", ":", "offset", "=", "entry", "->", "offset", "-", "offset", ";", "pr_offset", "=", "(", "rounded_frame_size", "(", "d", ")", "+", "offset", "+", "SHMEDIA_REGS_STACK_ADJUST", "(", ")", ")", ";", "}", "else", "pr_offset", "=", "rounded_frame_size", "(", "d", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "tmp", ",", "GEN_INT", "(", "pr_offset", ")", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "emit_insn", "(", "GEN_ADD3", "(", "tmp", ",", "tmp", ",", "hard_frame_pointer_rtx", ")", ")", ";", "else", "emit_insn", "(", "GEN_ADD3", "(", "tmp", ",", "tmp", ",", "stack_pointer_rtx", ")", ")", ";", "tmp", "=", "gen_frame_mem", "(", "Pmode", ",", "tmp", ")", ";", "emit_insn", "(", "GEN_MOV", "(", "tmp", ",", "ra", ")", ")", ";", "emit_use", "(", "tmp", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "RA", ".", "TEMP", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", "." ]

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

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "instr_begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isTerminator", "(", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "usePreRAHazardRecognizer", "(", ")", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ",", "\"pre-RA-sched\"", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "ARM", "ARM", "ARM", "\"pre-RA-sched\"" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "STI", ".", "hasMOVW", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVWRdRr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "else", "{", "unsigned", "DestLo", ",", "DestHi", ",", "SrcLo", ",", "SrcHi", ";", "TRI", ".", "splitReg", "(", "DestReg", ",", "DestLo", ",", "DestHi", ")", ";", "TRI", ".", "splitReg", "(", "SrcReg", ",", "SrcLo", ",", "SrcHi", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVRdRr", ")", ",", "DestLo", ")", ".", "addReg", "(", "SrcLo", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AVR", "::", "MOVRdRr", ")", ",", "DestHi", ")", ".", "addReg", "(", "SrcHi", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "else", "{", "if", "(", "AVR", "::", "GPR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "MOVRdRr", ";", "}", "else", "if", "(", "SrcReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPREAD", ";", "}", "else", "if", "(", "DestReg", "==", "AVR", "::", "SP", "&&", "AVR", "::", "DREGSRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "Opc", "=", "AVR", "::", "SPWRITE", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "AVR::DREGSRegClass", "AVR::MOVWRdRr", "AVR::MOVRdRr", "AVR::MOVRdRr", "AVR::GPR8RegClass", "AVR::MOVRdRr", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPREAD", "AVR::SP", "AVR::DREGSRegClass", "AVR::SPWRITE", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "AMDGPUTTI", "::", "PopcntSupportKind", "AMDGPUTTI", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "const", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "return", "ST", "->", "hasBCNT", "(", "TyWidth", ")", "?", "PSK_FastHardware", ":", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "R600", "\"Ty width must be power of 2\"" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "\"expected switch to return\"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "return", "TII", "->", "isInlineConstant", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

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

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "HII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "Changed", "|=", "coalesceSegments", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Changed", "|=", "splitInBlock", "(", "*", "I", ")", ";", "Changed", "|=", "predicateInBlock", "(", "*", "I", ")", ";", "}", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "postprocessUndefImplicitUses", "(", "*", "I", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "X86TargetLowering", "::", "shouldExpandAtomicLoadInIR", "(", "LoadInst", "*", "LI", ")", "const", "{", "Type", "*", "MemType", "=", "LI", "->", "getType", "(", ")", ";", "bool", "NoImplicitFloatOps", "=", "LI", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "!", "Subtarget", ".", "useSoftFloat", "(", ")", "&&", "!", "NoImplicitFloatOps", "&&", "(", "Subtarget", ".", "hasSSE1", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "needsCmpXchgNb", "(", "MemType", ")", "?", "AtomicExpansionKind", "::", "CmpXChg", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "(", "atomic", ")", "load", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

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

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "int", "FrameIndex", ",", "LiveIntervals", "*", "LIS", ",", "VirtRegMap", "*", "VRM", ")", "const", "{", "if", "(", "MI", ".", "isFullCopy", "(", ")", ")", "{", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "(", "DstReg", ".", "isVirtual", "(", ")", "||", "SrcReg", ".", "isVirtual", "(", ")", ")", "&&", "(", "DstReg", ".", "isVirtual", "(", ")", "!=", "SrcReg", ".", "isVirtual", "(", ")", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "Register", "VirtReg", "=", "DstReg", ".", "isVirtual", "(", ")", "?", "DstReg", ":", "SrcReg", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "VirtReg", ")", ";", "if", "(", "RC", "->", "hasSuperClassEq", "(", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ")", "{", "MRI", ".", "constrainRegClass", "(", "VirtReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "return", "nullptr", ";", "}", "else", "if", "(", "RC", "->", "hasSuperClassEq", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ")", "{", "MRI", ".", "constrainRegClass", "(", "VirtReg", ",", "&", "AMDGPU", "::", "SReg_64_XEXECRegClass", ")", ";", "return", "nullptr", ";", "}", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "AMDGPU", "SI", "0", "1", "AMDGPU::SReg_32RegClass", "AMDGPU::SReg_32_XM0_XEXECRegClass", "AMDGPU::SReg_64RegClass", "AMDGPU::SReg_64_XEXECRegClass" ]

[]

[ "<s>", "static", "void", "init_alignment_context", "(", "struct", "alignment_context", "*", "ac", ",", "rtx", "mem", ",", "enum", "machine_mode", "mode", ")", "{", "ac", "->", "shift", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "ac", "->", "aligned", "=", "(", "MEM_ALIGN", "(", "mem", ")", ">=", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "if", "(", "ac", "->", "aligned", ")", "ac", "->", "memsi", "=", "adjust_address", "(", "mem", ",", "SImode", ",", "0", ")", ";", "else", "{", "rtx", "byteoffset", ",", "addr", ",", "align", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "GET_MODE_SIZE", "(", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "ac", "->", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "set_mem_alias_set", "(", "ac", "->", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "set_mem_align", "(", "ac", "->", "memsi", ",", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "byteoffset", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "1", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MINUS", ",", "ac", "->", "shift", ",", "byteoffset", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MULT", ",", "ac", "->", "shift", ",", "GEN_INT", "(", "BITS_PER_UNIT", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "ac", "->", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemaski", "=", "expand_simple_unop", "(", "SImode", ",", "NOT", ",", "ac", "->", "modemask", ",", "NULL_RTX", ",", "1", ")", ";", "}", "</s>" ]

[ "Initialize", "structure", "AC", "for", "word", "access", "to", "HI", "and", "QI", "mode", "memory", "." ]

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

[]