Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "TPCFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "TPC", "TPC" ]

[]

[ "<s>", "void", "NyuziDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", ";", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "NVPTXSubtarget", "::", "NVPTXSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "is64Bit", ")", ":", "NVPTXGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "Is64Bit", "(", "is64Bit", ")", ",", "PTXVersion", "(", "0", ")", ",", "SmVersion", "(", "20", ")", ",", "DL", "(", "computeDataLayout", "(", "is64Bit", ")", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "(", "const", "NVPTXTargetMachine", "&", ")", "TM", ")", ",", "TSInfo", "(", "&", "DL", ")", ",", "FrameLowering", "(", "*", "this", ")", "{", "Triple", "T", "(", "TT", ")", ";", "if", "(", "T", ".", "getOS", "(", ")", "==", "Triple", "::", "NVCL", ")", "drvInterface", "=", "NVPTX", "::", "NVCL", ";", "else", "drvInterface", "=", "NVPTX", "::", "CUDA", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "0", "20", "NVPTX", "NVPTX::NVCL", "NVPTX::CUDA" ]

[]

[ "<s>", "int", "attr_length_indirect_call", "(", "rtx", "insn", ")", "{", "unsigned", "long", "distance", "=", "-", "1", ";", "unsigned", "long", "total", "=", "IN_NAMED_SECTION_P", "(", "cfun", "->", "decl", ")", "?", "0", ":", "total_code_bytes", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "distance", "=", "(", "total", "+", "insn_current_reference_address", "(", "insn", ")", ")", ";", "if", "(", "distance", "<", "total", ")", "distance", "=", "-", "1", ";", "}", "if", "(", "TARGET_64BIT", ")", "return", "12", ";", "if", "(", "TARGET_FAST_INDIRECT_CALLS", "||", "(", "!", "TARGET_PORTABLE_RUNTIME", "&&", "(", "(", "TARGET_PA_20", "&&", "!", "TARGET_SOM", "&&", "distance", "<", "7600000", ")", "||", "distance", "<", "240000", ")", ")", ")", "return", "8", ";", "if", "(", "flag_pic", ")", "return", "24", ";", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "return", "20", ";", "return", "12", ";", "}", "</s>" ]

[ "Return", "the", "attribute", "length", "of", "the", "indirect", "call", "instruction", "INSN", ".", "The", "length", "must", "match", "the", "code", "generated", "by", "output_indirect", "call", ".", "The", "returned", "length", "includes", "the", "delay", "slot", ".", "Currently", ",", "the", "delay", "slot", "of", "an", "indirect", "call", "sequence", "is", "not", "exposed", "and", "it", "is", "used", "by", "the", "sequence", "itself", "." ]

[ "pa", "1", "0", "1", "12", "7600000", "240000", "8", "24", "20", "12" ]

[]

[ "<s>", "const", "uint32_t", "*", "VERegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "return", "CSR_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "return", "CSR_preserve_all_RegMask", ";", "}", "}", "</s>" ]

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

[ "VE", "VE" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "RISCV_VECTOR_REMOVE_REDUNDANCY_VSETVL", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetMachine", "*", "TM", "=", "0", ")", "const", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", "?", "TM", "->", "getRegisterInfo", "(", ")", ":", "0", ";", "if", "(", "isReg", "(", ")", ")", "{", "OS", "<<", "PrintReg", "(", "Contents", ".", "R", ".", "Reg", ",", "TRI", ",", "Contents", ".", "R", ".", "Sub", ")", ";", "}", "if", "(", "isImm", "(", ")", ")", "{", "OS", "<<", "Contents", ".", "ImmVal", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "pic_address_needs_scratch", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "rtx", "p0", ",", "p1", ";", "p0", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "p1", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "p0", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "p0", ")", "==", "LABEL_REF", ")", "&&", "(", "GET_CODE", "(", "p1", ")", "==", "CONST_INT", ")", "&&", "(", "flag_pic", "==", "2", "||", "microblaze_tls_symbol_p", "(", "p0", ")", "||", "!", "SMALL_INT", "(", "p1", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "an", "address", "which", "needs", "a", "temporary", "register", "when", "reloaded", "while", "generating", "PIC", "code", "." ]

[ "microblaze", "0", "0", "0", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Discriminate Memory Operands\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Discriminate Memory Operands\"" ]

[]

[ "<s>", "bool", "X86FixupSetCCPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "ToErase", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isSetCCr", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "MachineInstr", "*", "ZExt", "=", "nullptr", ";", "for", "(", "auto", "&", "Use", ":", "MRI", "->", "use_instructions", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "if", "(", "Use", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVZX32rr8", ")", "ZExt", "=", "&", "Use", ";", "if", "(", "!", "ZExt", ")", "continue", ";", "MachineInstr", "*", "FlagsDefMI", "=", "findFlagsImpDef", "(", "MI", ".", "getParent", "(", ")", ",", "MachineBasicBlock", "::", "reverse_iterator", "(", "&", "MI", ")", ")", ";", "if", "(", "!", "FlagsDefMI", ")", "continue", ";", "if", "(", "impUsesFlags", "(", "FlagsDefMI", ")", ")", "continue", ";", "++", "NumSubstZexts", ";", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", "?", "&", "X86", "::", "GR32RegClass", ":", "&", "X86", "::", "GR32_ABCDRegClass", ";", "unsigned", "ZeroReg", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "unsigned", "InsertReg", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "MBB", ",", "FlagsDefMI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "MOV32r0", ")", ",", "ZeroReg", ")", ";", "BuildMI", "(", "*", "ZExt", "->", "getParent", "(", ")", ",", "ZExt", ",", "ZExt", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "INSERT_SUBREG", ")", ",", "InsertReg", ")", ".", "addReg", "(", "ZeroReg", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "X86", "::", "sub_8bit", ")", ";", "MRI", "->", "replaceRegWith", "(", "ZExt", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "InsertReg", ")", ";", "ToErase", ".", "push_back", "(", "ZExt", ")", ";", "}", "}", "for", "(", "auto", "&", "I", ":", "ToErase", ")", "I", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "4", "0", "X86::MOVZX32rr8", "X86", "X86::GR32RegClass", "X86::GR32_ABCDRegClass", "X86::MOV32r0", "X86::INSERT_SUBREG", "0", "X86::sub_8bit", "0" ]

[]

[ "<s>", "bool", "JVMInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineInstr", "*", "UBR", "=", "nullptr", ";", "MachineInstr", "*", "CBR", "=", "nullptr", ";", "for", "(", "auto", "ritr", "=", "MBB", ".", "instr_rbegin", "(", ")", ";", "ritr", "!=", "MBB", ".", "instr_rend", "(", ")", ";", "ritr", "++", ")", "{", "MachineInstr", "&", "MI", "=", "*", "ritr", ";", "if", "(", "!", "MI", ".", "isBranch", "(", ")", ")", "break", ";", "if", "(", "!", "IsConditionalBranch", "(", "MI", ")", ")", "{", "assert", "(", "!", "UBR", "&&", "\"Multiple-unconditional branches\"", ")", ";", "UBR", "=", "&", "MI", ";", "}", "else", "{", "assert", "(", "!", "CBR", "&&", "\"Multiple-conditional branches\"", ")", ";", "CBR", "=", "&", "MI", ";", "}", "}", "if", "(", "nullptr", "==", "CBR", "&&", "nullptr", "==", "UBR", ")", "return", "true", ";", "else", "if", "(", "UBR", "&&", "!", "CBR", ")", "{", "TBB", "=", "UBR", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "CBR", ")", "{", "TBB", "=", "CBR", "->", "getOperand", "(", "CBR", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getMBB", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CBR", "->", "getNumOperands", "(", ")", "-", "2", ";", "i", "++", ")", "Cond", ".", "push_back", "(", "CBR", "->", "getOperand", "(", "i", ")", ")", ";", "FBB", "=", "UBR", "?", "UBR", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ":", "nullptr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unhandled banching\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "JVM", "JVM", "\"Multiple-unconditional branches\"", "\"Multiple-conditional branches\"", "0", "1", "0", "2", "0", "\"Unhandled banching\"" ]

[]

[ "<s>", "void", "umips_output_load_store_pair", "(", "bool", "load_p", ",", "rtx", "*", "operands", ")", "{", "rtx", "reg1", ",", "reg2", ",", "mem1", ",", "mem2", ";", "if", "(", "load_p", ")", "{", "reg1", "=", "operands", "[", "0", "]", ";", "reg2", "=", "operands", "[", "2", "]", ";", "mem1", "=", "operands", "[", "1", "]", ";", "mem2", "=", "operands", "[", "3", "]", ";", "}", "else", "{", "reg1", "=", "operands", "[", "1", "]", ";", "reg2", "=", "operands", "[", "3", "]", ";", "mem1", "=", "operands", "[", "0", "]", ";", "mem2", "=", "operands", "[", "2", "]", ";", "}", "if", "(", "REGNO", "(", "reg2", ")", "==", "REGNO", "(", "reg1", ")", "+", "1", ")", "{", "umips_output_load_store_pair_1", "(", "load_p", ",", "reg1", ",", "mem1", ")", ";", "return", ";", "}", "gcc_assert", "(", "REGNO", "(", "reg1", ")", "==", "REGNO", "(", "reg2", ")", "+", "1", ")", ";", "umips_output_load_store_pair_1", "(", "load_p", ",", "reg2", ",", "mem2", ")", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "instruction", "for", "a", "microMIPS", "LWP", "or", "SWP", "instruction", ".", "LOAD_P", "and", "OPERANDS", "are", "as", "for", "umips_load_store_pair_p", "." ]

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

[]

[ "<s>", "DecodeStatus", "LanaiDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableLanai32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "PostOperandDecodeAdjust", "(", "Instr", ",", "Insn", ")", ";", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

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

[]

[ "<s>", "InstructionCost", "AArch64TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "DataTy", ",", "const", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "Align", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", ")", "{", "if", "(", "useNeonVector", "(", "DataTy", ")", ")", "return", "BaseT", "::", "getGatherScatterOpCost", "(", "Opcode", ",", "DataTy", ",", "Ptr", ",", "VariableMask", ",", "Alignment", ",", "CostKind", ",", "I", ")", ";", "auto", "*", "VT", "=", "cast", "<", "VectorType", ">", "(", "DataTy", ")", ";", "auto", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "DataTy", ")", ";", "if", "(", "!", "LT", ".", "first", ".", "isValid", "(", ")", ")", "return", "InstructionCost", "::", "getInvalid", "(", ")", ";", "if", "(", "cast", "<", "VectorType", ">", "(", "DataTy", ")", "->", "getElementCount", "(", ")", "==", "ElementCount", "::", "getScalable", "(", "1", ")", ")", "return", "InstructionCost", "::", "getInvalid", "(", ")", ";", "ElementCount", "LegalVF", "=", "LT", ".", "second", ".", "getVectorElementCount", "(", ")", ";", "InstructionCost", "MemOpCost", "=", "getMemoryOpCost", "(", "Opcode", ",", "VT", "->", "getElementType", "(", ")", ",", "Alignment", ",", "0", ",", "CostKind", ",", "I", ")", ";", "MemOpCost", "*=", "getSVEGatherScatterOverhead", "(", "Opcode", ")", ";", "return", "LT", ".", "first", "*", "MemOpCost", "*", "getMaxNumElements", "(", "LegalVF", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

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

[]

[ "<s>", "const", "char", "*", "output_plussi", "(", "rtx", "*", "operands", ",", "bool", "need_flags", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "intval", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "1", "&&", "intval", "<=", "7", ")", ")", "return", "\"add.l\\t%S2,%S0\"", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "-", "7", "&&", "intval", "<=", "-", "1", ")", ")", "return", "\"sub.l\\t%G2,%S0\"", ";", "switch", "(", "(", "unsigned", "int", ")", "intval", "&", "0xffffffff", ")", "{", "case", "0x00000001", ":", "if", "(", "need_flags", ")", "return", "\"inc.l\\t#1,%S0\"", ";", "else", "return", "\"adds\\t%2,%S0\"", ";", "case", "0x00000002", ":", "if", "(", "need_flags", ")", "return", "\"inc.l\\t#2,%S0\"", ";", "else", "return", "\"adds\\t%2,%S0\"", ";", "case", "0xffffffff", ":", "if", "(", "need_flags", ")", "return", "\"dec.l\\t#1,%S0\"", ";", "else", "return", "\"subs\\t%G2,%S0\"", ";", "case", "0xfffffffe", ":", "if", "(", "need_flags", ")", "return", "\"dec.l\\t#2,%S0\"", ";", "else", "return", "\"subs\\t%G2,%S0\"", ";", "case", "0x00000004", ":", "if", "(", "!", "need_flags", ")", "return", "\"adds\\t%2,%S0\"", ";", "case", "0xfffffffc", ":", "if", "(", "!", "need_flags", ")", "return", "\"subs\\t%G2,%S0\"", ";", "case", "0x00010000", ":", "case", "0x00020000", ":", "if", "(", "!", "need_flags", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"inc.w\\t%2,%e0\"", ";", "}", "case", "0xffff0000", ":", "case", "0xfffe0000", ":", "if", "(", "!", "need_flags", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"dec.w\\t%G2,%e0\"", ";", "}", "}", "if", "(", "(", "intval", "&", "0xffff", ")", "==", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"add.w\\t%2,%e0\"", ";", "}", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"sub.l\\t%S2,%S0\"", ";", "}", "return", "\"add.l\\t%S2,%S0\"", ";", "}", "</s>" ]

[ "Output", "an", "addition", "insn", "." ]

[ "h8300", "0", "2", "1", "2", "1", "7", "\"add.l\\t%S2,%S0\"", "7", "1", "\"sub.l\\t%G2,%S0\"", "0xffffffff", "0x00000001", "\"inc.l\\t#1,%S0\"", "\"adds\\t%2,%S0\"", "0x00000002", "\"inc.l\\t#2,%S0\"", "\"adds\\t%2,%S0\"", "0xffffffff", "\"dec.l\\t#1,%S0\"", "\"subs\\t%G2,%S0\"", "0xfffffffe", "\"dec.l\\t#2,%S0\"", "\"subs\\t%G2,%S0\"", "0x00000004", "\"adds\\t%2,%S0\"", "0xfffffffc", "\"subs\\t%G2,%S0\"", "0x00010000", "0x00020000", "2", "16", "\"inc.w\\t%2,%e0\"", "0xffff0000", "0xfffe0000", "2", "16", "\"dec.w\\t%G2,%e0\"", "0xffff", "0", "2", "16", "\"add.w\\t%2,%e0\"", "2", "2", "0", "2", "2", "\"sub.l\\t%S2,%S0\"", "\"add.l\\t%S2,%S0\"" ]

[]

[ "<s>", "int", "mmix_legitimate_address", "(", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "int", "strict_checking", ")", "{", "(", "(", "strict_checking", "\\", "&&", "(", "REGNO", "(", "X", ")", "<=", "MMIX_LAST_GENERAL_REGISTER", "\\", "||", "(", "reg_renumber", "[", "REGNO", "(", "X", ")", "]", ">", "0", "\\", "&&", "reg_renumber", "[", "REGNO", "(", "X", ")", "]", "<=", "MMIX_LAST_GENERAL_REGISTER", ")", ")", ")", "\\", "||", "(", "!", "strict_checking", "\\", "&&", "(", "REGNO", "(", "X", ")", "<=", "MMIX_LAST_GENERAL_REGISTER", "\\", "||", "REGNO", "(", "X", ")", ">=", "FIRST_PSEUDO_REGISTER", "\\", "||", "REGNO", "(", "X", ")", "==", "ARG_POINTER_REGNUM", ")", ")", ")", "if", "(", "REG_P", "(", "x", ")", "&&", "MMIX_REG_OK", "(", "x", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "x1", ")", ")", "{", "rtx", "tem", "=", "x1", ";", "x1", "=", "x2", ";", "x2", "=", "tem", ";", "}", "if", "(", "!", "REG_P", "(", "x1", ")", "||", "!", "MMIX_REG_OK", "(", "x1", ")", ")", "return", "TARGET_BASE_ADDRESSES", "&&", "mmix_constant_address_p", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x2", ")", "&&", "MMIX_REG_OK", "(", "x2", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x2", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_LETTER_P", "(", "INTVAL", "(", "x2", ")", ",", "'I'", ")", ")", "return", "1", ";", "return", "0", ";", "}", "return", "TARGET_BASE_ADDRESSES", "&&", "mmix_constant_address_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "address", "is", "OK", ",", "otherwise", "0", ".", "Used", "by", "GO_IF_LEGITIMATE_ADDRESS", "." ]

[ "mmix", "0", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_estimated_sve_vq", "(", ")", "{", "return", "estimated_poly_value", "(", "BITS_PER_SVE_VECTOR", ")", "/", "128", ";", "}", "</s>" ]

[ "Return", "an", "estimate", "for", "the", "number", "of", "quadwords", "in", "an", "SVE", "vector", ".", "This", "is", "equivalent", "to", "the", "number", "of", "Advanced", "SIMD", "vectors", "in", "an", "SVE", "vector", "." ]

[ "aarch64", "128" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "if", "(", "!", "MIa", ".", "hasOneMemOperand", "(", ")", "||", "!", "MIb", ".", "hasOneMemOperand", "(", ")", ")", "return", "false", ";", "MachineMemOperand", "*", "MMOa", "=", "*", "MIa", ".", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "MMOb", "=", "*", "MIb", ".", "memoperands_begin", "(", ")", ";", "const", "Value", "*", "VALa", "=", "MMOa", "->", "getValue", "(", ")", ";", "const", "Value", "*", "VALb", "=", "MMOb", "->", "getValue", "(", ")", ";", "bool", "SameVal", "=", "(", "VALa", "&&", "VALb", "&&", "(", "VALa", "==", "VALb", ")", ")", ";", "if", "(", "!", "SameVal", ")", "{", "const", "PseudoSourceValue", "*", "PSVa", "=", "MMOa", "->", "getPseudoValue", "(", ")", ";", "const", "PseudoSourceValue", "*", "PSVb", "=", "MMOb", "->", "getPseudoValue", "(", ")", ";", "if", "(", "PSVa", "&&", "PSVb", "&&", "(", "PSVa", "==", "PSVb", ")", ")", "SameVal", "=", "true", ";", "}", "if", "(", "SameVal", ")", "{", "int", "OffsetA", "=", "MMOa", "->", "getOffset", "(", ")", ",", "OffsetB", "=", "MMOb", "->", "getOffset", "(", ")", ";", "int", "WidthA", "=", "MMOa", "->", "getSize", "(", ")", ",", "WidthB", "=", "MMOb", "->", "getSize", "(", ")", ";", "int", "LowOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetA", ":", "OffsetB", ";", "int", "HighOffset", "=", "OffsetA", "<", "OffsetB", "?", "OffsetB", ":", "OffsetA", ";", "int", "LowWidth", "=", "(", "LowOffset", "==", "OffsetA", ")", "?", "WidthA", ":", "WidthB", ";", "if", "(", "LowOffset", "+", "LowWidth", "<=", "HighOffset", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStBaseOp", "(", "const", "MachineInstr", "&", "MI", ")", "{", "unsigned", "Idx", "=", "isPairedLdSt", "(", "MI", ")", "||", "AArch64InstrInfo", "::", "isPreLdSt", "(", "MI", ")", "?", "2", ":", "1", ";", "return", "MI", ".", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "base", "register", "operator", "of", "a", "load/store", "." ]

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

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "string", ">", "sub", "(", "Px", "a", ",", "Bx", "b", ")", "{", "return", "D", "(", "\"sub\"", ",", "R", "(", "a", ")", ",", "R", "(", "b", ")", ")", ";", "}", "</s>" ]

[ "sub", "-", "Return", "the", "result", "of", "replacing", "the", "first", "match", "of", "the", "regex", "in", "String", "with", "the", "Repl", "string", "." ]

[ "Teak", "\"sub\"" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "{", "addPass", "(", "createSIPrepareScratchRegs", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

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

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

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "tls_symbolic_reference_mentioned_p", "(", "rtx", "op", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "tls_symbolic_operand", "(", "op", ")", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "op", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "op", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "op", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "tls_symbolic_reference_mentioned_p", "(", "XVECEXP", "(", "op", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "tls_symbolic_reference_mentioned_p", "(", "XEXP", "(", "op", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "contains", "a", "reference", "to", "a", "thread-local", "symbol", "." ]

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

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M68kRegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "Info", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "M68k", "::", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M68k", "::", "MOVM32pm", ")", ")", ",", "FI", ")", ".", "addImm", "(", "Mask", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "Register", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "bool", "IsLiveIn", "=", "RI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "IsLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "I", ".", "addReg", "(", "Reg", ",", "IsLiveIn", "?", "RegState", "::", "Implicit", ":", "RegState", "::", "ImplicitKill", ")", ";", "M68k", "::", "addMemOperand", "(", "I", ",", "Info", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "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", "(", ")", "." ]

[ "M68k", "M68k", "M68k", "0", "0", "1", "M68k::addFrameReference", "M68k::MOVM32pm", "M68k::addMemOperand", "0" ]

[]

[ "<s>", "void", "Remove", "(", "T", "&", "Instrs", ",", "MachineRegisterInfo", "&", "RI", ")", "{", "for", "(", "MachineInstr", "*", "I", ":", "Instrs", ")", "{", "if", "(", "RI", ".", "use_nodbg_empty", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "I", "->", "eraseFromParentAndMarkDBGValuesForRemoval", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Remove", "-", "Removes", "a", "function", "pass", "from", "the", "registration", "list", "." ]

[ "Mips", "0" ]

[]

[ "<s>", "static", "void", "conditionalize_after_sched", "(", "void", ")", "{", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "rtx", "cond", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "uid", ">=", "INSN_INFO_LENGTH", ")", "continue", ";", "cond", "=", "INSN_INFO_ENTRY", "(", "uid", ")", ".", "new_cond", ";", "if", "(", "cond", "==", "NULL_RTX", ")", "continue", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Conditionalizing insn %d\\n\"", ",", "uid", ")", ";", "predicate_insn", "(", "insn", ",", "cond", ",", "true", ")", ";", "}", "}", "</s>" ]

[ "For", "every", "insn", "that", "has", "an", "entry", "in", "the", "new_conditions", "vector", ",", "give", "it", "the", "appropriate", "predicate", "." ]

[ "c6x", "\"Conditionalizing insn %d\\n\"" ]

[]

[ "<s>", "void", "ARM64AsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "const", "TargetInstrDesc", "&", "TID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "TID", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "{", "ARMFunctionInfo", "*", "AFI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "return", "AFI", "->", "isThumb2Function", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON", "ARM", "ARM" ]

[]

[ "<s>", "static", "rtx", "mips_expand_builtin_direct", "(", "enum", "insn_code", "icode", ",", "rtx", "target", ",", "tree", "arglist", ",", "bool", "has_target", ")", "{", "rtx", "ops", "[", "MAX_RECOG_OPERANDS", "]", ";", "int", "i", "=", "0", ";", "if", "(", "has_target", ")", "{", "ops", "[", "0", "]", "=", "mips_prepare_builtin_target", "(", "icode", ",", "0", ",", "target", ")", ";", "i", "=", "1", ";", "}", "for", "(", ";", "i", "<", "insn_data", "[", "icode", "]", ".", "n_operands", "&&", "arglist", "!=", "0", ";", "i", "++", ")", "ops", "[", "i", "]", "=", "mips_prepare_builtin_arg", "(", "icode", ",", "i", ",", "&", "arglist", ")", ";", "switch", "(", "i", ")", "{", "case", "2", ":", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "ops", "[", "0", "]", ",", "ops", "[", "1", "]", ")", ")", ";", "break", ";", "case", "3", ":", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "ops", "[", "0", "]", ",", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ")", ")", ";", "break", ";", "case", "4", ":", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "ops", "[", "0", "]", ",", "ops", "[", "1", "]", ",", "ops", "[", "2", "]", ",", "ops", "[", "3", "]", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "target", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Dcpu16" ]

[]

[ "<s>", "static", "inline", "HOST_WIDE_INT", "htm_spr_num", "(", "enum", "rs6000_builtins", "code", ")", "{", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFHAR", "||", "code", "==", "HTM_BUILTIN_SET_TFHAR", ")", "return", "TFHAR_SPR", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFIAR", "||", "code", "==", "HTM_BUILTIN_SET_TFIAR", ")", "return", "TFIAR_SPR", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TEXASR", "||", "code", "==", "HTM_BUILTIN_SET_TEXASR", ")", "return", "TEXASR_SPR", ";", "gcc_assert", "(", "code", "==", "HTM_BUILTIN_GET_TEXASRU", "||", "code", "==", "HTM_BUILTIN_SET_TEXASRU", ")", ";", "return", "TEXASRU_SPR", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SPR", "number", "associated", "with", "the", "given", "builtin", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "void", "build_vs_offset", "(", "function_builder", "&", "b", ",", "const", "char", "*", "signature", ",", "const", "function_group_info", "&", "group", ",", "bool", "force_direct_overloads", "=", "false", ")", "{", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_u32base_offset", ",", "MODE_u64base_offset", ",", "force_direct_overloads", ")", ";", "}", "</s>" ]

[ "Like", "build_v_base", ",", "but", "for", "functions", "that", "also", "take", "a", "scalar", "byte", "offset", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "isValid", "(", ")", "{", "return", "isValidModel", ";", "}", "</s>" ]

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

[ "TPC" ]

[]

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

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

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

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "msp430_hard_regno_nregs_with_padding", "(", "int", "regno", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "PSImode", ")", "return", "2", ";", "return", "msp430_hard_regno_nregs", "(", "regno", ",", "mode", ")", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS_WITH_PADDING", "." ]

[ "msp430", "2" ]

[]

[ "<s>", "outliner", "::", "OutlinedFunction", "ARMBaseInstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "outliner", "::", "Candidate", "&", "FirstCand", "=", "RepeatedSequenceLocs", "[", "0", "]", ";", "unsigned", "SequenceSize", "=", "std", "::", "accumulate", "(", "FirstCand", ".", "front", "(", ")", ",", "std", "::", "next", "(", "FirstCand", ".", "back", "(", ")", ")", ",", "0", ",", "[", "this", "]", "(", "unsigned", "Sum", ",", "const", "MachineInstr", "&", "MI", ")", "{", "return", "Sum", "+", "getInstSizeInBytes", "(", "MI", ")", ";", "}", ")", ";", "unsigned", "FlagsSetInAll", "=", "0xF", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "getRegisterInfo", "(", ")", ";", "std", "::", "for_each", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "[", "&", "FlagsSetInAll", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "FlagsSetInAll", "&=", "C", ".", "Flags", ";", "}", ")", ";", "auto", "CantGuaranteeValueAcrossCall", "=", "[", "&", "TRI", "]", "(", "outliner", "::", "Candidate", "&", "C", ")", "{", "if", "(", "C", ".", "Flags", "&", "UnsafeRegsDead", ")", "return", "false", ";", "C", ".", "initLRU", "(", "TRI", ")", ";", "LiveRegUnits", "LRU", "=", "C", ".", "LRU", ";", "return", "(", "!", "LRU", ".", "available", "(", "ARM", "::", "R12", ")", "||", "!", "LRU", ".", "available", "(", "ARM", "::", "CPSR", ")", ")", ";", "}", ";", "if", "(", "!", "(", "FlagsSetInAll", "&", "UnsafeRegsDead", ")", ")", "{", "RepeatedSequenceLocs", ".", "erase", "(", "std", "::", "remove_if", "(", "RepeatedSequenceLocs", ".", "begin", "(", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ",", "CantGuaranteeValueAcrossCall", ")", ",", "RepeatedSequenceLocs", ".", "end", "(", ")", ")", ";", "if", "(", "RepeatedSequenceLocs", ".", "size", "(", ")", "<", "2", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "}", "unsigned", "LastInstrOpcode", "=", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", "->", "getOpcode", "(", ")", ";", "auto", "SetCandidateCallInfo", "=", "[", "&", "RepeatedSequenceLocs", "]", "(", "unsigned", "CallID", ",", "unsigned", "NumBytesForCall", ")", "{", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "CallID", ",", "NumBytesForCall", ")", ";", "}", ";", "auto", "Costs", "=", "std", "::", "make_unique", "<", "OutlinerCosts", ">", "(", "Subtarget", ")", ";", "unsigned", "FrameID", "=", "0", ";", "unsigned", "NumBytesToCreateFrame", "=", "0", ";", "if", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", "->", "isTerminator", "(", ")", ")", "{", "FrameID", "=", "MachineOutlinerTailCall", ";", "NumBytesToCreateFrame", "=", "Costs", "->", "FrameTailCall", ";", "SetCandidateCallInfo", "(", "MachineOutlinerTailCall", ",", "Costs", "->", "CallTailCall", ")", ";", "}", "else", "if", "(", "LastInstrOpcode", "==", "ARM", "::", "BL", "||", "LastInstrOpcode", "==", "ARM", "::", "BLX", "||", "LastInstrOpcode", "==", "ARM", "::", "tBL", "||", "LastInstrOpcode", "==", "ARM", "::", "tBLXr", "||", "LastInstrOpcode", "==", "ARM", "::", "tBLXi", ")", "{", "FrameID", "=", "MachineOutlinerThunk", ";", "NumBytesToCreateFrame", "=", "Costs", "->", "FrameThunk", ";", "SetCandidateCallInfo", "(", "MachineOutlinerThunk", ",", "Costs", "->", "CallThunk", ")", ";", "}", "else", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "NumBytesToCreateFrame", ",", "FrameID", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "0xF", "ARM::R12", "ARM::CPSR", "2", "0", "0", "0", "0", "ARM::BL", "ARM::BLX", "ARM::tBL", "ARM::tBLXr", "ARM::tBLXi" ]

[]

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

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

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

[]

[ "<s>", "void", "MipsTargetStreamer", "::", "emitStoreWithImmOffset", "(", "unsigned", "Opcode", ",", "unsigned", "SrcReg", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ",", "function_ref", "<", "unsigned", "(", ")", ">", "GetATReg", ",", "SMLoc", "IDLoc", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "{", "emitRRI", "(", "Opcode", ",", "SrcReg", ",", "BaseReg", ",", "Offset", ",", "IDLoc", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "ATReg", "=", "GetATReg", "(", ")", ";", "if", "(", "!", "ATReg", ")", "return", ";", "unsigned", "LoOffset", "=", "Offset", "&", "0x0000ffff", ";", "unsigned", "HiOffset", "=", "(", "Offset", "&", "0xffff0000", ")", ">>", "16", ";", "if", "(", "LoOffset", "&", "0x8000", ")", "HiOffset", "++", ";", "emitRI", "(", "Mips", "::", "LUi", ",", "ATReg", ",", "HiOffset", ",", "IDLoc", ",", "STI", ")", ";", "if", "(", "BaseReg", "!=", "Mips", "::", "ZERO", ")", "emitRRR", "(", "Mips", "::", "ADDu", ",", "ATReg", ",", "ATReg", ",", "BaseReg", ",", "IDLoc", ",", "STI", ")", ";", "emitRRI", "(", "Opcode", ",", "SrcReg", ",", "ATReg", ",", "LoOffset", ",", "IDLoc", ",", "STI", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "instruction", "with", "an", "offset", "." ]

[ "Mips", "Mips", "16", "0x0000ffff", "0xffff0000", "16", "0x8000", "Mips::LUi", "Mips::ZERO", "Mips::ADDu" ]

[]

[ "<s>", "void", "function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "count", ",", "bytes", ",", "words", ";", "bytes", "=", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "cum", "->", "words", "+=", "words", ";", "cum", "->", "nregs", "-=", "words", ";", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "arg_regs", "=", "NULL", ";", "}", "else", "{", "for", "(", "count", "=", "1", ";", "count", "<=", "words", ";", "count", "++", ")", "cum", "->", "arg_regs", "++", ";", "}", "return", ";", "}", "</s>" ]

[ "Handle", "the", "FUNCTION_ARG_ADVANCE", "macro", ".", "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", "." ]

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

[]

[ "<s>", "FastISel", "*", "MipsTargetLowering", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "const", "{", "const", "MipsTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "funcInfo", ".", "MF", "->", "getTarget", "(", ")", ")", ";", "bool", "UseFastISel", "=", "TM", ".", "Options", ".", "EnableFastISel", "&&", "Subtarget", ".", "hasMips32", "(", ")", "&&", "!", "Subtarget", ".", "hasMips32r6", "(", ")", "&&", "!", "Subtarget", ".", "inMips16Mode", "(", ")", "&&", "!", "Subtarget", ".", "inMicroMipsMode", "(", ")", ";", "if", "(", "!", "TM", ".", "isPositionIndependent", "(", ")", "||", "!", "TM", ".", "getABI", "(", ")", ".", "IsO32", "(", ")", ")", "UseFastISel", "=", "false", ";", "return", "UseFastISel", "?", "Mips", "::", "createFastISel", "(", "funcInfo", ",", "libInfo", ")", ":", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::createFastISel" ]

[]

[ "<s>", "void", "MBlazeFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MBlazeInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MBlazeInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "MBlazeFI", "->", "adjustLoadArgsFI", "(", "MFI", ")", ";", "MBlazeFI", "->", "adjustStoreVarArgsFI", "(", "MFI", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R15", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "RAOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "FPOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze", "MBlaze", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::ADD", "MBlaze::R19", "MBlaze::R1", "MBlaze::R0" ]

[]

[ "<s>", "static", "void", "arc_dwarf_emit_irq_save_regs", "(", "void", ")", "{", "rtx", "tmp", ",", "par", ",", "insn", ",", "reg", ";", "int", "i", ",", "offset", ",", "j", ";", "par", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", "+", "1", "+", "irq_ctrl_saved", ".", "irq_save_blink", "+", "irq_ctrl_saved", ".", "irq_save_lpcount", "+", "1", ")", ")", ";", "j", "=", "0", ";", "offset", "=", "UNITS_PER_WORD", "*", "(", "irq_ctrl_saved", ".", "irq_save_last_reg", "+", "1", "+", "irq_ctrl_saved", ".", "irq_save_blink", "+", "irq_ctrl_saved", ".", "irq_save_lpcount", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "1", "*", "offset", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "tmp", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "if", "(", "irq_ctrl_saved", ".", "irq_save_lpcount", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "60", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "if", "(", "irq_ctrl_saved", ".", "irq_save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "31", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "for", "(", "i", "=", "irq_ctrl_saved", ".", "irq_save_last_reg", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "tmp", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "++", ")", "=", "tmp", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "insn", "=", "emit_insn", "(", "gen_stack_irq_dwarf", "(", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "par", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Build", "dwarf", "information", "when", "the", "context", "is", "saved", "via", "AUX_IRQ_CTRL", "mechanism", "." ]

[ "arc", "1", "1", "0", "1", "1", "1", "0", "60", "1", "0", "31", "1", "0", "0", "1", "0", "1" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "tGPRRegisterClass", ")", ";", "else", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "SPRRegisterClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "DPRRegisterClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegisterClass", "0U", "ARM::GPRRegisterClass", "0U", "ARM::GPRRegisterClass", "MVT::f32", "0U", "ARM::SPRRegisterClass", "MVT::f64", "0U", "ARM::DPRRegisterClass" ]

[]

[ "<s>", "unsigned", "char", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "!", "TM", ".", "shouldAssumeDSOLocal", "(", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "useSmallAddressing", "(", ")", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "static", "void", "riscv_emit_int_order_test", "(", "enum", "rtx_code", "code", ",", "bool", "*", "invert_ptr", ",", "rtx", "target", ",", "rtx", "cmp0", ",", "rtx", "cmp1", ")", "{", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "cmp0", ")", ";", "if", "(", "riscv_canonicalize_int_order_test", "(", "&", "code", ",", "&", "cmp1", ",", "mode", ")", ")", "riscv_emit_binary", "(", "code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "else", "{", "enum", "rtx_code", "inv_code", "=", "reverse_condition", "(", "code", ")", ";", "if", "(", "!", "riscv_canonicalize_int_order_test", "(", "&", "inv_code", ",", "&", "cmp1", ",", "mode", ")", ")", "{", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "riscv_emit_int_order_test", "(", "code", ",", "invert_ptr", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "else", "if", "(", "invert_ptr", "==", "0", ")", "{", "rtx", "inv_target", "=", "riscv_force_binary", "(", "GET_MODE", "(", "target", ")", ",", "inv_code", ",", "cmp0", ",", "cmp1", ")", ";", "riscv_emit_binary", "(", "XOR", ",", "target", ",", "inv_target", ",", "const1_rtx", ")", ";", "}", "else", "{", "*", "invert_ptr", "=", "!", "*", "invert_ptr", ";", "riscv_emit_binary", "(", "inv_code", ",", "target", ",", "cmp0", ",", "cmp1", ")", ";", "}", "}", "}", "</s>" ]

[ "Compare", "CMP0", "and", "CMP1", "using", "ordering", "test", "CODE", "and", "store", "the", "result", "in", "TARGET", ".", "CMP0", "and", "TARGET", "are", "register_operands", ".", "If", "INVERT_PTR", "is", "nonnull", ",", "it", "'s", "OK", "to", "set", "TARGET", "to", "the", "inverse", "of", "the", "result", "and", "flip", "*", "INVERT_PTR", "instead", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "bool", "BPFAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "if", "(", "MAI", "->", "doesSupportDebugInformation", "(", ")", "&&", "!", "empty", "(", "M", ".", "debug_compile_units", "(", ")", ")", ")", "{", "BTF", "=", "new", "BTFDebug", "(", "this", ")", ";", "Handlers", ".", "push_back", "(", "HandlerInfo", "(", "std", "::", "unique_ptr", "<", "BTFDebug", ">", "(", "BTF", ")", ",", "\"emit\"", ",", "\"Debug Info Emission\"", ",", "\"BTF\"", ",", "\"BTF Emission\"", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "BPF", "BPF", "\"emit\"", "\"Debug Info Emission\"", "\"BTF\"", "\"BTF Emission\"" ]

[]

[ "<s>", "bool", "A15SDOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "(", "STI", ".", "isCortexA15", "(", ")", "&&", "STI", ".", "hasNEON", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running on function \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DeadInstr", ".", "clear", "(", ")", ";", "Replacements", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "Modified", "|=", "runOnInstruction", "(", "&", "MI", ")", ";", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "DeadInstr", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

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

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

[ "ARM" ]

[]

[ "<s>", "void", "gomp_print_output", "(", "struct", "kernargs", "*", "kernargs", ",", "bool", "final", ")", "{", "unsigned", "int", "limit", "=", "(", "sizeof", "(", "kernargs", "->", "output_data", ".", "queue", ")", "/", "sizeof", "(", "kernargs", "->", "output_data", ".", "queue", "[", "0", "]", ")", ")", ";", "unsigned", "int", "from", "=", "__atomic_load_n", "(", "&", "kernargs", "->", "output_data", ".", "consumed", ",", "__ATOMIC_ACQUIRE", ")", ";", "unsigned", "int", "to", "=", "kernargs", "->", "output_data", ".", "next_output", ";", "if", "(", "from", ">", "to", ")", "{", "if", "(", "final", ")", "printf", "(", "\"GCN print buffer overflowed.\\n\"", ")", ";", "return", ";", "}", "unsigned", "int", "i", ";", "for", "(", "i", "=", "from", ";", "i", "<", "to", ";", "i", "++", ")", "{", "struct", "printf_data", "*", "data", "=", "&", "kernargs", "->", "output_data", ".", "queue", "[", "i", "%", "limit", "]", ";", "if", "(", "!", "data", "->", "written", "&&", "!", "final", ")", "break", ";", "switch", "(", "data", "->", "type", ")", "{", "case", "0", ":", "printf", "(", "\"%.128s%ld\\n\"", ",", "data", "->", "msg", ",", "data", "->", "ivalue", ")", ";", "break", ";", "case", "1", ":", "printf", "(", "\"%.128s%f\\n\"", ",", "data", "->", "msg", ",", "data", "->", "dvalue", ")", ";", "break", ";", "case", "2", ":", "printf", "(", "\"%.128s%.128s\\n\"", ",", "data", "->", "msg", ",", "data", "->", "text", ")", ";", "break", ";", "case", "3", ":", "printf", "(", "\"%.128s%.128s\"", ",", "data", "->", "msg", ",", "data", "->", "text", ")", ";", "break", ";", "default", ":", "printf", "(", "\"GCN print buffer error!\\n\"", ")", ";", "break", ";", "}", "data", "->", "written", "=", "0", ";", "__atomic_store_n", "(", "&", "kernargs", "->", "output_data", ".", "consumed", ",", "i", "+", "1", ",", "__ATOMIC_RELEASE", ")", ";", "}", "fflush", "(", "stdout", ")", ";", "}", "</s>" ]

[ "Print", "any", "console", "output", "from", "the", "kernel", ".", "We", "print", "all", "entries", "from", "``", "consumed", "''", "to", "the", "next", "entry", "without", "a", "``", "written", "''", "flag", ",", "or", "``", "next_output", "''", "is", "reached", ".", "The", "buffer", "is", "circular", ",", "but", "the", "indices", "are", "absolute", ".", "It", "is", "assumed", "the", "kernel", "will", "stop", "writing", "data", "if", "``", "next_output", "''", "wraps", "(", "becomes", "smaller", "than", "``", "consumed", "''", ")", "." ]

[ "gcn", "0", "\"GCN print buffer overflowed.\\n\"", "0", "\"%.128s%ld\\n\"", "1", "\"%.128s%f\\n\"", "2", "\"%.128s%.128s\\n\"", "3", "\"%.128s%.128s\"", "\"GCN print buffer error!\\n\"", "0", "1" ]

[]

[ "<s>", "unsigned", "SISubtarget", "::", "getOccupancyWithNumVGPRs", "(", "unsigned", "VGPRs", ")", "const", "{", "if", "(", "VGPRs", "<=", "24", ")", "return", "10", ";", "if", "(", "VGPRs", "<=", "28", ")", "return", "9", ";", "if", "(", "VGPRs", "<=", "32", ")", "return", "8", ";", "if", "(", "VGPRs", "<=", "36", ")", "return", "7", ";", "if", "(", "VGPRs", "<=", "40", ")", "return", "6", ";", "if", "(", "VGPRs", "<=", "48", ")", "return", "5", ";", "if", "(", "VGPRs", "<=", "64", ")", "return", "4", ";", "if", "(", "VGPRs", "<=", "84", ")", "return", "3", ";", "if", "(", "VGPRs", "<=", "128", ")", "return", "2", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "waves", "per", "SIMD", "for", "kernels", "using", "VGPRs", "VGPRs", "." ]

[ "AMDGPU", "SI", "24", "10", "28", "9", "32", "8", "36", "7", "40", "6", "48", "5", "64", "4", "84", "3", "128", "2", "1" ]

[]

[ "<s>", "virtual", "bool", "runOnFunction", "(", "Function", "&", "Fn", ")", "{", "GlobalBaseReg", "=", "0", ";", "SelectionDAGISel", "::", "runOnFunction", "(", "Fn", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CellSPU", "0" ]

[]

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

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

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

[]

[ "<s>", "bool", "arc_ccfsm_branch_deleted_p", "(", "void", ")", "{", "return", "ARC_CCFSM_BRANCH_DELETED_P", "(", "&", "arc_ccfsm_current", ")", ";", "}", "</s>" ]

[ "See", "if", "the", "current", "insn", ",", "which", "is", "a", "conditional", "branch", ",", "is", "to", "be", "deleted", "." ]

[ "arc" ]

[]

[ "<s>", "static", "bool", "arm_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "mode", "==", "HFmode", ")", "return", "(", "arm_fp16_format", "!=", "ARM_FP16_FORMAT_NONE", ")", ";", "else", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", ".", "This", "simply", "adds", "HFmode", "as", "a", "supported", "mode", ";", "even", "though", "we", "do", "n't", "implement", "arithmetic", "on", "this", "type", "directly", ",", "it", "'s", "supported", "by", "optabs", "conversions", ",", "much", "the", "way", "the", "double-word", "arithmetic", "is", "special-cased", "in", "the", "default", "hook", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "mips_cfun_might_clobber_call_saved_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "crtl", "->", "saves_all_registers", ")", "return", "true", ";", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "profile", "&&", "MIPS_SAVE_REG_FOR_PROFILING_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "cfun", "->", "machine", "->", "global_pointer", "==", "regno", ")", "return", "true", ";", "if", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "true", ";", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", "&&", "mips16_cfun_returns_in_fpr_p", "(", ")", ")", "return", "true", ";", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "mips_interrupt_extra_call_saved_reg_p", "(", "regno", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "body", "might", "clobber", "register", "REGNO", ".", "We", "know", "that", "REGNO", "is", "call-saved", "." ]

[ "mips" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "LC2200InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "LC2200", "::", "ADDI", ":", "return", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "LC2200", "::", "zero", ")", ";", "}", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "LC2200", "LC2200", "LC2200::ADDI", "1", "1", "LC2200::zero" ]

[]

[ "<s>", "bool", "PTXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "formatted_raw_ostream", "&", "Out", ",", "CodeGenFileType", "FileType", ",", "CodeGenOpt", "::", "Level", "OptLevel", ",", "bool", "DisableVerify", ")", "{", "MCContext", "*", "Context", "=", "0", ";", "if", "(", "addCommonCodeGenPasses", "(", "PM", ",", "OptLevel", ",", "DisableVerify", ",", "Context", ")", ")", "return", "true", ";", "assert", "(", "Context", "!=", "0", "&&", "\"Failed to get MCContext\"", ")", ";", "if", "(", "hasMCSaveTempLabels", "(", ")", ")", "Context", "->", "setAllowTemporaryLabels", "(", "false", ")", ";", "const", "MCAsmInfo", "&", "MAI", "=", "*", "getMCAsmInfo", "(", ")", ";", "const", "MCSubtargetInfo", "&", "STI", "=", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ";", "OwningPtr", "<", "MCStreamer", ">", "AsmStreamer", ";", "switch", "(", "FileType", ")", "{", "default", ":", "return", "true", ";", "case", "CGFT_AssemblyFile", ":", "{", "MCInstPrinter", "*", "InstPrinter", "=", "getTarget", "(", ")", ".", "createMCInstPrinter", "(", "MAI", ".", "getAssemblerDialect", "(", ")", ",", "MAI", ",", "STI", ")", ";", "MCCodeEmitter", "*", "MCE", "=", "0", ";", "MCAsmBackend", "*", "MAB", "=", "0", ";", "MCStreamer", "*", "S", "=", "getTarget", "(", ")", ".", "createAsmStreamer", "(", "*", "Context", ",", "Out", ",", "true", ",", "hasMCUseLoc", "(", ")", ",", "hasMCUseCFI", "(", ")", ",", "InstPrinter", ",", "MCE", ",", "MAB", ",", "false", ")", ";", "AsmStreamer", ".", "reset", "(", "S", ")", ";", "break", ";", "}", "case", "CGFT_ObjectFile", ":", "{", "llvm_unreachable", "(", "\"Object file emission is not supported with PTX\"", ")", ";", "}", "case", "CGFT_Null", ":", "AsmStreamer", ".", "reset", "(", "createNullStreamer", "(", "*", "Context", ")", ")", ";", "break", ";", "}", "FunctionPass", "*", "Printer", "=", "getTarget", "(", ")", ".", "createAsmPrinter", "(", "*", "this", ",", "*", "AsmStreamer", ")", ";", "if", "(", "Printer", "==", "0", ")", "return", "true", ";", "AsmStreamer", ".", "take", "(", ")", ";", "PM", ".", "add", "(", "Printer", ")", ";", "PM", ".", "add", "(", "createGCInfoDeleter", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "PTX", "PTX", "0", "0", "\"Failed to get MCContext\"", "0", "0", "\"Object file emission is not supported with PTX\"", "0" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "mprocRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "mproc", "::", "GR8RegClass", ";", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "mproc", "mproc", "mproc::GR8RegClass" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_V128", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "FUNCREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_FUNCREF", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXTERNREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_EXTERNREF", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_F64", "WebAssembly::V128RegClass", "WebAssembly::COPY_V128", "WebAssembly::FUNCREFRegClass", "WebAssembly::COPY_FUNCREF", "WebAssembly::EXTERNREFRegClass", "WebAssembly::COPY_EXTERNREF", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2017 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/avr-devices.c\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "avr_texinfo", ")", "/", "sizeof", "(", "*", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcu_name", "[", "n_mcus", "++", "]", "=", "mcu", "->", "name", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "avr", "0", "\"@c Copyright (C) 2012-2017 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.c from:\\n\"", "\"@c gcc/config/avr/avr-arch.h\\n\"", "\"@c gcc/config/avr/avr-devices.c\\n\"", "\"@c gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\"" ]

[]

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

[ "Expand", "an", "expression", "EXP", "that", "calls", "a", "builtin", "without", "arguments", "." ]

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA9", "(", ")", ")", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mips PseudoInstrs Expansion\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips PseudoInstrs Expansion\"" ]

[]

[ "<s>", "MCS51TargetLowering", "::", "ConstraintType", "MCS51TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'a'", ":", "case", "'b'", ":", "case", "'d'", ":", "case", "'l'", ":", "case", "'e'", ":", "case", "'q'", ":", "case", "'r'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "case", "'x'", ":", "case", "'X'", ":", "case", "'y'", ":", "case", "'Y'", ":", "case", "'z'", ":", "case", "'Z'", ":", "return", "C_Register", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'G'", ":", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "case", "'R'", ":", "return", "C_Immediate", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "MCS51", "MCS51", "MCS51", "1", "0" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "*", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", "->", "isVarArg", "(", ")", ";", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "MFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ")", ";", "if", "(", "!", "MF", ".", "getMMI", "(", ")", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R6D", ")", ";", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R7D", ")", ";", "}", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "if", "(", "MFFrame", "->", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "CSRegs", "[", "I", "]", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSRegs", "[", "I", "]", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R11D", "SystemZ::R14D", "0", "SystemZ::GR64BitRegClass", "SystemZ::R15D" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "{", "bool", "OnlyOptimizeForSize", "=", "(", "TM", "->", "getOptLevel", "(", ")", "<", "CodeGenOpt", "::", "Aggressive", ")", "&&", "(", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", ";", "bool", "MergeExternalByDefault", "=", "!", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ";", "if", "(", "!", "OnlyOptimizeForSize", ")", "MergeExternalByDefault", "=", "false", ";", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "4095", ",", "OnlyOptimizeForSize", ",", "MergeExternalByDefault", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "OpenRISCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "OpenRISC", "::", "FP", ":", "OpenRISC", "::", "SP", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC", "OpenRISC::FP", "OpenRISC::SP" ]

[]

[ "<s>", "TargetPassConfig", "*", "MSP430TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "MSP430PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "static", "rtx", "m68hc11_expand_compare", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "ret", "=", "0", ";", "gcc_assert", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "!=", "MODE_FLOAT", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc0_rtx", ",", "gen_rtx_COMPARE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ")", ")", ";", "ret", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc0_rtx", ",", "const0_rtx", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Splitting", "of", "some", "instructions", "." ]

[ "m68hc11", "0" ]

[]

[ "<s>", "static", "void", "rs6000_eliminate_indexed_memrefs", "(", "rtx", "operands", "[", "2", "]", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "!=", "REG", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", "&&", "!", "reload_in_progress", ")", "operands", "[", "0", "]", "=", "replace_equiv_address", "(", "operands", "[", "0", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", "!=", "REG", "&&", "!", "legitimate_constant_pool_address_p", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", "&&", "!", "reload_in_progress", ")", "operands", "[", "1", "]", "=", "replace_equiv_address", "(", "operands", "[", "1", "]", ",", "copy_addr_to_reg", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "for", "the", "following", ".", "Get", "rid", "of", "[", "r+r", "]", "memory", "refs", "in", "cases", "where", "it", "wo", "n't", "work", "(", "TImode", ",", "TFmode", ")", "." ]

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "ReverseVEXT", ";", "unsigned", "Imm", ",", "WhichResult", ";", "return", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isVREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isVEXTMask", "(", "M", ",", "VT", ",", "ReverseVEXT", ",", "Imm", ")", "||", "isVTRNMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVUZPMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVZIPMask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", "||", "isVZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "WhichResult", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "0", "64", "32", "16" ]

[]

[ "<s>", "static", "bool", "xtensa_lra_p", "(", "void", ")", "{", "return", "TARGET_LRA", ";", "}", "</s>" ]

[ "Implement", "TARGET_LRA_P", "." ]

[ "xtensa" ]

[]

[ "<s>", "bool", "fp_zero_operand", "(", "rtx", "op", ")", "{", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "false", ";", "const", "REAL_VALUE_TYPE", "*", "r", "=", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ";", "return", "real_equal", "(", "r", ",", "&", "dconst0", ")", "&&", "!", "REAL_VALUE_MINUS_ZERO", "(", "*", "r", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "a", "floating", "point", "value", "with", "value", "0.0", "." ]

[ "sh" ]

[]

[ "<s>", "void", "SNESRegisterInfo", "::", "splitReg", "(", "unsigned", "Reg", ",", "unsigned", "&", "LoReg", ",", "unsigned", "&", "HiReg", ")", "const", "{", "assert", "(", "SNES", "::", "MainRegsRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "SNES", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "SNES", "::", "sub_hi", ")", ";", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "SNES", "SNES", "SNES::MainRegsRegClass", "\"can only split 16-bit registers\"", "SNES::sub_lo", "SNES::sub_hi" ]

[]

[ "<s>", "static", "rtx", "function_value_32", "(", "machine_mode", "orig_mode", ",", "machine_mode", "mode", ",", "const_tree", "fntype", ",", "const_tree", "fn", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", "regno", "=", "FIRST_MMX_REG", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "regno", "=", "FIRST_SSE_REG", ";", "else", "if", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_FLOAT_RETURNS_IN_80387", ")", "regno", "=", "FIRST_FLOAT_REG", ";", "else", "regno", "=", "AX_REG", ";", "if", "(", "mode", "==", "HFmode", ")", "regno", "=", "FIRST_SSE_REG", ";", "if", "(", "mode", "==", "HCmode", ")", "{", "rtx", "ret", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "1", ")", ")", ";", "XVECEXP", "(", "ret", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "FIRST_SSE_REG", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "ret", ";", "}", "if", "(", "(", "fn", "||", "fntype", ")", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", "{", "int", "sse_level", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fn", ",", "false", ")", ";", "if", "(", "sse_level", "==", "-", "1", ")", "{", "error", "(", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", ",", "fn", ")", ";", "sorry", "(", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", ")", ";", "}", "else", "if", "(", "(", "sse_level", ">=", "1", "&&", "mode", "==", "SFmode", ")", "||", "(", "sse_level", "==", "2", "&&", "mode", "==", "DFmode", ")", ")", "regno", "=", "FIRST_SSE_REG", ";", "}", "gcc_assert", "(", "mode", "!=", "OImode", ")", ";", "return", "gen_rtx_REG", "(", "orig_mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", "." ]

[ "i386", "8", "16", "32", "64", "1", "0", "0", "0", "1", "\"calling %qD with SSE calling convention without \"", "\"SSE/SSE2 enabled\"", "\"this is a GCC bug that can be worked around by adding \"", "\"attribute used to function called\"", "1", "2" ]

[]

[ "<s>", "static", "void", "store_reg_modify", "(", "int", "base", ",", "int", "reg", ",", "HOST_WIDE_INT", "mod", ")", "{", "rtx", "insn", ",", "basereg", ",", "srcreg", ",", "delta", ";", "gcc_assert", "(", "VAL_14_BITS_P", "(", "mod", ")", ")", ";", "basereg", "=", "gen_rtx_REG", "(", "Pmode", ",", "base", ")", ";", "srcreg", "=", "gen_rtx_REG", "(", "word_mode", ",", "reg", ")", ";", "delta", "=", "GEN_INT", "(", "mod", ")", ";", "insn", "=", "emit_insn", "(", "gen_post_store", "(", "basereg", ",", "srcreg", ",", "delta", ")", ")", ";", "if", "(", "DO_FRAME_NOTES", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "1", ")", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "to", "store", "REG", "at", "the", "memory", "location", "specified", "by", "BASE", "and", "then", "add", "MOD", "to", "BASE", ".", "MOD", "must", "be", "<", "=", "8k", "." ]

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

[]

[ "<s>", "bool", "nds32_indirect_call_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_ICT", ")", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "return", "decl", "&&", "(", "lookup_attribute", "(", "\"indirect_call\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", "!=", "NULL", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "X", "is", "a", "indirect", "call", "symbol", "." ]

[ "nds32", "1", "0", "0", "\"indirect_call\"" ]

[]

[ "<s>", "const", "char", "*", "BPFTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "BPFISD", "::", "ADJDYNALLOC", ":", "return", "\"BPFISD::ADJDYNALLOC\"", ";", "case", "BPFISD", "::", "RET_FLAG", ":", "return", "\"BPFISD::RET_FLAG\"", ";", "case", "BPFISD", "::", "CALL", ":", "return", "\"BPFISD::CALL\"", ";", "case", "BPFISD", "::", "SELECT_CC", ":", "return", "\"BPFISD::SELECT_CC\"", ";", "case", "BPFISD", "::", "BR_CC", ":", "return", "\"BPFISD::BR_CC\"", ";", "case", "BPFISD", "::", "Wrapper", ":", "return", "\"BPFISD::Wrapper\"", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "BPFISD::ADJDYNALLOC", "\"BPFISD::ADJDYNALLOC\"", "BPFISD::RET_FLAG", "\"BPFISD::RET_FLAG\"", "BPFISD::CALL", "\"BPFISD::CALL\"", "BPFISD::SELECT_CC", "\"BPFISD::SELECT_CC\"", "BPFISD::BR_CC", "\"BPFISD::BR_CC\"", "BPFISD::Wrapper", "\"BPFISD::Wrapper\"" ]

[]

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

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

[ "Mandarin", "MD::GenericRegsRegClass", "MD::STORErr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getPrefLoopAlignment", "(", "MachineLoop", "*", "ML", ")", "const", "{", "switch", "(", "Subtarget", ".", "getDarwinDirective", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "DIR_970", ":", "case", "PPC", "::", "DIR_PWR4", ":", "case", "PPC", "::", "DIR_PWR5", ":", "case", "PPC", "::", "DIR_PWR5X", ":", "case", "PPC", "::", "DIR_PWR6", ":", "case", "PPC", "::", "DIR_PWR6X", ":", "case", "PPC", "::", "DIR_PWR7", ":", "case", "PPC", "::", "DIR_PWR8", ":", "{", "if", "(", "!", "ML", ")", "break", ";", "const", "PPCInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "LoopSize", "=", "0", ";", "for", "(", "auto", "I", "=", "ML", "->", "block_begin", "(", ")", ",", "IE", "=", "ML", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "J", "=", "(", "*", "I", ")", "->", "begin", "(", ")", ",", "JE", "=", "(", "*", "I", ")", "->", "end", "(", ")", ";", "J", "!=", "JE", ";", "++", "J", ")", "LoopSize", "+=", "TII", "->", "GetInstSizeInBytes", "(", "J", ")", ";", "if", "(", "LoopSize", ">", "16", "&&", "LoopSize", "<=", "32", ")", "return", "5", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getPrefLoopAlignment", "(", "ML", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "PowerPC", "PPC", "PPC::DIR_970", "PPC::DIR_PWR4", "PPC::DIR_PWR5", "PPC::DIR_PWR5X", "PPC::DIR_PWR6", "PPC::DIR_PWR6X", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC", "0", "16", "32", "5" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "DLX" ]

[]

[ "<s>", "static", "tree", "spu_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_args", ",", "f_skip", ";", "tree", "args", ",", "skip", ";", "HOST_WIDE_INT", "size", ",", "rsize", ";", "tree", "addr", ",", "tmp", ";", "bool", "pass_by_reference_p", ";", "f_args", "=", "TYPE_FIELDS", "(", "TREE_TYPE", "(", "va_list_type_node", ")", ")", ";", "f_skip", "=", "DECL_CHAIN", "(", "f_args", ")", ";", "valist", "=", "build_simple_mem_ref", "(", "valist", ")", ";", "args", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_args", ")", ",", "valist", ",", "f_args", ",", "NULL_TREE", ")", ";", "skip", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_skip", ")", ",", "valist", ",", "f_skip", ",", "NULL_TREE", ")", ";", "addr", "=", "create_tmp_var", "(", "ptr_type_node", ",", "\"va_arg\"", ")", ";", "pass_by_reference_p", "=", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ";", "if", "(", "pass_by_reference_p", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", "*", "UNITS_PER_WORD", ";", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "args", ")", ",", "rsize", ")", ";", "tmp", "=", "build2", "(", "TRUTH_AND_EXPR", ",", "boolean_type_node", ",", "build2", "(", "GT_EXPR", ",", "boolean_type_node", ",", "tmp", ",", "unshare_expr", "(", "skip", ")", ")", ",", "build2", "(", "LE_EXPR", ",", "boolean_type_node", ",", "unshare_expr", "(", "args", ")", ",", "unshare_expr", "(", "skip", ")", ")", ")", ";", "tmp", "=", "build3", "(", "COND_EXPR", ",", "ptr_type_node", ",", "tmp", ",", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "skip", ")", ",", "32", ")", ",", "unshare_expr", "(", "args", ")", ")", ";", "gimplify_assign", "(", "addr", ",", "tmp", ",", "pre_p", ")", ";", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "addr", ",", "rsize", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "addr", "=", "fold_convert", "(", "build_pointer_type_for_mode", "(", "type", ",", "ptr_mode", ",", "true", ")", ",", "addr", ")", ";", "if", "(", "pass_by_reference_p", ")", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Gimplify", "va_arg", "by", "updating", "the", "va_list", "structure", "VALIST", "as", "required", "to", "retrieve", "an", "argument", "of", "type", "TYPE", ",", "and", "returning", "that", "argument", ".", "ret", "=", "va_arg", "(", "VALIST", ",", "TYPE", ")", ";", "generates", "code", "equivalent", "to", ":", "paddedsize", "=", "(", "sizeof", "(", "TYPE", ")", "+", "15", ")", "&", "-16", ";", "if", "(", "VALIST.__args", "+", "paddedsize", ">", "VALIST.__skip", "&", "&", "VALIST.__args", "<", "=", "VALIST.__skip", ")", "addr", "=", "VALIST.__skip", "+", "32", ";", "else", "addr", "=", "VALIST.__args", ";", "VALIST.__args", "=", "addr", "+", "paddedsize", ";", "ret", "=", "*", "(", "TYPE", "*", ")", "addr", ";" ]

[ "spu", "\"va_arg\"", "1", "32" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_Hexagon", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "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", "(", "HexagonISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::OutputArg", "16", "Hexagon", "4", "1", "0", "1", "0", "HexagonISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "SDValue", "MMIXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "IsVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MMIX", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "MMIXISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "ISD::OutputArg", "\"VarArg not supported\"", "16", "MMIX", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "MMIXISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "aarch64_advsimd_valid_immediate", "(", "unsigned", "HOST_WIDE_INT", "val64", ",", "simd_immediate_info", "*", "info", ",", "enum", "simd_immediate_check", "which", ")", "{", "unsigned", "int", "val32", "=", "val64", "&", "0xffffffff", ";", "unsigned", "int", "val16", "=", "val64", "&", "0xffff", ";", "unsigned", "int", "val8", "=", "val64", "&", "0xff", ";", "if", "(", "val32", "==", "(", "val64", ">>", "32", ")", ")", "{", "if", "(", "(", "which", "&", "AARCH64_CHECK_ORR", ")", "!=", "0", "&&", "aarch64_advsimd_valid_immediate_hs", "(", "val32", ",", "info", ",", "which", ",", "simd_immediate_info", "::", "MOV", ")", ")", "return", "true", ";", "if", "(", "(", "which", "&", "AARCH64_CHECK_BIC", ")", "!=", "0", "&&", "aarch64_advsimd_valid_immediate_hs", "(", "~", "val32", ",", "info", ",", "which", ",", "simd_immediate_info", "::", "MVN", ")", ")", "return", "true", ";", "if", "(", "which", "==", "AARCH64_CHECK_MOV", "&&", "val16", "==", "(", "val32", ">>", "16", ")", "&&", "val8", "==", "(", "val16", ">>", "8", ")", ")", "{", "if", "(", "info", ")", "*", "info", "=", "simd_immediate_info", "(", "QImode", ",", "val8", ")", ";", "return", "true", ";", "}", "}", "if", "(", "which", "==", "AARCH64_CHECK_MOV", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "64", ";", "i", "+=", "8", ")", "{", "unsigned", "char", "byte", "=", "(", "val64", ">>", "i", ")", "&", "0xff", ";", "if", "(", "byte", "!=", "0", "&&", "byte", "!=", "0xff", ")", "break", ";", "}", "if", "(", "i", "==", "64", ")", "{", "if", "(", "info", ")", "*", "info", "=", "simd_immediate_info", "(", "DImode", ",", "val64", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "replicating", "VAL64", "is", "a", "valid", "immediate", "for", "the", "Advanced", "SIMD", "operation", "described", "by", "WHICH", ".", "If", "INFO", "is", "nonnull", ",", "use", "it", "to", "describe", "valid", "immediates", "." ]

[ "aarch64", "0xffffffff", "0xffff", "0xff", "32", "0", "0", "16", "8", "0", "64", "8", "0xff", "0", "0xff", "64" ]

[]

[ "<s>", "void", "expand_epilogue", "(", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ";", "size", "+=", "(", "current_function_outgoing_args_size", "?", "4", ":", "0", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "frame_pointer_rtx", ")", ";", "size", "=", "0", ";", "}", "else", "if", "(", "size", "+", "REG_SAVE_BYTES", ">", "255", ")", "{", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "size", ")", ")", ")", ";", "size", "=", "0", ";", "}", "if", "(", "size", "||", "regs_ever_live", "[", "2", "]", "||", "regs_ever_live", "[", "3", "]", "||", "regs_ever_live", "[", "6", "]", "||", "regs_ever_live", "[", "7", "]", "||", "regs_ever_live", "[", "14", "]", "||", "regs_ever_live", "[", "15", "]", "||", "regs_ever_live", "[", "16", "]", "||", "regs_ever_live", "[", "17", "]", "||", "frame_pointer_needed", ")", "emit_jump_insn", "(", "gen_return_internal_regs", "(", "GEN_INT", "(", "size", "+", "REG_SAVE_BYTES", ")", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_return_internal", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "epilogue", "into", "RTL", "." ]

[ "mn10300", "4", "0", "0", "255", "0", "2", "3", "6", "7", "14", "15", "16", "17" ]

[]

[ "<s>", "DFAPacketizer", "*", "HexagonInstrInfo", "::", "CreateTargetScheduleState", "(", "const", "TargetSubtargetInfo", "&", "STI", ")", "const", "{", "const", "InstrItineraryData", "*", "II", "=", "STI", ".", "getInstrItineraryData", "(", ")", ";", "return", "static_cast", "<", "const", "HexagonSubtarget", "&", ">", "(", "STI", ")", ".", "createDFAPacketizer", "(", "II", ")", ";", "}", "</s>" ]

[ "Create", "machine", "specific", "model", "for", "scheduling", "." ]

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

[]

[ "<s>", "const", "TeakInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "static", "const", "predefined_function_abi", "&", "aarch64_simd_abi", "(", "void", ")", "{", "predefined_function_abi", "&", "simd_abi", "=", "function_abis", "[", "ARM_PCS_SIMD", "]", ";", "if", "(", "!", "simd_abi", ".", "initialized_p", "(", ")", ")", "{", "HARD_REG_SET", "full_reg_clobbers", "=", "default_function_abi", ".", "full_reg_clobbers", "(", ")", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "FP_SIMD_SAVED_REGNUM_P", "(", "regno", ")", ")", "CLEAR_HARD_REG_BIT", "(", "full_reg_clobbers", ",", "regno", ")", ";", "simd_abi", ".", "initialize", "(", "ARM_PCS_SIMD", ",", "full_reg_clobbers", ")", ";", "}", "return", "simd_abi", ";", "}", "</s>" ]

[ "Return", "the", "descriptor", "of", "the", "SIMD", "ABI", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "ExtractVectorElements", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Args", ",", "unsigned", "Start", ",", "unsigned", "Count", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "for", "(", "unsigned", "i", "=", "Start", ",", "e", "=", "Start", "+", "Count", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Args", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SDLoc", "(", "Op", ")", ",", "VT", ".", "getVectorElementType", "(", ")", ",", "Op", ",", "DAG", ".", "getConstant", "(", "i", ",", "MVT", "::", "i32", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Append", "the", "extracted", "elements", "from", "Start", "to", "Count", "out", "of", "the", "vector", "Op", "in", "Args", "." ]

[ "R600", "ISD::EXTRACT_VECTOR_ELT", "MVT::i32" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "*", "TmpMBB", "=", "const_cast", "<", "MachineBasicBlock", "*", ">", "(", "&", "MBB", ")", ";", "const", "auto", "*", "RVFI", "=", "MBB", ".", "getParent", "(", ")", "->", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "RVFI", "->", "useSaveRestoreLibCalls", "(", ")", ")", "return", "true", ";", "RegScavenger", "RS", ";", "RS", ".", "enterBasicBlock", "(", "*", "TmpMBB", ")", ";", "return", "!", "RS", ".", "isRegUsed", "(", "RISCV", "::", "X5", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV::X5" ]

[]

[ "<s>", "void", "MCS51ShiftExpand", "::", "expand", "(", "BinaryOperator", "*", "BI", ")", "{", "auto", "&", "Ctx", "=", "BI", "->", "getContext", "(", ")", ";", "IRBuilder", "<", ">", "Builder", "(", "BI", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ";", "Type", "*", "Int8Ty", "=", "Type", "::", "getInt8Ty", "(", "Ctx", ")", ";", "Value", "*", "Int8Zero", "=", "ConstantInt", "::", "get", "(", "Int8Ty", ",", "0", ")", ";", "BasicBlock", "*", "BB", "=", "BI", "->", "getParent", "(", ")", ";", "Function", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "BasicBlock", "*", "EndBB", "=", "BB", "->", "splitBasicBlock", "(", "BI", ",", "\"shift.done\"", ")", ";", "BasicBlock", "*", "LoopBB", "=", "BasicBlock", "::", "Create", "(", "Ctx", ",", "\"shift.loop\"", ",", "F", ",", "EndBB", ")", ";", "Builder", ".", "SetInsertPoint", "(", "&", "BB", "->", "back", "(", ")", ")", ";", "Value", "*", "ShiftAmount", "=", "Builder", ".", "CreateTrunc", "(", "BI", "->", "getOperand", "(", "1", ")", ",", "Int8Ty", ")", ";", "Value", "*", "Cmp1", "=", "Builder", ".", "CreateICmpEQ", "(", "ShiftAmount", ",", "Int8Zero", ")", ";", "Builder", ".", "CreateCondBr", "(", "Cmp1", ",", "EndBB", ",", "LoopBB", ")", ";", "BB", "->", "back", "(", ")", ".", "eraseFromParent", "(", ")", ";", "Builder", ".", "SetInsertPoint", "(", "LoopBB", ")", ";", "PHINode", "*", "ShiftAmountPHI", "=", "Builder", ".", "CreatePHI", "(", "Int8Ty", ",", "2", ")", ";", "ShiftAmountPHI", "->", "addIncoming", "(", "ShiftAmount", ",", "BB", ")", ";", "PHINode", "*", "ValuePHI", "=", "Builder", ".", "CreatePHI", "(", "Int32Ty", ",", "2", ")", ";", "ValuePHI", "->", "addIncoming", "(", "BI", "->", "getOperand", "(", "0", ")", ",", "BB", ")", ";", "Value", "*", "ShiftAmountSub", "=", "Builder", ".", "CreateSub", "(", "ShiftAmountPHI", ",", "ConstantInt", "::", "get", "(", "Int8Ty", ",", "1", ")", ")", ";", "ShiftAmountPHI", "->", "addIncoming", "(", "ShiftAmountSub", ",", "LoopBB", ")", ";", "Value", "*", "ValueShifted", ";", "switch", "(", "BI", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Shl", ":", "ValueShifted", "=", "Builder", ".", "CreateShl", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "case", "Instruction", "::", "LShr", ":", "ValueShifted", "=", "Builder", ".", "CreateLShr", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "case", "Instruction", "::", "AShr", ":", "ValueShifted", "=", "Builder", ".", "CreateAShr", "(", "ValuePHI", ",", "ConstantInt", "::", "get", "(", "Int32Ty", ",", "1", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"asked to expand an instruction that is not a shift\"", ")", ";", "}", "ValuePHI", "->", "addIncoming", "(", "ValueShifted", ",", "LoopBB", ")", ";", "Value", "*", "Cmp2", "=", "Builder", ".", "CreateICmpEQ", "(", "ShiftAmountSub", ",", "Int8Zero", ")", ";", "Builder", ".", "CreateCondBr", "(", "Cmp2", ",", "EndBB", ",", "LoopBB", ")", ";", "Builder", ".", "SetInsertPoint", "(", "BI", ")", ";", "PHINode", "*", "Result", "=", "Builder", ".", "CreatePHI", "(", "Int32Ty", ",", "2", ")", ";", "Result", "->", "addIncoming", "(", "BI", "->", "getOperand", "(", "0", ")", ",", "BB", ")", ";", "Result", "->", "addIncoming", "(", "ValueShifted", ",", "LoopBB", ")", ";", "BI", "->", "replaceAllUsesWith", "(", "Result", ")", ";", "BI", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "expand", "-", "Expand", "a", "record", "into", "a", "set", "of", "elements", "if", "possible", "." ]

[ "MCS51", "MCS51", "0", "\"shift.done\"", "\"shift.loop\"", "1", "2", "2", "0", "1", "1", "1", "1", "\"asked to expand an instruction that is not a shift\"", "2", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AS", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "AS", "==", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "4", "*", "32", ")", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "{", "unsigned", "MaxPrivateBits", "=", "8", "*", "getSubtarget", "(", ")", "->", "getMaxPrivateElementSize", "(", ")", ";", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "MaxPrivateBits", ")", ";", "}", "else", "if", "(", "AS", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "{", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "2", "*", "32", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "if", "it", "'s", "reasonable", "to", "merge", "stores", "to", "MemVT", "size", "." ]

[ "AMDGPU", "SI", "AMDGPU", "AMDGPU", "4", "32", "AMDGPU", "8", "AMDGPU", "AMDGPU", "2", "32" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "spu_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "case", "HImode", ":", "case", "SImode", ":", "case", "SFmode", ":", "case", "DImode", ":", "case", "TImode", ":", "case", "DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "True", "if", "MODE", "is", "valid", "for", "the", "target", ".", "By", "``", "valid", "''", ",", "we", "mean", "able", "to", "be", "manipulated", "in", "non-trivial", "ways", ".", "In", "particular", ",", "this", "means", "all", "the", "arithmetic", "is", "supported", "." ]

[ "spu" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "lowerInterleavedLoad", "(", "LoadInst", "*", "LI", ",", "ArrayRef", "<", "ShuffleVectorInst", "*", ">", "Shuffles", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Factor", ")", "const", "{", "assert", "(", "Factor", ">=", "2", "&&", "Factor", "<=", "getMaxSupportedInterleaveFactor", "(", ")", "&&", "\"Invalid interleave factor\"", ")", ";", "assert", "(", "!", "Shuffles", ".", "empty", "(", ")", "&&", "\"Empty shufflevector input\"", ")", ";", "assert", "(", "Shuffles", ".", "size", "(", ")", "==", "Indices", ".", "size", "(", ")", "&&", "\"Unmatched number of shufflevectors and indices\"", ")", ";", "VectorType", "*", "VecTy", "=", "Shuffles", "[", "0", "]", "->", "getType", "(", ")", ";", "Type", "*", "EltTy", "=", "VecTy", "->", "getVectorElementType", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "LI", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "unsigned", "VecSize", "=", "DL", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", ";", "bool", "EltIs64Bits", "=", "DL", ".", "getTypeAllocSizeInBits", "(", "EltTy", ")", "==", "64", ";", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "(", "VecSize", "!=", "64", "&&", "VecSize", "!=", "128", ")", "||", "EltIs64Bits", ")", "return", "false", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "VecTy", "=", "VectorType", "::", "get", "(", "DL", ".", "getIntPtrType", "(", "EltTy", ")", ",", "VecTy", "->", "getVectorNumElements", "(", ")", ")", ";", "static", "const", "Intrinsic", "::", "ID", "LoadInts", "[", "3", "]", "=", "{", "Intrinsic", "::", "arm_neon_vld2", ",", "Intrinsic", "::", "arm_neon_vld3", ",", "Intrinsic", "::", "arm_neon_vld4", "}", ";", "IRBuilder", "<", ">", "Builder", "(", "LI", ")", ";", "SmallVector", "<", "Value", "*", ",", "2", ">", "Ops", ";", "Type", "*", "Int8Ptr", "=", "Builder", ".", "getInt8PtrTy", "(", "LI", "->", "getPointerAddressSpace", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "LI", "->", "getPointerOperand", "(", ")", ",", "Int8Ptr", ")", ")", ";", "Ops", ".", "push_back", "(", "Builder", ".", "getInt32", "(", "LI", "->", "getAlignment", "(", ")", ")", ")", ";", "Type", "*", "Tys", "[", "]", "=", "{", "VecTy", ",", "Int8Ptr", "}", ";", "Function", "*", "VldnFunc", "=", "Intrinsic", "::", "getDeclaration", "(", "LI", "->", "getModule", "(", ")", ",", "LoadInts", "[", "Factor", "-", "2", "]", ",", "Tys", ")", ";", "CallInst", "*", "VldN", "=", "Builder", ".", "CreateCall", "(", "VldnFunc", ",", "Ops", ",", "\"vldN\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Shuffles", ".", "size", "(", ")", ";", "i", "++", ")", "{", "ShuffleVectorInst", "*", "SV", "=", "Shuffles", "[", "i", "]", ";", "unsigned", "Index", "=", "Indices", "[", "i", "]", ";", "Value", "*", "SubVec", "=", "Builder", ".", "CreateExtractValue", "(", "VldN", ",", "Index", ")", ";", "if", "(", "EltTy", "->", "isPointerTy", "(", ")", ")", "SubVec", "=", "Builder", ".", "CreateIntToPtr", "(", "SubVec", ",", "SV", "->", "getType", "(", ")", ")", ";", "SV", "->", "replaceAllUsesWith", "(", "SubVec", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Lower", "interleaved", "load", "(", "s", ")", "into", "target", "specific", "instructions/intrinsics", "." ]

[ "ARM", "ARM", "2", "\"Invalid interleave factor\"", "\"Empty shufflevector input\"", "\"Unmatched number of shufflevectors and indices\"", "0", "64", "64", "128", "Intrinsic::ID", "3", "Intrinsic::arm_neon_vld2", "Intrinsic::arm_neon_vld3", "Intrinsic::arm_neon_vld4", "2", "Intrinsic::getDeclaration", "2", "\"vldN\"", "0" ]

[]