Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "reg_class_t", "mmix_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "return", "GET_CODE", "(", "x", ")", "==", "MOD", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", "?", "REMAINDER_REG", ":", "rclass", ";", "}", "</s>" ]

[ "PREFERRED_RELOAD_CLASS", ".", "We", "need", "to", "extend", "the", "reload", "class", "of", "REMAINDER_REG", "and", "HIMULT_REG", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "const", "char", "*", "nvptx_name_replacement", "(", "const", "char", "*", "name", ")", "{", "if", "(", "strcmp", "(", "name", ",", "\"call\"", ")", "==", "0", ")", "return", "\"__nvptx_call\"", ";", "if", "(", "strcmp", "(", "name", ",", "\"malloc\"", ")", "==", "0", ")", "return", "\"__nvptx_malloc\"", ";", "if", "(", "strcmp", "(", "name", ",", "\"free\"", ")", "==", "0", ")", "return", "\"__nvptx_free\"", ";", "if", "(", "strcmp", "(", "name", ",", "\"realloc\"", ")", "==", "0", ")", "return", "\"__nvptx_realloc\"", ";", "return", "name", ";", "}", "</s>" ]

[ "Check", "NAME", "for", "special", "function", "names", "and", "redirect", "them", "by", "returning", "a", "replacement", ".", "This", "applies", "to", "malloc", ",", "free", "and", "realloc", ",", "for", "which", "we", "want", "to", "use", "libgcc", "wrappers", ",", "and", "call", ",", "which", "triggers", "a", "bug", "in", "ptxas", "." ]

[ "nvptx", "\"call\"", "0", "\"__nvptx_call\"", "\"malloc\"", "0", "\"__nvptx_malloc\"", "\"free\"", "0", "\"__nvptx_free\"", "\"realloc\"", "0", "\"__nvptx_realloc\"" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_warp_bcast", "(", "rtx", "reg", ")", "{", "return", "nvptx_gen_shuffle", "(", "reg", ",", "reg", ",", "const0_rtx", ",", "SHUFFLE_IDX", ")", ";", "}", "</s>" ]

[ "Generate", "an", "instruction", "or", "sequence", "to", "broadcast", "register", "REG", "across", "the", "vectors", "of", "a", "single", "warp", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MCID", ".", "isBranch", "(", ")", "&&", "!", "MCID", ".", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MCID", ".", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "void", "aarch64_emit_sve_ptrue_op_cc", "(", "rtx", "target", ",", "rtx", "ptrue", ",", "rtx", "op", ")", "{", "rtx", "unspec", "=", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "target", ")", ",", "gen_rtvec", "(", "2", ",", "ptrue", ",", "op", ")", ",", "UNSPEC_MERGE_PTRUE", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_set_clobber_cc", "(", "target", ",", "unspec", ")", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "copy_rtx", "(", "op", ")", ")", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "also", "clobber", "the", "condition", "codes", "." ]

[ "aarch64", "2" ]

[]

[ "<s>", "rtx", "ix86_rewrite_tls_address", "(", "rtx", "pattern", ")", "{", "pattern", "=", "copy_insn", "(", "pattern", ")", ";", "ix86_rewrite_tls_address_1", "(", "&", "pattern", ")", ";", "return", "pattern", ";", "}", "</s>" ]

[ "Rewrite", "instruction", "pattern", "involvning", "TLS", "address", "so", "that", "it", "refers", "to", "a", "default", "TLS", "address", "space", "." ]

[ "i386" ]

[]

[ "<s>", "static", "unsigned", "int", "sparc_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "return", "(", "(", "TARGET_ARCH64", "&&", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", "==", "128", "||", "(", "type", "&&", "TYPE_ALIGN", "(", "type", ")", "==", "128", ")", ")", ")", "?", "128", ":", "PARM_BOUNDARY", ")", ";", "}", "</s>" ]

[ "For", "sparc64", ",", "objects", "requiring", "16", "byte", "alignment", "are", "passed", "that", "way", "." ]

[ "sparc", "128", "128", "128" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Indirect Branch Tracking\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Indirect Branch Tracking\"" ]

[]

[ "<s>", "bool", "SIFixVGPRCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY", ":", "if", "(", "TII", "->", "isVGPRCopy", "(", "MI", ")", "&&", "!", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "MI", ".", "addOperand", "(", "MF", ",", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "EXEC", ",", "false", ",", "true", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Add exec use to \"", "<<", "MI", ")", ";", "Changed", "=", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::EXEC", "\"Add exec use to \"" ]

[]

[ "<s>", "bool", "MSP430InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Br", "||", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Bm", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "JMP", "||", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Bi", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "I", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "JCC", "&&", "\"Invalid conditional branch\"", ")", ";", "MSP430CC", "::", "CondCodes", "BranchCode", "=", "static_cast", "<", "MSP430CC", "::", "CondCodes", ">", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "BranchCode", "==", "MSP430CC", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", ")", ";", "assert", "(", "TBB", ")", ";", "if", "(", "TBB", "!=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", "return", "true", ";", "MSP430CC", "::", "CondCodes", "OldBranchCode", "=", "(", "MSP430CC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "OldBranchCode", "==", "BranchCode", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::Br", "MSP430::Bm", "MSP430::JMP", "MSP430::Bi", "0", "0", "0", "MSP430::JCC", "\"Invalid conditional branch\"", "MSP430CC::CondCodes", "MSP430CC::CondCodes", "1", "MSP430CC::COND_INVALID", "0", "1", "0", "MSP430CC::CondCodes", "MSP430CC::CondCodes", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "createPHIDestinationCopy", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "LastPHIIt", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "Src", ",", "Register", "Dst", ")", "const", "{", "auto", "Cur", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "Cur", "!=", "MBB", ".", "end", "(", ")", ")", "do", "{", "if", "(", "!", "Cur", "->", "isPHI", "(", ")", "&&", "Cur", "->", "readsRegister", "(", "Dst", ")", ")", "return", "BuildMI", "(", "MBB", ",", "Cur", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "Dst", ")", ".", "addReg", "(", "Src", ")", ";", "++", "Cur", ";", "}", "while", "(", "Cur", "!=", "MBB", ".", "end", "(", ")", "&&", "Cur", "!=", "LastPHIIt", ")", ";", "return", "TargetInstrInfo", "::", "createPHIDestinationCopy", "(", "MBB", ",", "LastPHIIt", ",", "DL", ",", "Src", ",", "Dst", ")", ";", "}", "</s>" ]

[ "During", "PHI", "eleimination", "lets", "target", "to", "make", "necessary", "checks", "and", "insert", "the", "copy", "to", "the", "PHI", "destination", "register", "in", "a", "target", "specific", "manner", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "getAddNoCarry", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "DestReg", ",", "RegScavenger", "&", "RS", ")", "const", "{", "if", "(", "ST", ".", "hasAddNoCarry", "(", ")", ")", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_U32_e64", ")", ",", "DestReg", ")", ";", "Register", "UnusedCarry", "=", "RS", ".", "scavengeRegister", "(", "RI", ".", "getBoolRC", "(", ")", ",", "I", ",", "0", ",", "false", ")", ";", "if", "(", "!", "UnusedCarry", ".", "isValid", "(", ")", ")", "return", "MachineInstrBuilder", "(", ")", ";", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "DestReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ";", "}", "</s>" ]

[ "Return", "a", "partially", "built", "integer", "add", "instruction", "without", "carry", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ADD_U32_e64", "0", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", "||", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "{", "Size", "=", "4", ";", "assert", "(", "MRI", ".", "getType", "(", "ValVReg", ")", ".", "isScalar", "(", ")", "&&", "\"Only scalars supported atm\"", ")", ";", "auto", "LoadVReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "buildLoad", "(", "LoadVReg", ",", "Addr", ",", "Size", ",", "1", ",", "MPO", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "LoadVReg", ")", ";", "}", "else", "{", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "Size", ",", "1", ",", "MPO", ")", ";", "}", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "4", "\"Only scalars supported atm\"", "32", "1", "1" ]

[]

[ "<s>", "static", "bool", "write_as_kernel", "(", "tree", "attrs", ")", "{", "return", "(", "lookup_attribute", "(", "\"kernel\"", ",", "attrs", ")", "!=", "NULL_TREE", "||", "(", "lookup_attribute", "(", "\"omp target entrypoint\"", ",", "attrs", ")", "!=", "NULL_TREE", "&&", "lookup_attribute", "(", "\"oacc function\"", ",", "attrs", ")", "!=", "NULL_TREE", ")", ")", ";", "}", "</s>" ]

[ "Look", "for", "attributes", "in", "ATTRS", "that", "would", "indicate", "we", "must", "write", "a", "function", "as", "a", ".entry", "kernel", "rather", "than", "a", ".func", ".", "Return", "true", "if", "one", "is", "found", "." ]

[ "nvptx", "\"kernel\"", "\"omp target entrypoint\"", "\"oacc function\"" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "unsigned", "FP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "FP_64", ":", "Mips", "::", "FP", ";", "unsigned", "ZERO", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "ZERO_64", ":", "Mips", "::", "ZERO", ";", "unsigned", "ADDu", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "DADDu", ":", "Mips", "::", "ADDu", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBBI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MFI", "->", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ";", "++", "i", ")", "--", "I", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDu", ")", ",", "SP", ")", ".", "addReg", "(", "FP", ")", ".", "addReg", "(", "ZERO", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::SP_64", "Mips::SP", "Mips::FP_64", "Mips::FP", "Mips::ZERO_64", "Mips::ZERO", "Mips::DADDu", "Mips::ADDu", "0" ]

[]

[ "<s>", "int", "NVPTXFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FrameReg", "=", "NVPTX", "::", "VRDepot", ";", "return", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "NVPTX", "NVPTX", "NVPTX::VRDepot" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_vec_init_builtin", "(", "tree", "type", ",", "tree", "arglist", ",", "rtx", "target", ")", "{", "enum", "machine_mode", "tmode", "=", "TYPE_MODE", "(", "type", ")", ";", "enum", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "tmode", ")", ";", "int", "i", ",", "n_elt", "=", "GET_MODE_NUNITS", "(", "tmode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "n_elt", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "tmode", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elt", ";", "++", "i", ",", "arglist", "=", "TREE_CHAIN", "(", "arglist", ")", ")", "{", "rtx", "x", "=", "expand_expr", "(", "TREE_VALUE", "(", "arglist", ")", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_lowpart", "(", "inner_mode", ",", "x", ")", ";", "}", "gcc_assert", "(", "arglist", "==", "NULL", ")", ";", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "ix86_expand_vector_init", "(", "true", ",", "target", ",", "gen_rtx_PARALLEL", "(", "tmode", ",", "v", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_builtin", ".", "These", "builtins", "are", "a", "wrapper", "around", "ix86_expand_vector_init", ".", "We", "DO", "have", "language-level", "syntax", "for", "this", ",", "in", "the", "form", "of", "(", "type", ")", "{", "init-list", "}", ".", "Except", "that", "since", "we", "ca", "n't", "place", "emms", "instructions", "from", "inside", "the", "compiler", ",", "we", "ca", "n't", "allow", "the", "use", "of", "MMX", "registers", "unless", "the", "user", "explicitly", "asks", "for", "it", ".", "So", "we", "do", "*", "not", "*", "define", "vec_set/vec_extract/vec_init", "patterns", "for", "MMX", "modes", "in", "mmx.md", ".", "Instead", "we", "have", "builtins", "invoked", "by", "mmintrin.h", "that", "gives", "us", "license", "to", "emit", "these", "sorts", "of", "instructions", "." ]

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

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "LdSt", ".", "mayLoadOrStore", "(", ")", "&&", "\"Expected a memory operation.\"", ")", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "if", "(", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", ")", "{", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "(", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "return", "false", ";", "unsigned", "Scale", "=", "0", ";", "int64_t", "Dummy1", ",", "Dummy2", ";", "if", "(", "!", "getMemOpInfo", "(", "LdSt", ".", "getOpcode", "(", ")", ",", "Scale", ",", "Width", ",", "Dummy1", ",", "Dummy2", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "*", "Scale", ";", "}", "else", "{", "assert", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", "&&", "\"invalid number of operands\"", ")", ";", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "2", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "*", "Scale", ";", "}", "assert", "(", "(", "BaseOp", "->", "isReg", "(", ")", "||", "BaseOp", "->", "isFI", "(", ")", ")", "&&", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register or frame index.\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "AArch64", "AArch64", "\"Expected a memory operation.\"", "3", "1", "1", "2", "4", "1", "2", "2", "3", "0", "3", "1", "2", "4", "\"invalid number of operands\"", "2", "3", "\"getMemOperandWithOffset only supports base \"", "\"operands of type register or frame index.\"" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "OS", ".", "flush", "(", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "mips_sim_wait_regs_1", "(", "rtx", "*", "x", ",", "void", "*", "data", ")", "{", "for_each_rtx", "(", "x", ",", "mips_sim_wait_regs_2", ",", "data", ")", ";", "}", "</s>" ]

[ "Call", "mips_sim_wait_regs_2", "(", "R", ",", "DATA", ")", "for", "each", "register", "R", "mentioned", "in", "*", "X", "." ]

[ "mips" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "0", "MVT::i8", "AVR::STDPtrQRr", "MVT::i16", "AVR::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "bool", "Z80ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ".", "addKillFlags", "(", "&", "getAnalysis", "<", "VirtRegMap", ">", "(", ")", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

[ "<s>", "yaml", "::", "MachineFunctionInfo", "*", "GCNTargetMachine", "::", "convertFuncInfoToYAML", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "new", "yaml", "::", "SIMachineFunctionInfo", "(", "*", "MFI", ",", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "initialize", "an", "instance", "of", "the", "YAML", "representation", "of", "the", "MachineFunctionInfo", "." ]

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

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "SafeInLoadDelaySlot", "(", "const", "MachineInstr", "&", "MIInSlot", ",", "const", "MachineInstr", "&", "LoadMI", ")", "const", "{", "if", "(", "MIInSlot", ".", "isInlineAsm", "(", ")", ")", "return", "false", ";", "return", "!", "llvm", "::", "any_of", "(", "LoadMI", ".", "defs", "(", ")", ",", "[", "&", "]", "(", "const", "MachineOperand", "&", "Op", ")", "{", "return", "Op", ".", "isReg", "(", ")", "&&", "MIInSlot", ".", "readsRegister", "(", "Op", ".", "getReg", "(", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Predicate", "to", "determine", "if", "an", "instruction", "can", "go", "in", "a", "load", "delay", "slot", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "aarch64_process_components", "(", "sbitmap", "components", ",", "bool", "prologue_p", ")", "{", "rtx", "ptr_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", ")", ";", "unsigned", "last_regno", "=", "SBITMAP_SIZE", "(", "components", ")", ";", "unsigned", "regno", "=", "aarch64_get_next_set_bit", "(", "components", ",", "R0_REGNUM", ")", ";", "rtx_insn", "*", "insn", "=", "NULL", ";", "while", "(", "regno", "!=", "last_regno", ")", "{", "machine_mode", "mode", "=", "GP_REGNUM_P", "(", "regno", ")", "?", "DImode", ":", "DFmode", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "HOST_WIDE_INT", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "if", "(", "!", "frame_pointer_needed", ")", "offset", "+=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "-", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", ";", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "ptr_reg", ",", "offset", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "mode", ",", "addr", ")", ";", "rtx", "set", "=", "prologue_p", "?", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ":", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "unsigned", "regno2", "=", "aarch64_get_next_set_bit", "(", "components", ",", "regno", "+", "1", ")", ";", "if", "(", "regno2", "==", "last_regno", ")", "{", "insn", "=", "emit_insn", "(", "set", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "prologue_p", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "copy_rtx", "(", "set", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "break", ";", "}", "HOST_WIDE_INT", "offset2", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "if", "(", "!", "satisfies_constraint_Ump", "(", "mem", ")", "||", "GP_REGNUM_P", "(", "regno", ")", "!=", "GP_REGNUM_P", "(", "regno2", ")", "||", "(", "offset2", "-", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ")", "!=", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "insn", "=", "emit_insn", "(", "set", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "prologue_p", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "copy_rtx", "(", "set", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "regno", "=", "regno2", ";", "continue", ";", "}", "rtx", "reg2", "=", "gen_rtx_REG", "(", "mode", ",", "regno2", ")", ";", "if", "(", "!", "frame_pointer_needed", ")", "offset2", "+=", "cfun", "->", "machine", "->", "frame", ".", "frame_size", "-", "cfun", "->", "machine", "->", "frame", ".", "hard_fp_offset", ";", "rtx", "addr2", "=", "plus_constant", "(", "Pmode", ",", "ptr_reg", ",", "offset2", ")", ";", "rtx", "mem2", "=", "gen_frame_mem", "(", "mode", ",", "addr2", ")", ";", "rtx", "set2", "=", "prologue_p", "?", "gen_rtx_SET", "(", "mem2", ",", "reg2", ")", ":", "gen_rtx_SET", "(", "reg2", ",", "mem2", ")", ";", "if", "(", "prologue_p", ")", "insn", "=", "emit_insn", "(", "aarch64_gen_store_pair", "(", "mode", ",", "mem", ",", "reg", ",", "mem2", ",", "reg2", ")", ")", ";", "else", "insn", "=", "emit_insn", "(", "aarch64_gen_load_pair", "(", "mode", ",", "reg", ",", "mem", ",", "reg2", ",", "mem2", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "prologue_p", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "set2", ")", ";", "}", "else", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg2", ")", ";", "}", "regno", "=", "aarch64_get_next_set_bit", "(", "components", ",", "regno2", "+", "1", ")", ";", "}", "}", "</s>" ]

[ "Do", "the", "work", "for", "aarch64_emit_prologue_components", "and", "aarch64_emit_epilogue_components", ".", "COMPONENTS", "is", "the", "bitmap", "of", "registers", "to", "save/restore", ",", "PROLOGUE_P", "indicates", "whether", "to", "emit", "the", "prologue", "sequence", "for", "these", "components", "or", "the", "epilogue", "sequence", ".", "That", "is", ",", "it", "determines", "whether", "we", "should", "emit", "stores", "or", "loads", "and", "what", "kind", "of", "CFA", "notes", "to", "attach", "to", "the", "insns", ".", "Otherwise", "the", "logic", "for", "the", "two", "sequences", "is", "very", "similar", "." ]

[ "aarch64", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "machine_mode", "sparc_promote_function_mode", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", ",", "const_tree", ",", "int", ")", "{", "if", "(", "type", "&&", "POINTER_TYPE_P", "(", "type", ")", ")", "{", "*", "punsignedp", "=", "POINTERS_EXTEND_UNSIGNED", ";", "return", "Pmode", ";", "}", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "return", "word_mode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Handle", "promotion", "of", "pointer", "and", "integer", "arguments", "." ]

[ "sparc" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "{", "addPass", "(", "createHexagonHardwareLoops", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "erasingInstr", "(", "MachineInstr", "&", "MI", ")", "override", "{", "}", "</s>" ]

[ "An", "instruction", "is", "about", "to", "be", "erased", "." ]

[ "Mips" ]

[]

[ "<s>", "const", "char", "*", "fpuv3_output_move", "(", "rtx", "*", "operands", ")", "{", "rtx", "reg", ",", "mem", ",", "addr", ",", "ops", "[", "2", "]", ";", "bool", "isload", "=", "REG_P", "(", "operands", "[", "0", "]", ")", ";", "const", "char", "*", "templ", "=", "\"f%s%s.%s\\t%%0, %%1\"", ";", "char", "buff", "[", "50", "]", ";", "machine_mode", "mode", ";", "reg", "=", "operands", "[", "isload", "?", "0", ":", "1", "]", ";", "mem", "=", "operands", "[", "isload", "?", "1", ":", "0", "]", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "gcc_assert", "(", "CSKY_VREG_P", "(", "REGNO", "(", "reg", ")", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "const", "char", "*", "type", "=", "mode", "==", "DFmode", "?", "\"64\"", ":", "mode", "==", "SFmode", "?", "\"32\"", ":", "mode", "==", "HFmode", "?", "\"16\"", ":", "NULL", ";", "gcc_assert", "(", "type", "!=", "NULL", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "struct", "csky_address", "caddr", ";", "decompose_csky_address", "(", "addr", ",", "&", "caddr", ")", ";", "ops", "[", "0", "]", "=", "reg", ";", "ops", "[", "1", "]", "=", "mem", ";", "sprintf", "(", "buff", ",", "templ", ",", "isload", "?", "\"ld\"", ":", "\"st\"", ",", "caddr", ".", "index", "?", "\"r\"", ":", "\"\"", ",", "type", ")", ";", "output_asm_insn", "(", "buff", ",", "ops", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "float", "point", "load/store", "instructions", "for", "fpuv3", "." ]

[ "csky", "2", "0", "\"f%s%s.%s\\t%%0, %%1\"", "50", "0", "1", "1", "0", "\"64\"", "\"32\"", "\"16\"", "0", "0", "1", "\"ld\"", "\"st\"", "\"r\"", "\"\"", "\"\"" ]

[]

[ "<s>", "DecodeStatus", "PPCDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Inst", "=", "IsLittleEndian", "?", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ":", "support", "::", "endian", "::", "read32be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureQPX", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableQPX32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "else", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureSPE", "]", ")", "{", "DecodeStatus", "result", "=", "decodeInstruction", "(", "DecoderTableSPE32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "result", ";", "}", "return", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "4", "4", "0", "support::endian", "support::endian", "PPC::FeatureQPX", "PPC::FeatureSPE" ]

[]

[ "<s>", "static", "rtx", "frv_emit_comparison", "(", "enum", "rtx_code", "test", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "enum", "machine_mode", "cc_mode", ";", "rtx", "cc_reg", ";", "if", "(", "GET_MODE", "(", "op0", ")", "==", "CC_FPmode", "&&", "GET_CODE", "(", "op1", ")", "!=", "REG", ")", "op1", "=", "force_reg", "(", "GET_MODE", "(", "op0", ")", ",", "op1", ")", ";", "cc_mode", "=", "SELECT_CC_MODE", "(", "test", ",", "op0", ",", "op1", ")", ";", "cc_reg", "=", "(", "(", "TARGET_ALLOC_CC", ")", "?", "gen_reg_rtx", "(", "cc_mode", ")", ":", "gen_rtx_REG", "(", "cc_mode", ",", "(", "cc_mode", "==", "CC_FPmode", ")", "?", "FCC_FIRST", ":", "ICC_FIRST", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "cc_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "Emit", "the", "appropriate", "code", "to", "do", "a", "comparison", ",", "returning", "the", "register", "the", "comparison", "was", "done", "it", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastLowerCall", "(", "CallLoweringInfo", "&", "CLI", ")", "{", "CallingConv", "::", "ID", "CC", "=", "CLI", ".", "CallConv", ";", "bool", "IsTailCall", "=", "CLI", ".", "IsTailCall", ";", "bool", "IsVarArg", "=", "CLI", ".", "IsVarArg", ";", "const", "Value", "*", "Callee", "=", "CLI", ".", "Callee", ";", "MCSymbol", "*", "Symbol", "=", "CLI", ".", "Symbol", ";", "if", "(", "CC", "==", "CallingConv", "::", "Fast", ")", "return", "false", ";", "if", "(", "IsTailCall", ")", "return", "false", ";", "if", "(", "IsVarArg", ")", "return", "false", ";", "MVT", "RetVT", ";", "if", "(", "CLI", ".", "RetTy", "->", "isVoidTy", "(", ")", ")", "RetVT", "=", "MVT", "::", "isVoid", ";", "else", "if", "(", "!", "isTypeSupported", "(", "CLI", ".", "RetTy", ",", "RetVT", ")", ")", "return", "false", ";", "for", "(", "auto", "Flag", ":", "CLI", ".", "OutFlags", ")", "if", "(", "Flag", ".", "isInReg", "(", ")", "||", "Flag", ".", "isSRet", "(", ")", "||", "Flag", ".", "isNest", "(", ")", "||", "Flag", ".", "isByVal", "(", ")", ")", "return", "false", ";", "SmallVector", "<", "MVT", ",", "16", ">", "OutVTs", ";", "OutVTs", ".", "reserve", "(", "CLI", ".", "OutVals", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "*", "Val", ":", "CLI", ".", "OutVals", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isTypeLegal", "(", "Val", "->", "getType", "(", ")", ",", "VT", ")", "&&", "!", "(", "VT", "==", "MVT", "::", "i1", "||", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", ")", ")", "return", "false", ";", "if", "(", "VT", ".", "isVector", "(", ")", "||", "VT", ".", "getSizeInBits", "(", ")", ">", "64", ")", "return", "false", ";", "OutVTs", ".", "push_back", "(", "VT", ")", ";", "}", "Address", "Addr", ";", "if", "(", "!", "computeCallAddress", "(", "Callee", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "NumBytes", ";", "if", "(", "!", "processCallArgs", "(", "CLI", ",", "OutVTs", ",", "NumBytes", ")", ")", "return", "false", ";", "if", "(", "!", "Addr", ".", "getGlobalValue", "(", ")", ")", "return", "false", ";", "unsigned", "DestAddress", ";", "if", "(", "Symbol", ")", "DestAddress", "=", "materializeExternalCallSym", "(", "Symbol", ")", ";", "else", "DestAddress", "=", "materializeGV", "(", "Addr", ".", "getGlobalValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "emitInst", "(", "TargetOpcode", "::", "COPY", ",", "Mips", "::", "T9", ")", ".", "addReg", "(", "DestAddress", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Mips", "::", "JALR", ")", ",", "Mips", "::", "RA", ")", ".", "addReg", "(", "Mips", "::", "T9", ")", ";", "for", "(", "auto", "Reg", ":", "CLI", ".", "OutRegs", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addRegMask", "(", "TRI", ".", "getCallPreservedMask", "(", "*", "FuncInfo", ".", "MF", ",", "CC", ")", ")", ";", "CLI", ".", "Call", "=", "MIB", ";", "if", "(", "EmitJalrReloc", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "{", "if", "(", "Symbol", ")", "MIB", ".", "addSym", "(", "Symbol", ",", "MipsII", "::", "MO_JALR", ")", ";", "else", "MIB", ".", "addSym", "(", "FuncInfo", ".", "MF", "->", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Addr", ".", "getGlobalValue", "(", ")", "->", "getName", "(", ")", ")", ",", "MipsII", "::", "MO_JALR", ")", ";", "}", "return", "finishCall", "(", "CLI", ",", "RetVT", ",", "NumBytes", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "do", "target-", "specific", "call", "lowering", "." ]

[ "Mips", "Mips", "MVT::isVoid", "16", "MVT::i1", "MVT::i8", "MVT::i16", "64", "MVT::i32", "Mips::T9", "Mips::JALR", "Mips::RA", "Mips::T9", "Mips", "MipsII::MO_JALR", "MipsII::MO_JALR" ]

[]

[ "<s>", "static", "void", "nios2_deregister_custom_code", "(", "unsigned", "int", "N", ")", "{", "if", "(", "N", "<=", "255", ")", "{", "custom_code_status", "[", "N", "]", "=", "CCS_UNUSED", ";", "custom_code_index", "[", "N", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "Mark", "a", "custom", "code", "as", "not", "in", "use", "." ]

[ "nios2", "255", "0" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "AArch64", "AArch64", "AArch64", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-tls\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lanai Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Lanai", "\"Lanai Delay Slot Filler\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "32", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "==", "32", "&&", "\"Unsupported location size\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "32", "\"Unsupported value size\"", "32", "\"Unsupported location size\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "canMergeStoresTo", "(", "unsigned", "AddressSpace", ",", "EVT", "MemVT", ",", "const", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "NoFloat", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "if", "(", "NoFloat", ")", "{", "unsigned", "MaxIntSize", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "return", "(", "MemVT", ".", "getSizeInBits", "(", ")", "<=", "MaxIntSize", ")", ";", "}", "if", "(", "MemVT", ".", "getSizeInBits", "(", ")", ">", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "int", "flags_from_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_CC_ZSmode", ":", "return", "CC_FLAG_S", "|", "CC_FLAG_Z", ";", "case", "E_CC_ZSOmode", ":", "return", "CC_FLAG_S", "|", "CC_FLAG_Z", "|", "CC_FLAG_O", ";", "case", "E_CC_ZSCmode", ":", "return", "CC_FLAG_S", "|", "CC_FLAG_Z", "|", "CC_FLAG_C", ";", "case", "E_CCmode", ":", "return", "CC_FLAG_S", "|", "CC_FLAG_Z", "|", "CC_FLAG_O", "|", "CC_FLAG_C", ";", "case", "E_CC_Fmode", ":", "return", "CC_FLAG_FP", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Convert", "a", "CC_MODE", "to", "the", "set", "of", "flags", "that", "it", "represents", "." ]

[ "rx" ]

[]

[ "<s>", "void", "LanaiInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annotation", ",", "const", "MCSubtargetInfo", "&", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "printAlias", "(", "MI", ",", "OS", ")", "&&", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annotation", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "false", ";", "int64_t", "Val", "=", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "Val", "==", "0", "||", "AArch64_AM", "::", "isLogicalImmediate", "(", "Val", ",", "BitSize", ")", ")", "return", "true", ";", "if", "(", "(", "int64_t", ")", "Val", "<", "0", ")", "Val", "=", "~", "Val", ";", "if", "(", "BitSize", "==", "32", ")", "Val", "&=", "(", "1LL", "<<", "32", ")", "-", "1", ";", "unsigned", "LZ", "=", "countLeadingZeros", "(", "(", "uint64_t", ")", "Val", ")", ";", "unsigned", "Shift", "=", "(", "63", "-", "LZ", ")", "/", "16", ";", "return", "(", "Shift", "<", "3", ")", "?", "true", ":", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "0", "AArch64_AM::isLogicalImmediate", "0", "32", "1LL", "32", "1", "63", "16", "3" ]

[]

[ "<s>", "StringRef", "AArch64MCExpr", "::", "getVariantKindName", "(", ")", "const", "{", "switch", "(", "static_cast", "<", "uint32_t", ">", "(", "getKind", "(", ")", ")", ")", "{", "case", "VK_CALL", ":", "return", "\"\"", ";", "case", "VK_LO12", ":", "return", "\":lo12:\"", ";", "case", "VK_ABS_G3", ":", "return", "\":abs_g3:\"", ";", "case", "VK_ABS_G2", ":", "return", "\":abs_g2:\"", ";", "case", "VK_ABS_G2_S", ":", "return", "\":abs_g2_s:\"", ";", "case", "VK_ABS_G2_NC", ":", "return", "\":abs_g2_nc:\"", ";", "case", "VK_ABS_G1", ":", "return", "\":abs_g1:\"", ";", "case", "VK_ABS_G1_S", ":", "return", "\":abs_g1_s:\"", ";", "case", "VK_ABS_G1_NC", ":", "return", "\":abs_g1_nc:\"", ";", "case", "VK_ABS_G0", ":", "return", "\":abs_g0:\"", ";", "case", "VK_ABS_G0_S", ":", "return", "\":abs_g0_s:\"", ";", "case", "VK_ABS_G0_NC", ":", "return", "\":abs_g0_nc:\"", ";", "case", "VK_PREL_G3", ":", "return", "\":prel_g3:\"", ";", "case", "VK_PREL_G2", ":", "return", "\":prel_g2:\"", ";", "case", "VK_PREL_G2_NC", ":", "return", "\":prel_g2_nc:\"", ";", "case", "VK_PREL_G1", ":", "return", "\":prel_g1:\"", ";", "case", "VK_PREL_G1_NC", ":", "return", "\":prel_g1_nc:\"", ";", "case", "VK_PREL_G0", ":", "return", "\":prel_g0:\"", ";", "case", "VK_PREL_G0_NC", ":", "return", "\":prel_g0_nc:\"", ";", "case", "VK_DTPREL_G2", ":", "return", "\":dtprel_g2:\"", ";", "case", "VK_DTPREL_G1", ":", "return", "\":dtprel_g1:\"", ";", "case", "VK_DTPREL_G1_NC", ":", "return", "\":dtprel_g1_nc:\"", ";", "case", "VK_DTPREL_G0", ":", "return", "\":dtprel_g0:\"", ";", "case", "VK_DTPREL_G0_NC", ":", "return", "\":dtprel_g0_nc:\"", ";", "case", "VK_DTPREL_HI12", ":", "return", "\":dtprel_hi12:\"", ";", "case", "VK_DTPREL_LO12", ":", "return", "\":dtprel_lo12:\"", ";", "case", "VK_DTPREL_LO12_NC", ":", "return", "\":dtprel_lo12_nc:\"", ";", "case", "VK_TPREL_G2", ":", "return", "\":tprel_g2:\"", ";", "case", "VK_TPREL_G1", ":", "return", "\":tprel_g1:\"", ";", "case", "VK_TPREL_G1_NC", ":", "return", "\":tprel_g1_nc:\"", ";", "case", "VK_TPREL_G0", ":", "return", "\":tprel_g0:\"", ";", "case", "VK_TPREL_G0_NC", ":", "return", "\":tprel_g0_nc:\"", ";", "case", "VK_TPREL_HI12", ":", "return", "\":tprel_hi12:\"", ";", "case", "VK_TPREL_LO12", ":", "return", "\":tprel_lo12:\"", ";", "case", "VK_TPREL_LO12_NC", ":", "return", "\":tprel_lo12_nc:\"", ";", "case", "VK_TLSDESC_LO12", ":", "return", "\":tlsdesc_lo12:\"", ";", "case", "VK_ABS_PAGE", ":", "return", "\"\"", ";", "case", "VK_ABS_PAGE_NC", ":", "return", "\":pg_hi21_nc:\"", ";", "case", "VK_GOT", ":", "return", "\":got:\"", ";", "case", "VK_GOT_PAGE", ":", "return", "\":got:\"", ";", "case", "VK_GOT_PAGE_LO15", ":", "return", "\":gotpage_lo15:\"", ";", "case", "VK_GOT_LO12", ":", "return", "\":got_lo12:\"", ";", "case", "VK_GOTTPREL", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_PAGE", ":", "return", "\":gottprel:\"", ";", "case", "VK_GOTTPREL_LO12_NC", ":", "return", "\":gottprel_lo12:\"", ";", "case", "VK_GOTTPREL_G1", ":", "return", "\":gottprel_g1:\"", ";", "case", "VK_GOTTPREL_G0_NC", ":", "return", "\":gottprel_g0_nc:\"", ";", "case", "VK_TLSDESC", ":", "return", "\"\"", ";", "case", "VK_TLSDESC_PAGE", ":", "return", "\":tlsdesc:\"", ";", "case", "VK_SECREL_LO12", ":", "return", "\":secrel_lo12:\"", ";", "case", "VK_SECREL_HI12", ":", "return", "\":secrel_hi12:\"", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\"", "\":lo12:\"", "\":abs_g3:\"", "\":abs_g2:\"", "\":abs_g2_s:\"", "\":abs_g2_nc:\"", "\":abs_g1:\"", "\":abs_g1_s:\"", "\":abs_g1_nc:\"", "\":abs_g0:\"", "\":abs_g0_s:\"", "\":abs_g0_nc:\"", "\":prel_g3:\"", "\":prel_g2:\"", "\":prel_g2_nc:\"", "\":prel_g1:\"", "\":prel_g1_nc:\"", "\":prel_g0:\"", "\":prel_g0_nc:\"", "\":dtprel_g2:\"", "\":dtprel_g1:\"", "\":dtprel_g1_nc:\"", "\":dtprel_g0:\"", "\":dtprel_g0_nc:\"", "\":dtprel_hi12:\"", "\":dtprel_lo12:\"", "\":dtprel_lo12_nc:\"", "\":tprel_g2:\"", "\":tprel_g1:\"", "\":tprel_g1_nc:\"", "\":tprel_g0:\"", "\":tprel_g0_nc:\"", "\":tprel_hi12:\"", "\":tprel_lo12:\"", "\":tprel_lo12_nc:\"", "\":tlsdesc_lo12:\"", "\"\"", "\":pg_hi21_nc:\"", "\":got:\"", "\":got:\"", "\":gotpage_lo15:\"", "\":got_lo12:\"", "\":gottprel:\"", "\":gottprel:\"", "\":gottprel_lo12:\"", "\":gottprel_g1:\"", "\":gottprel_g0_nc:\"", "\"\"", "\":tlsdesc:\"", "\":secrel_lo12:\"", "\":secrel_hi12:\"", "\"Invalid ELF symbol kind\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "int", "compute_mov_length", "(", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "addr", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "addr", "=", "XEXP", "(", "src", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", ")", "addr", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "else", "addr", "=", "NULL_RTX", ";", "unsigned", "int", "base_length", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "if", "(", "addr", "==", "NULL_RTX", ")", "return", "2", ";", "if", "(", "h8300_eightbit_constant_address_p", "(", "addr", ")", ")", "return", "2", ";", "base_length", "=", "8", ";", "break", ";", "case", "E_HImode", ":", "if", "(", "addr", "==", "NULL_RTX", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "2", ";", "if", "(", "src", "==", "const0_rtx", ")", "return", "2", ";", "return", "4", ";", "}", "base_length", "=", "8", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "addr", "==", "NULL_RTX", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "{", "if", "(", "REGNO", "(", "src", ")", "==", "MAC_REG", "||", "REGNO", "(", "dest", ")", "==", "MAC_REG", ")", "return", "4", ";", "else", "return", "2", ";", "}", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "int", "val", "=", "INTVAL", "(", "src", ")", ";", "if", "(", "val", "==", "0", ")", "return", "2", ";", "if", "(", "val", "==", "(", "val", "&", "0x00ff", ")", "||", "val", "==", "(", "val", "&", "0xff00", ")", ")", "return", "4", ";", "switch", "(", "val", "&", "0xffffffff", ")", "{", "case", "0xffffffff", ":", "case", "0xfffffffe", ":", "case", "0xfffffffc", ":", "case", "0x0000ffff", ":", "case", "0x0000fffe", ":", "case", "0xffff0000", ":", "case", "0xfffe0000", ":", "case", "0x00010000", ":", "case", "0x00020000", ":", "return", "4", ";", "}", "}", "return", "6", ";", "}", "base_length", "=", "10", ";", "break", ";", "case", "E_SFmode", ":", "if", "(", "addr", "==", "NULL_RTX", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "2", ";", "if", "(", "satisfies_constraint_G", "(", "src", ")", ")", "return", "2", ";", "return", "6", ";", "}", "base_length", "=", "10", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "addr", ")", "==", "POST_INC", ")", "return", "base_length", "-", "6", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", "return", "base_length", "-", "6", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ">", "-", "32768", "&&", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "<", "32767", ")", "return", "base_length", "-", "4", ";", "if", "(", "h8300_tiny_constant_address_p", "(", "addr", ")", ")", "return", "base_length", "-", "4", ";", "if", "(", "CONSTANT_P", "(", "addr", ")", ")", "return", "base_length", "-", "2", ";", "return", "base_length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "mov", "instruction", "." ]

[ "h8300", "0", "0", "1", "0", "0", "2", "2", "8", "2", "2", "4", "8", "4", "2", "0", "2", "0x00ff", "0xff00", "4", "0xffffffff", "0xffffffff", "0xfffffffe", "0xfffffffc", "0x0000ffff", "0x0000fffe", "0xffff0000", "0xfffe0000", "0x00010000", "0x00020000", "4", "6", "10", "2", "2", "6", "10", "6", "6", "0", "1", "1", "32768", "1", "32767", "4", "4", "2" ]

[]

[ "<s>", "std", "::", "string", "AMDGPUSubtarget", "::", "getDataLayout", "(", ")", "const", "{", "if", "(", "!", "Device", ")", "{", "return", "std", "::", "string", "(", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048-a0:0:64\"", ")", ";", "}", "return", "Device", "->", "getDataLayout", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "R600", "\"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16\"", "\"-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f80:32:32\"", "\"-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64\"", "\"-v96:128:128-v128:128:128-v192:256:256-v256:256:256\"", "\"-v512:512:512-v1024:1024:1024-v2048:2048:2048-a0:0:64\"" ]

[]

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

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

[ "Mips", "\"Mips Constant Islands\"" ]

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "void", "spu_allocate_stack", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "HOST_WIDE_INT", "v", ";", "rtx", "chain", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "stack_bot", "=", "gen_frame_mem", "(", "V4SImode", ",", "stack_pointer_rtx", ")", ";", "rtx", "sp", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "splatted", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "rtx", "pat", "=", "gen_reg_rtx", "(", "TImode", ")", ";", "emit_move_insn", "(", "chain", ",", "stack_bot", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "v", "=", "0x1020300010203ll", ";", "emit_move_insn", "(", "pat", ",", "immed_double_const", "(", "v", ",", "v", ",", "TImode", ")", ")", ";", "emit_insn", "(", "gen_shufb", "(", "splatted", ",", "op1", ",", "op1", ",", "pat", ")", ")", ";", "emit_insn", "(", "gen_spu_convert", "(", "sp", ",", "stack_pointer_rtx", ")", ")", ";", "emit_insn", "(", "gen_subv4si3", "(", "sp", ",", "sp", ",", "splatted", ")", ")", ";", "if", "(", "flag_stack_check", "||", "flag_stack_clash_protection", ")", "{", "rtx", "avail", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "result", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_vec_extractv4sisi", "(", "avail", ",", "sp", ",", "GEN_INT", "(", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_cgt_si", "(", "result", ",", "avail", ",", "GEN_INT", "(", "-", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_spu_heq", "(", "result", ",", "GEN_INT", "(", "0", ")", ")", ")", ";", "}", "emit_insn", "(", "gen_spu_convert", "(", "stack_pointer_rtx", ",", "sp", ")", ")", ";", "emit_move_insn", "(", "stack_bot", ",", "chain", ")", ";", "emit_move_insn", "(", "op0", ",", "virtual_stack_dynamic_rtx", ")", ";", "}", "</s>" ]

[ "We", "need", "to", "correctly", "update", "the", "back", "chain", "pointer", "and", "the", "Available", "Stack", "Size", "(", "which", "is", "in", "the", "second", "slot", "of", "the", "sp", "register", ".", ")" ]

[ "spu", "0x1020300010203ll", "1", "1", "0" ]

[]

[ "<s>", "BitVector", "ARCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "ILINK", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "R25", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "BLINK", ")", ";", "Reserved", ".", "set", "(", "ARC", "::", "FP", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "ARC::ILINK", "ARC::SP", "ARC::GP", "ARC::R25", "ARC::BLINK", "ARC::FP" ]

[]

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

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

[ "M68k", "M68k", "\"%\"" ]

[]

[ "<s>", "bool", "AMDGPUPropagateAttributesEarly", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "TM", ")", "{", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "TM", "=", "&", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "}", "if", "(", "!", "AMDGPU", "::", "isKernel", "(", "F", ".", "getCallingConv", "(", ")", ")", ")", "return", "false", ";", "return", "AMDGPUPropagateAttributes", "(", "TM", ",", "false", ")", ".", "process", "(", "F", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isKernel", "AMDGPU" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "bool", "MustSaveTOC", "=", "FI", "->", "mustSaveTOC", "(", ")", ";", "DebugLoc", "DL", ";", "bool", "CRSpilled", "=", "false", ";", "MachineInstrBuilder", "CRMIB", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", ")", "continue", ";", "bool", "IsCRField", "=", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "bool", "IsLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "IsLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "CRSpilled", "&&", "IsCRField", ")", "{", "CRMIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "continue", ";", "}", "if", "(", "(", "Reg", "==", "PPC", "::", "X2", "||", "Reg", "==", "PPC", "::", "R2", ")", "&&", "MustSaveTOC", ")", "continue", ";", "if", "(", "IsCRField", ")", "{", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "FuncInfo", "->", "addMustSaveCR", "(", "Reg", ")", ";", "}", "else", "{", "CRSpilled", "=", "true", ";", "FuncInfo", "->", "setSpillsCR", "(", ")", ";", "CRMIB", "=", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFCR", ")", ",", "PPC", "::", "R12", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitKill", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "CRMIB", ")", ";", "MBB", ".", "insert", "(", "MI", ",", "addFrameReference", "(", "BuildMI", "(", "*", "MF", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "PPC", "::", "R12", ",", "getKillRegState", "(", "true", ")", ")", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ")", ";", "}", "}", "else", "{", "if", "(", "CSI", "[", "i", "]", ".", "isSpilledToReg", "(", ")", ")", "{", "NumPESpillVSR", "++", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MTVSRD", ")", ",", "CSI", "[", "i", "]", ".", "getDstReg", "(", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "!", "IsLiveIn", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "}", "}", "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", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR4", "PPC::X2", "PPC::R2", "PPC", "PPC", "PPC", "PPC::MFCR", "PPC::R12", "PPC::STW", "PPC::R12", "PPC::MTVSRD" ]

[]

[ "<s>", "static", "void", "aarch64_override_options", "(", "void", ")", "{", "unsigned", "long", "cpu_isa", "=", "0", ";", "unsigned", "long", "arch_isa", "=", "0", ";", "aarch64_isa_flags", "=", "0", ";", "bool", "valid_cpu", "=", "true", ";", "bool", "valid_tune", "=", "true", ";", "bool", "valid_arch", "=", "true", ";", "selected_cpu", "=", "NULL", ";", "selected_arch", "=", "NULL", ";", "selected_tune", "=", "NULL", ";", "if", "(", "aarch64_branch_protection_string", ")", "aarch64_validate_mbranch_protection", "(", "aarch64_branch_protection_string", ")", ";", "if", "(", "aarch64_cpu_string", ")", "valid_cpu", "=", "aarch64_validate_mcpu", "(", "aarch64_cpu_string", ",", "&", "selected_cpu", ",", "&", "cpu_isa", ")", ";", "if", "(", "aarch64_arch_string", ")", "valid_arch", "=", "aarch64_validate_march", "(", "aarch64_arch_string", ",", "&", "selected_arch", ",", "&", "arch_isa", ")", ";", "if", "(", "aarch64_tune_string", ")", "valid_tune", "=", "aarch64_validate_mtune", "(", "aarch64_tune_string", ",", "&", "selected_tune", ")", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "if", "(", "!", "selected_cpu", ")", "{", "if", "(", "selected_arch", ")", "{", "selected_cpu", "=", "&", "all_cores", "[", "selected_arch", "->", "ident", "]", ";", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "else", "{", "selected_cpu", "=", "aarch64_get_tune_cpu", "(", "aarch64_none", ")", ";", "aarch64_isa_flags", "=", "TARGET_CPU_DEFAULT", ">>", "6", ";", "}", "if", "(", "selected_tune", ")", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "}", "else", "if", "(", "selected_arch", ")", "{", "if", "(", "selected_arch", "->", "arch", "!=", "selected_cpu", "->", "arch", ")", "{", "warning", "(", "0", ",", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", ",", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ".", "name", ",", "selected_arch", "->", "name", ")", ";", "}", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "}", "else", "{", "aarch64_isa_flags", "=", "cpu_isa", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "if", "(", "!", "selected_arch", ")", "{", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "}", "if", "(", "!", "selected_tune", ")", "selected_tune", "=", "selected_cpu", ";", "if", "(", "aarch64_enable_bti", "==", "2", ")", "{", "aarch64_enable_bti", "=", "1", ";", "aarch64_enable_bti", "=", "0", ";", "}", "if", "(", "!", "TARGET_ILP32", "&&", "accepted_branch_protection_string", "==", "NULL", ")", "{", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NON_LEAF", ";", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NONE", ";", "}", "if", "(", "TARGET_ILP32", ")", "error", "(", "\"assembler does not support %<-mabi=ilp32%>\"", ")", ";", "aarch64_sve_vg", "=", "aarch64_convert_sve_vector_bits", "(", "aarch64_sve_vector_bits", ")", ";", "if", "(", "aarch64_ra_sign_scope", "!=", "AARCH64_FUNCTION_NONE", "&&", "TARGET_ILP32", ")", "sorry", "(", "\"return address signing is only supported for %<-mabi=lp64%>\"", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_tune_string", "&&", "valid_tune", ")", ")", "gcc_assert", "(", "explicit_tune_core", "!=", "aarch64_none", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_arch_string", "&&", "valid_arch", ")", ")", "gcc_assert", "(", "explicit_arch", "!=", "aarch64_no_arch", ")", ";", "if", "(", "aarch64_track_speculation", ")", "flag_shrink_wrap", "=", "0", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "aarch64", "0", "0", "0", "6", "0", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", "2", "1", "0", "\"assembler does not support %<-mabi=ilp32%>\"", "\"return address signing is only supported for %<-mabi=lp64%>\"", "0" ]

[]

[ "<s>", "void", "tilepro_allocate_stack", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "fp_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "fp_value", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "fp_loc", ";", "emit_move_insn", "(", "fp_addr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ")", ";", "fp_loc", "=", "gen_frame_mem", "(", "Pmode", ",", "fp_addr", ")", ";", "emit_move_insn", "(", "fp_value", ",", "fp_loc", ")", ";", "op1", "=", "force_reg", "(", "Pmode", ",", "op1", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "op1", ")", ")", ";", "emit_move_insn", "(", "fp_addr", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ")", ";", "fp_loc", "=", "gen_frame_mem", "(", "Pmode", ",", "fp_addr", ")", ";", "emit_move_insn", "(", "fp_loc", ",", "fp_value", ")", ";", "emit_move_insn", "(", "op0", ",", "virtual_stack_dynamic_rtx", ")", ";", "}", "</s>" ]

[ "Implement", "the", "allocate_stack", "pattern", "(", "alloca", ")", "." ]

[ "tilepro" ]

[]

[ "<s>", "void", "m68hc11_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ")", "{", "tree", "ret_type", ";", "z_replacement_completed", "=", "0", ";", "cum", "->", "words", "=", "0", ";", "cum", "->", "nregs", "=", "0", ";", "if", "(", "fntype", "==", "0", ")", "{", "const", "char", "*", "name", ";", "size_t", "len", ";", "if", "(", "libname", "==", "0", "||", "GET_CODE", "(", "libname", ")", "!=", "SYMBOL_REF", ")", "return", ";", "name", "=", "XSTR", "(", "libname", ",", "0", ")", ";", "len", "=", "strlen", "(", "name", ")", ";", "if", "(", "len", ">", "3", "&&", "(", "(", "name", "[", "len", "-", "2", "]", "==", "'d'", "&&", "(", "name", "[", "len", "-", "1", "]", "==", "'f'", "||", "name", "[", "len", "-", "1", "]", "==", "'i'", ")", ")", "||", "(", "name", "[", "len", "-", "3", "]", "==", "'d'", "&&", "(", "name", "[", "len", "-", "2", "]", "==", "'i'", "||", "name", "[", "len", "-", "2", "]", "==", "'f'", ")", ")", ")", ")", "{", "cum", "->", "words", "=", "1", ";", "cum", "->", "nregs", "=", "1", ";", "}", "return", ";", "}", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "ret_type", "&&", "aggregate_value_p", "(", "ret_type", ",", "fntype", ")", ")", "{", "cum", "->", "words", "=", "1", ";", "cum", "->", "nregs", "=", "1", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "timode_remove_non_convertible_regs", "(", "bitmap", "candidates", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "bitmap", "regs", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "bool", "changed", ";", "do", "{", "changed", "=", "false", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "candidates", ",", "0", ",", "id", ",", "bi", ")", "{", "rtx_insn", "*", "insn", "=", "DF_INSN_UID_GET", "(", "id", ")", "->", "insn", ";", "df_ref", "ref", ";", "FOR_EACH_INSN_DEF", "(", "ref", ",", "insn", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", "&&", "GET_MODE", "(", "DF_REF_REG", "(", "ref", ")", ")", "==", "TImode", ")", "timode_check_non_convertible_regs", "(", "candidates", ",", "regs", ",", "DF_REF_REGNO", "(", "ref", ")", ")", ";", "FOR_EACH_INSN_USE", "(", "ref", ",", "insn", ")", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "ref", ")", "&&", "GET_MODE", "(", "DF_REF_REG", "(", "ref", ")", ")", "==", "TImode", ")", "timode_check_non_convertible_regs", "(", "candidates", ",", "regs", ",", "DF_REF_REGNO", "(", "ref", ")", ")", ";", "}", "EXECUTE_IF_SET_IN_BITMAP", "(", "regs", ",", "0", ",", "id", ",", "bi", ")", "{", "for", "(", "df_ref", "def", "=", "DF_REG_DEF_CHAIN", "(", "id", ")", ";", "def", ";", "def", "=", "DF_REF_NEXT_REG", "(", "def", ")", ")", "if", "(", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Removing insn %d from candidates list\\n\"", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "def", ")", ")", ";", "changed", "=", "true", ";", "}", "for", "(", "df_ref", "ref", "=", "DF_REG_USE_CHAIN", "(", "id", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "if", "(", "bitmap_bit_p", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Removing insn %d from candidates list\\n\"", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ";", "changed", "=", "true", ";", "}", "}", "}", "while", "(", "changed", ")", ";", "BITMAP_FREE", "(", "regs", ")", ";", "}", "</s>" ]

[ "For", "a", "given", "bitmap", "of", "insn", "UIDs", "scans", "all", "instructions", "and", "remove", "insn", "from", "CANDIDATES", "in", "case", "it", "has", "both", "convertible", "and", "not", "convertible", "definitions", ".", "All", "insns", "in", "a", "bitmap", "are", "conversion", "candidates", "according", "to", "scalar_to_vector_candidate_p", ".", "Currently", "it", "implies", "all", "insns", "are", "single_set", "." ]

[ "i386", "0", "0", "\"Removing insn %d from candidates list\\n\"", "\"Removing insn %d from candidates list\\n\"" ]

[]

[ "<s>", "void", "i386_pe_unique_section", "(", "tree", "decl", ",", "int", "reloc", ")", "{", "int", "len", ";", "const", "char", "*", "name", ",", "*", "prefix", ";", "char", "*", "string", ";", "if", "(", "!", "flag_writable_rel_rdata", ")", "reloc", "=", "0", ";", "name", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "name", "=", "i386_pe_strip_name_encoding_full", "(", "name", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "prefix", "=", "\".text$\"", ";", "else", "if", "(", "decl_readonly_section", "(", "decl", ",", "reloc", ")", ")", "prefix", "=", "\".rdata$\"", ";", "else", "prefix", "=", "\".data$\"", ";", "len", "=", "strlen", "(", "name", ")", "+", "strlen", "(", "prefix", ")", ";", "string", "=", "XALLOCAVEC", "(", "char", ",", "len", "+", "1", ")", ";", "sprintf", "(", "string", ",", "\"%s%s\"", ",", "prefix", ",", "name", ")", ";", "set_decl_section_name", "(", "decl", ",", "string", ")", ";", "}", "</s>" ]

[ "Cover", "function", "for", "UNIQUE_SECTION", "." ]

[ "i386", "0", "\".text$\"", "\".rdata$\"", "\".data$\"", "1", "\"%s%s\"" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "Outs", ".", "size", "(", ")", "<=", "1", "&&", "\"WebAssembly can only return up to one value\"", ")", ";", "if", "(", "!", "callingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", ".", "append", "(", "OutVals", ".", "begin", "(", ")", ",", "OutVals", ".", "end", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "RETURN", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "for", "(", "const", "ISD", "::", "OutputArg", "&", "Out", ":", "Outs", ")", "{", "assert", "(", "!", "Out", ".", "Flags", ".", "isByVal", "(", ")", "&&", "\"byval is not valid for return values\"", ")", ";", "assert", "(", "!", "Out", ".", "Flags", ".", "isNest", "(", ")", "&&", "\"nest is not valid for return values\"", ")", ";", "assert", "(", "Out", ".", "IsFixed", "&&", "\"non-fixed return value is not valid\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs results\"", ")", ";", "if", "(", "Out", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last results\"", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1", "\"WebAssembly can only return up to one value\"", "\"WebAssembly doesn't support non-C calling conventions\"", "4", "1", "WebAssemblyISD::RETURN", "MVT::Other", "ISD::OutputArg", "\"byval is not valid for return values\"", "\"nest is not valid for return values\"", "\"non-fixed return value is not valid\"", "\"WebAssembly hasn't implemented inalloca results\"", "\"WebAssembly hasn't implemented cons regs results\"", "\"WebAssembly hasn't implemented cons regs last results\"" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHU", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "false", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRem", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRemU", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "lowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "lowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "MipsTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::LOAD", "ISD::STORE", "ISD::SMUL_LOHI", "MipsISD::Mult", "ISD::UMUL_LOHI", "MipsISD::Multu", "ISD::MULHS", "MipsISD::Mult", "ISD::MULHU", "MipsISD::Multu", "ISD::MUL", "MipsISD::Mult", "ISD::SDIVREM", "MipsISD::DivRem", "ISD::UDIVREM", "MipsISD::DivRemU", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_VOID", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SELECT", "Mips" ]

[]

[ "<s>", "static", "int", "get_some_local_dynamic_name_1", "(", "rtx", "*", "px", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "cfun", "->", "machine", "->", "some_ld_name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "See", "'get_some_local_dynamic_name", "'", "." ]

[ "alpha", "0", "1", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Load Value Injection (LVI) Load Hardening (Unoptimized)\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Load Value Injection (LVI) Load Hardening (Unoptimized)\"" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", ")", "&&", "\"Invalid branch condition!\"", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "getOppositeBranchOpcode", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "RISCV", "RISCV", "3", "\"Invalid branch condition!\"", "0", "0" ]

[]

[ "<s>", "bool", "mn10300_can_use_retf_insn", "(", "void", ")", "{", "if", "(", "!", "optimize", ")", "return", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "false", ";", "if", "(", "df_regs_ever_live_p", "(", "MDR_REG", ")", ")", "return", "false", ";", "gcc_assert", "(", "!", "in_sequence_p", "(", ")", ")", ";", "return", "leaf_function_p", "(", ")", ";", "}", "</s>" ]

[ "If", "the", "MDR", "register", "is", "never", "clobbered", ",", "we", "can", "use", "the", "RETF", "instruction", "which", "takes", "the", "address", "from", "the", "MDR", "register", ".", "This", "is", "3", "cycles", "faster", "than", "having", "to", "load", "the", "address", "from", "the", "stack", "." ]

[ "mn10300" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", "{", "if", "(", "(", "TT", ".", "isOSWindows", "(", ")", "&&", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", "||", "TT", ".", "isPS4", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUSubtarget", "::", "getOccupancyWithLocalMemSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "getOccupancyWithLocalMemSize", "(", "MFI", "->", "getLDSSize", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ")", ";", "}", "</s>" ]

[ "Inverse", "of", "getMaxLocalMemWithWaveCount", "." ]

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

[]

[ "<s>", "static", "int", "rs6000_debug_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", "dw", ")", "{", "int", "ret", "=", "rs6000_adjust_cost", "(", "insn", ",", "dep_type", ",", "dep_insn", ",", "cost", ",", "dw", ")", ";", "if", "(", "ret", "!=", "cost", ")", "{", "const", "char", "*", "dep", ";", "switch", "(", "dep_type", ")", "{", "default", ":", "dep", "=", "\"unknown depencency\"", ";", "break", ";", "case", "REG_DEP_TRUE", ":", "dep", "=", "\"data dependency\"", ";", "break", ";", "case", "REG_DEP_OUTPUT", ":", "dep", "=", "\"output dependency\"", ";", "break", ";", "case", "REG_DEP_ANTI", ":", "dep", "=", "\"anti depencency\"", ";", "break", ";", "}", "fprintf", "(", "stderr", ",", "\"\\nrs6000_adjust_cost, final cost = %d, orig cost = %d, \"", "\"%s, insn:\\n\"", ",", "ret", ",", "cost", ",", "dep", ")", ";", "debug_rtx", "(", "insn", ")", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_adjust_cost", "." ]

[ "powerpcspe", "\"unknown depencency\"", "\"data dependency\"", "\"output dependency\"", "\"anti depencency\"", "\"\\nrs6000_adjust_cost, final cost = %d, orig cost = %d, \"", "\"%s, insn:\\n\"" ]

[]

[ "<s>", "void", "HexagonExpandCondsets", "::", "shrinkToUses", "(", "unsigned", "Reg", ",", "LiveInterval", "&", "LI", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "4", ">", "Deads", ";", "LIS", "->", "shrinkToUses", "(", "&", "LI", ",", "&", "Deads", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "Deads", ".", "size", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "{", "MachineInstr", "*", "MI", "=", "Deads", "[", "i", "]", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "getReg", "(", ")", "!=", "Reg", ")", "continue", ";", "Op", ".", "setIsDead", "(", "false", ")", ";", "}", "LiveInterval", "::", "iterator", "End", "=", "LI", ".", "end", "(", ")", ";", "SlotIndex", "S", "=", "LIS", "->", "getInstructionIndex", "(", "MI", ")", ".", "getRegSlot", "(", ")", ";", "LiveInterval", "::", "iterator", "T", "=", "LI", ".", "FindSegmentContaining", "(", "S", ")", ";", "assert", "(", "T", "!=", "End", ")", ";", "LiveInterval", "::", "iterator", "N", "=", "std", "::", "next", "(", "T", ")", ";", "if", "(", "N", "!=", "End", ")", "T", "->", "end", "=", "N", "->", "start", ";", "else", "T", "->", "end", "=", "LIS", "->", "getMBBEndIdx", "(", "MI", "->", "getParent", "(", ")", ")", ";", "}", "updateKillFlags", "(", "Reg", ",", "LI", ")", ";", "}", "</s>" ]

[ "Specialized", "version", "of", "shrinkToUses", "(", "LiveInterval", "li", ",", "SmallVectorImpl", "<", "MachineInstr", ">", "*", "dead", ")", "that", "works", "on", "a", "subregister", "live", "range", "and", "only", "looks", "at", "uses", "matching", "the", "lane", "mask", "of", "the", "subregister", "range", "." ]

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

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "X86InstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "uint16_t", "domain", "=", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ">>", "X86II", "::", "SSEDomainShift", ")", "&", "3", ";", "uint16_t", "validDomains", "=", "0", ";", "if", "(", "domain", "&&", "lookup", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "else", "if", "(", "domain", "&&", "lookupAVX2", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "Subtarget", ".", "hasAVX2", "(", ")", "?", "0xe", ":", "0x6", ";", "else", "if", "(", "domain", "&&", "lookupAVX512", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "0xe", ";", "else", "if", "(", "domain", "&&", "lookupAVX512DQ", "(", "MI", ".", "getOpcode", "(", ")", ",", "domain", ")", ")", "validDomains", "=", "Subtarget", ".", "hasDQI", "(", ")", "?", "0xe", ":", "0x8", ";", "return", "std", "::", "make_pair", "(", "domain", ",", "validDomains", ")", ";", "}", "</s>" ]

[ "Return", "the", "current", "execution", "domain", "and", "bit", "mask", "of", "possible", "domains", "for", "instruction", "." ]

[ "X86", "X86", "X86II::SSEDomainShift", "3", "0", "0xe", "0xe", "0x6", "0xe", "0xe", "0x8" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "dl", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"Code size not handled.\"", ")", ";", "assert", "(", "TBB", "&&", "\"InsertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"ARC branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "int", "BccOpc", "=", "Cond", "[", "1", "]", ".", "isImm", "(", ")", "?", "ARC", "::", "BRcc_ru6_p", ":", "ARC", "::", "BRcc_rr_p", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "BccOpc", ")", ")", ";", "MIB", ".", "addMBB", "(", "TBB", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "MIB", ".", "add", "(", "Cond", "[", "i", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "{", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "ARC", "ARC", "\"Code size not handled.\"", "\"InsertBranch must not be told to insert a fallthrough\"", "3", "0", "\"ARC branch conditions have two components!\"", "ARC::BR", "1", "1", "ARC::BRcc_ru6_p", "ARC::BRcc_rr_p", "0", "3", "1", "ARC::BR", "2" ]

[]

[ "<s>", "void", "SystemZRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetFrameInfo", "&", "TFI", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "SystemZMFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "SystemZ", "::", "RET", ":", "break", ";", "default", ":", "assert", "(", "0", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", "-", "SystemZMFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "-", "TFI", ".", "getOffsetOfLocalArea", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "--", "MBBI", ";", "if", "(", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "}", "if", "(", "StackSize", "||", "MFI", "->", "hasCalls", "(", ")", ")", "{", "assert", "(", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rmm", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "SystemZ", "::", "MOV64rm", ")", "&&", "\"Expected to see callee-save register restore code\"", ")", ";", "assert", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "SystemZ", "::", "R15D", ")", "&&", "\"Invalid stack frame calculation!\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isImm", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Unexpected restore code!\"", ")", ";", "}", "uint64_t", "Offset", "=", "NumBytes", "+", "MI", ".", "getOperand", "(", "i", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">", "524287", ")", "{", "NumBytes", "=", "Offset", "-", "524287", ";", "Offset", "=", "524287", ";", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "NumBytes", ",", "TII", ")", ";", "}", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::RET", "0", "\"Can only insert epilog into returning blocks\"", "SystemZ", "SystemZ::MOV64rmm", "SystemZ::MOV64rm", "\"Expected to see callee-save register restore code\"", "SystemZ::R15D", "\"Invalid stack frame calculation!\"", "0", "\"Unexpected restore code!\"", "524287", "524287", "524287" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "4", "&&", "isMicroMips", "(", "STI", ")", ")", "{", "EmitInstruction", "(", "Val", ">>", "16", ",", "2", ",", "STI", ",", "OS", ")", ";", "EmitInstruction", "(", "Val", ",", "2", ",", "STI", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Mips", "4", "Mips", "16", "2", "2", "0", "8", "1", "8", "0xff" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "Node", "=", "AdjustRegClass", "(", "Node", ",", "DAG", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Node", "->", "getMachineOpcode", "(", ")", ")", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "if", "(", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "INSERT_SUBREG", "||", "Node", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "legalizeTargetIndependentNode", "(", "Node", ",", "DAG", ")", ";", "return", "Node", ";", "}", "return", "Node", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

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

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildDefaultInstruction", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "Opcode", ",", "unsigned", "DstReg", ",", "unsigned", "Src0Reg", ",", "unsigned", "Src1Reg", ")", "const", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Src0Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "-", "1", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addReg", "(", "Src1Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "-", "1", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "AMDGPU", "::", "PRED_SEL_OFF", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "buildDefaultInstruction", "-", "This", "function", "returns", "a", "MachineInstr", "with", "all", "the", "instruction", "modifiers", "initialized", "to", "their", "default", "values", "." ]

[ "AMDGPU", "R600", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "1", "AMDGPU::PRED_SEL_OFF", "0", "0" ]

[]

[ "<s>", "void", "alpha_end_function", "(", "FILE", "*", "file", ",", "const", "char", "*", "fnname", ",", "tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "alpha_write_linkage", "(", "file", ",", "fnname", ",", "decl", ")", ";", "if", "(", "!", "TARGET_ABI_UNICOSMK", "&&", "!", "flag_inhibit_size_directive", ")", "{", "fputs", "(", "\"\\t.end \"", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "fnname", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "inside_function", "=", "FALSE", ";", "if", "(", "TARGET_ABI_UNICOSMK", ")", "{", "unicosmk_output_ssib", "(", "file", ",", "fnname", ")", ";", "unicosmk_output_deferred_case_vectors", "(", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "the", "rest", "of", "the", "textual", "info", "surrounding", "the", "epilogue", "." ]

[ "alpha", "\"\\t.end \"" ]

[]

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

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

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

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "isInt", "<", "8", ">", "(", "Imm", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "Z80old", "Z80old", "8" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "M0", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_SHARED_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_BASE", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SRC_PRIVATE_LIMIT", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "unsigned", "MaxNumSGPRs", "=", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::M0", "AMDGPU::SRC_SHARED_BASE", "AMDGPU::SRC_SHARED_LIMIT", "AMDGPU::SRC_PRIVATE_BASE", "AMDGPU::SRC_PRIVATE_LIMIT", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "SI", "SI", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "const", "char", "*", "SNESMCExpr", "::", "getName", "(", ")", "const", "{", "const", "auto", "&", "Modifier", "=", "std", "::", "find_if", "(", "std", "::", "begin", "(", "ModifierNames", ")", ",", "std", "::", "end", "(", "ModifierNames", ")", ",", "[", "this", "]", "(", "ModifierEntry", "const", "&", "Mod", ")", "{", "return", "Mod", ".", "VariantKind", "==", "Kind", ";", "}", ")", ";", "if", "(", "Modifier", "!=", "std", "::", "end", "(", "ModifierNames", ")", ")", "{", "return", "Modifier", "->", "Spelling", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "SNES", "SNES" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "M68kInstructionLookup", "::", "dump", "(", ")", "const", "{", "dbgs", "(", ")", "<<", "\"M68kInstructionLookup \"", "<<", "OpCode", "<<", "\" \"", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Mask", ".", "size", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "uint16_t", "WordMask", "=", "Mask", "[", "I", "]", ";", "uint16_t", "WordValue", "=", "Value", "[", "I", "]", ";", "for", "(", "unsigned", "B", "=", "0", ";", "B", "<", "16", ";", "++", "B", ")", "{", "uint16_t", "Bit", "=", "(", "1", "<<", "(", "15", "-", "B", ")", ")", ";", "unsigned", "IsMasked", "=", "!", "(", "WordMask", "&", "Bit", ")", ";", "unsigned", "IsClear", "=", "!", "(", "WordValue", "&", "Bit", ")", ";", "if", "(", "B", "==", "8", ")", "dbgs", "(", ")", "<<", "\" \"", ";", "char", "Ch", "=", "IsMasked", "?", "'?'", ":", "(", "IsClear", "?", "'0'", ":", "'1'", ")", ";", "dbgs", "(", ")", "<<", "Ch", ";", "}", "dbgs", "(", ")", "<<", "\" \"", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "\"M68kInstructionLookup \"", "\" \"", "0", "0", "16", "1", "15", "8", "\" \"", "\" \"", "\"\\n\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "WebAssemblySelectionDAGInfo", "::", "EmitTargetCodeForMemmove", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Chain", ",", "SDValue", "Op1", ",", "SDValue", "Op2", ",", "SDValue", "Op3", ",", "Align", "Alignment", ",", "bool", "IsVolatile", ",", "bool", "MustPreserveCheriCapabilities", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "return", "EmitTargetCodeForMemcpy", "(", "DAG", ",", "DL", ",", "Chain", ",", "Op1", ",", "Op2", ",", "Op3", ",", "Alignment", ",", "IsVolatile", ",", "false", ",", "MustPreserveCheriCapabilities", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "SDNode", "*", "ARCompactDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Op", ")", "{", "DebugLoc", "dl", "=", "Op", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Op", "->", "isMachineOpcode", "(", ")", ")", "{", "return", "NULL", ";", "}", "switch", "(", "Op", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FrameIndex", ":", "{", "assert", "(", "Op", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Op", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Op", "->", "hasOneUse", "(", ")", ")", "{", "return", "CurDAG", "->", "SelectNodeTo", "(", "Op", ",", "ARC", "::", "ADDrli", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "}", "return", "CurDAG", "->", "getMachineNode", "(", "ARC", "::", "ADDrli", ",", "dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ")", ";", "}", "default", ":", "break", ";", "}", "return", "SelectCode", "(", "Op", ")", ";", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "ARC::ADDrli", "MVT::i32", "0", "MVT::i32", "ARC::ADDrli", "MVT::i32", "0", "MVT::i32" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isAssociativeAndCommutative", "(", "const", "MachineInstr", "&", "Inst", ")", "const", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "PPC", "::", "FADD", ":", "case", "PPC", "::", "FADDS", ":", "case", "PPC", "::", "FMUL", ":", "case", "PPC", "::", "FMULS", ":", "case", "PPC", "::", "VADDFP", ":", "case", "PPC", "::", "XSADDDP", ":", "case", "PPC", "::", "XVADDDP", ":", "case", "PPC", "::", "XVADDSP", ":", "case", "PPC", "::", "XSADDSP", ":", "case", "PPC", "::", "XSMULDP", ":", "case", "PPC", "::", "XVMULDP", ":", "case", "PPC", "::", "XVMULSP", ":", "case", "PPC", "::", "XSMULSP", ":", "case", "PPC", "::", "QVFADD", ":", "case", "PPC", "::", "QVFADDS", ":", "case", "PPC", "::", "QVFADDSs", ":", "case", "PPC", "::", "QVFMUL", ":", "case", "PPC", "::", "QVFMULS", ":", "case", "PPC", "::", "QVFMULSs", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "when", "\\P", "Inst", "is", "both", "associative", "and", "commutative", "." ]

[ "PowerPC", "PPC", "PPC::FADD", "PPC::FADDS", "PPC::FMUL", "PPC::FMULS", "PPC::VADDFP", "PPC::XSADDDP", "PPC::XVADDDP", "PPC::XVADDSP", "PPC::XSADDSP", "PPC::XSMULDP", "PPC::XVMULDP", "PPC::XVMULSP", "PPC::XSMULSP", "PPC::QVFADD", "PPC::QVFADDS", "PPC::QVFADDSs", "PPC::QVFMUL", "PPC::QVFMULS", "PPC::QVFMULSs" ]

[]

[ "<s>", "unsigned", "TeakInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "NewDestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "MI", "=", "*", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Teak", "::", "BR_imm18", ")", ")", ".", "addMBB", "(", "&", "NewDestBB", ")", ".", "addImm", "(", "TeakCC", "::", "True", ")", ".", "addReg", "(", "0", ")", ";", "return", "getInstSizeInBytes", "(", "MI", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "Teak", "Teak", "Teak::BR_imm18", "TeakCC::True", "0" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createAMDGPUELFObjectWriter", "(", "OS", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

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

[ "Returns", "true", "if", "we", "know", "the", "value", "of", "all", "bits", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "calculateIndirectAddress", "(", "unsigned", "RegIndex", ",", "unsigned", "Channel", ")", "const", "{", "assert", "(", "Channel", "==", "0", ")", ";", "return", "RegIndex", ";", "}", "</s>" ]

[ "Calculate", "the", "``", "Indirect", "Address", "''", "for", "the", "given", "RegIndex", "and", "Channel", "." ]

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

[]

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

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "M88k", "M88k" ]

[]

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

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

[ "ARM64", "ARM64", "ARM64::FP", "ARM64::SP" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "hasBitTest", "(", "SDValue", "X", ",", "SDValue", "Y", ")", "const", "{", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Y", ")", ";", "return", "C", "&&", "C", "->", "getAPIntValue", "(", ")", ".", "ule", "(", "10", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bit-test", "instruction", ":", "(", "X", "&", "(", "1", "<", "<", "Y", ")", ")", "==/", "!", "=", "0", "This", "knowledge", "can", "be", "used", "to", "prevent", "breaking", "the", "pattern", ",", "or", "creating", "it", "if", "it", "could", "be", "recognized", "." ]

[ "RISCV", "RISCV", "10" ]

[]

[ "<s>", "int", "extra_constraint", "(", "rtx", "x", ",", "int", "c", ")", "{", "if", "(", "c", "==", "'Q'", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "{", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "(", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", ")", ",", "reload_completed", ",", "reload_in_progress", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "if", "(", "TARGET_ALL_DEBUG", ")", "{", "fprintf", "(", "stderr", ",", "(", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", ")", ",", "reload_completed", ",", "reload_in_progress", ")", ";", "debug_rtx", "(", "x", ")", ";", "}", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "1", ";", "else", "if", "(", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", ")", "return", "1", ";", "else", "if", "(", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "EXTRA_CONSTRAINT", "helper" ]

[ "avr", "0", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", "0", "0", "0", "0", "1", "0", "1", "0", "0", "\"extra_constraint:\\n\"", "\"reload_completed: %d\\n\"", "\"reload_in_progress: %d\\n\"", "1", "1", "1", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"ARM hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "if", "(", "ITBlockSize", "&&", "MI", "!=", "ITBlockMIs", "[", "ITBlockSize", "-", "1", "]", ")", "return", "Hazard", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "LastMI", "&&", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "!=", "ARMII", "::", "DomainGeneral", ")", "{", "MachineInstr", "*", "DefMI", "=", "LastMI", ";", "const", "MCInstrDesc", "&", "LastMCID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "LastMCID", ".", "isBarrier", "(", ")", "&&", "!", "(", "STI", ".", "isCortexA9", "(", ")", "&&", "(", "LastMCID", ".", "mayLoad", "(", ")", "||", "LastMCID", ".", "mayStore", "(", ")", ")", ")", "&&", "(", "LastMCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainGeneral", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "llvm", "::", "prior", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}", "}", "if", "(", "TII", ".", "isFpMLxInstruction", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "&&", "(", "TII", ".", "canCauseFpMLxStall", "(", "MI", "->", "getOpcode", "(", ")", ")", "||", "hasRAWHazard", "(", "DefMI", ",", "MI", ",", "TRI", ")", ")", ")", "{", "if", "(", "FpMLxStalls", "==", "0", ")", "FpMLxStalls", "=", "4", ";", "return", "Hazard", ";", "}", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ",", "Stalls", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"ARM hazards don't support scoreboard lookahead\"", "1", "ARMII::DomainMask", "ARMII::DomainGeneral", "ARMII::DomainMask", "ARMII::DomainGeneral", "0", "4" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"mproc Branch Selector\"", ";", "}", "</s>" ]

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

[ "mproc", "\"mproc Branch Selector\"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "MI", "->", "getDesc", "(", ")", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "override", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "startswith", "(", "\".mos_addr_asciz\"", ")", ")", "return", "parseAddrAsciz", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MOS", "\".mos_addr_asciz\"" ]

[]

[ "<s>", "bool", "is_interrupt_func", "(", "const_tree", "decl", ")", "{", "return", "has_func_attr", "(", "decl", ",", "\"interrupt\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "interrupt", "''", "attribute", "." ]

[ "rx", "\"interrupt\"" ]

[]

[ "<s>", "void", "ix86_setup_frame_addresses", "(", "void", ")", "{", "cfun", "->", "machine", "->", "accesses_prev_frame", "=", "1", ";", "}", "</s>" ]

[ "Record", "that", "the", "current", "function", "accesses", "previous", "call", "frames", "." ]

[ "i386", "1" ]

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "getAddNoCarry", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "DestReg", ",", "RegScavenger", "&", "RS", ")", "const", "{", "if", "(", "ST", ".", "hasAddNoCarry", "(", ")", ")", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_U32_e32", ")", ",", "DestReg", ")", ";", "Register", "UnusedCarry", "=", "!", "RS", ".", "isRegUsed", "(", "AMDGPU", "::", "VCC", ")", "?", "Register", "(", "RI", ".", "getVCC", "(", ")", ")", ":", "RS", ".", "scavengeRegister", "(", "RI", ".", "getBoolRC", "(", ")", ",", "I", ",", "0", ",", "false", ")", ";", "if", "(", "!", "UnusedCarry", ".", "isValid", "(", ")", ")", "return", "MachineInstrBuilder", "(", ")", ";", "return", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_ADD_I32_e64", ")", ",", "DestReg", ")", ".", "addReg", "(", "UnusedCarry", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ";", "}", "</s>" ]

[ "Return", "a", "partially", "built", "integer", "add", "instruction", "without", "carry", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_ADD_U32_e32", "AMDGPU::VCC", "0", "AMDGPU::V_ADD_I32_e64" ]

[]

[ "<s>", "static", "rtx", "arm_expand_unop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ",", "int", "do_load", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "do_load", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "else", "{", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "}", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Subroutine", "of", "arm_expand_builtin", "to", "take", "care", "of", "unop", "insns", "." ]

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

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Result", "=", "Match_Success", ";", "for", "(", "auto", "Variant", ":", "getMatchedVariants", "(", ")", ")", "{", "uint64_t", "EI", ";", "auto", "R", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "EI", ",", "MatchingInlineAsm", ",", "Variant", ")", ";", "if", "(", "(", "R", "==", "Match_Success", ")", "||", "(", "R", "==", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", "||", "(", "R", "==", "Match_MnemonicFail", "&&", "Result", "!=", "Match_InvalidOperand", "&&", "Result", "!=", "Match_MissingFeature", "&&", "Result", "!=", "Match_PreferE32", ")", ")", "{", "Result", "=", "R", ";", "ErrorInfo", "=", "EI", ";", "}", "if", "(", "R", "==", "Match_Success", ")", "break", ";", "}", "switch", "(", "Result", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_PreferE32", ":", "return", "Error", "(", "IDLoc", ",", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"instruction not supported on this GPU\"", "\"unrecognized instruction mnemonic\"", "0ULL", "\"too few operands for instruction\"", "AMDGPU", "\"invalid operand for instruction\"", "\"internal error: instruction without _e64 suffix \"", "\"should be encoded as e32\"", "\"Implement any new match types added!\"" ]

[]