Datasets:

---

docz1105

/

ComBack

like 10

[ "<s>", "const", "RegisterBankInfo", "*", "getRegBankInfo", "(", ")", "const", "override", "{", "return", "&", "RegBankInfo", ";", "}", "</s>" ]

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

[ "MOS" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "Mask", ",", "int", "&", "Value", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "CMPEHexagon4rr", ":", "case", "Hexagon", "::", "CMPEQri", ":", "case", "Hexagon", "::", "CMPEQrr", ":", "case", "Hexagon", "::", "CMPGT64rr", ":", "case", "Hexagon", "::", "CMPGTU64rr", ":", "case", "Hexagon", "::", "CMPGTUri", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTri", ":", "case", "Hexagon", "::", "CMPGTrr", ":", "case", "Hexagon", "::", "CMPLTUrr", ":", "case", "Hexagon", "::", "CMPLTrr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "~", "0", ";", "break", ";", "case", "Hexagon", "::", "CMPbEQri_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_ubub_V4", ":", "case", "Hexagon", "::", "CMPbGTUri_V4", ":", "case", "Hexagon", "::", "CMPbGTUrr_V4", ":", "case", "Hexagon", "::", "CMPbGTrr_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFF", ";", "break", ";", "case", "Hexagon", "::", "CMPhEQri_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_shl_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_xor_V4", ":", "case", "Hexagon", "::", "CMPhGTUri_V4", ":", "case", "Hexagon", "::", "CMPhGTUrr_V4", ":", "case", "Hexagon", "::", "CMPhGTrr_shl_V4", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Mask", "=", "0xFFFF", ";", "break", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "CMPEHexagon4rr", ":", "case", "Hexagon", "::", "CMPEQrr", ":", "case", "Hexagon", "::", "CMPGT64rr", ":", "case", "Hexagon", "::", "CMPGTU64rr", ":", "case", "Hexagon", "::", "CMPGTUrr", ":", "case", "Hexagon", "::", "CMPGTrr", ":", "case", "Hexagon", "::", "CMPbEQrr_sbsb_V4", ":", "case", "Hexagon", "::", "CMPbEQrr_ubub_V4", ":", "case", "Hexagon", "::", "CMPbGTUrr_V4", ":", "case", "Hexagon", "::", "CMPbGTrr_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_shl_V4", ":", "case", "Hexagon", "::", "CMPhEQrr_xor_V4", ":", "case", "Hexagon", "::", "CMPhGTUrr_V4", ":", "case", "Hexagon", "::", "CMPhGTrr_shl_V4", ":", "case", "Hexagon", "::", "CMPLTUrr", ":", "case", "Hexagon", "::", "CMPLTrr", ":", "SrcReg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "true", ";", "case", "Hexagon", "::", "CMPEQri", ":", "case", "Hexagon", "::", "CMPGTUri", ":", "case", "Hexagon", "::", "CMPGTri", ":", "case", "Hexagon", "::", "CMPbEQri_V4", ":", "case", "Hexagon", "::", "CMPbGTUri_V4", ":", "case", "Hexagon", "::", "CMPhEQri_V4", ":", "case", "Hexagon", "::", "CMPhGTUri_V4", ":", "SrcReg2", "=", "0", ";", "Value", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "Hexagon", "Hexagon", "Hexagon::CMPEHexagon4rr", "Hexagon::CMPEQri", "Hexagon::CMPEQrr", "Hexagon::CMPGT64rr", "Hexagon::CMPGTU64rr", "Hexagon::CMPGTUri", "Hexagon::CMPGTUrr", "Hexagon::CMPGTri", "Hexagon::CMPGTrr", "Hexagon::CMPLTUrr", "Hexagon::CMPLTrr", "1", "0", "Hexagon::CMPbEQri_V4", "Hexagon::CMPbEQrr_sbsb_V4", "Hexagon::CMPbEQrr_ubub_V4", "Hexagon::CMPbGTUri_V4", "Hexagon::CMPbGTUrr_V4", "Hexagon::CMPbGTrr_V4", "1", "0xFF", "Hexagon::CMPhEQri_V4", "Hexagon::CMPhEQrr_shl_V4", "Hexagon::CMPhEQrr_xor_V4", "Hexagon::CMPhGTUri_V4", "Hexagon::CMPhGTUrr_V4", "Hexagon::CMPhGTrr_shl_V4", "1", "0xFFFF", "Hexagon::CMPEHexagon4rr", "Hexagon::CMPEQrr", "Hexagon::CMPGT64rr", "Hexagon::CMPGTU64rr", "Hexagon::CMPGTUrr", "Hexagon::CMPGTrr", "Hexagon::CMPbEQrr_sbsb_V4", "Hexagon::CMPbEQrr_ubub_V4", "Hexagon::CMPbGTUrr_V4", "Hexagon::CMPbGTrr_V4", "Hexagon::CMPhEQrr_shl_V4", "Hexagon::CMPhEQrr_xor_V4", "Hexagon::CMPhGTUrr_V4", "Hexagon::CMPhGTrr_shl_V4", "Hexagon::CMPLTUrr", "Hexagon::CMPLTrr", "2", "Hexagon::CMPEQri", "Hexagon::CMPGTUri", "Hexagon::CMPGTri", "Hexagon::CMPbEQri_V4", "Hexagon::CMPbGTUri_V4", "Hexagon::CMPhEQri_V4", "Hexagon::CMPhGTUri_V4", "0", "2" ]

[]

[ "<s>", "static", "rtx", "tilegx_text_label_rtx", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "text_label_rtx", ";", "}", "</s>" ]

[ "Return", "the", "register", "storing", "the", "value", "of", "the", "text", "label", "." ]

[ "tilegx" ]

[]

[ "<s>", "const", "EpiphanySubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "Epiphany" ]

[]

[ "<s>", "const", "char", "*", "bpf_output_call", "(", "rtx", "target", ")", "{", "rtx", "xops", "[", "1", "]", ";", "switch", "(", "GET_CODE", "(", "target", ")", ")", "{", "case", "CONST_INT", ":", "output_asm_insn", "(", "\"call\\t%0\"", ",", "&", "target", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "target", ")", ";", "tree", "attr", ";", "if", "(", "decl", "&&", "(", "attr", "=", "lookup_attribute", "(", "\"kernel_helper\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", ")", "{", "tree", "attr_args", "=", "TREE_VALUE", "(", "attr", ")", ";", "xops", "[", "0", "]", "=", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "attr_args", ")", ")", ")", ";", "output_asm_insn", "(", "\"call\\t%0\"", ",", "xops", ")", ";", "}", "else", "output_asm_insn", "(", "\"call\\t%0\"", ",", "&", "target", ")", ";", "break", ";", "}", "default", ":", "if", "(", "TARGET_XBPF", ")", "output_asm_insn", "(", "\"call\\t%0\"", ",", "&", "target", ")", ";", "else", "{", "error", "(", "\"indirect call in function, which are not supported by eBPF\"", ")", ";", "output_asm_insn", "(", "\"call 0\"", ",", "NULL", ")", ";", "}", "break", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "instruction", "to", "CALL", "to", "a", "function", ".", "TARGET", "is", "an", "RTX", "denoting", "the", "address", "of", "the", "called", "function", ".", "The", "main", "purposes", "of", "this", "function", "are", ":", "-", "To", "reject", "indirect", "CALL", "instructions", ",", "which", "are", "not", "supported", "by", "eBPF", ".", "-", "To", "recognize", "calls", "to", "kernel", "helper", "functions", "and", "emit", "the", "corresponding", "CALL", "N", "instruction", ".", "This", "function", "is", "called", "from", "the", "expansion", "of", "the", "'call", "'", "pattern", "in", "bpf.md", "." ]

[ "bpf", "1", "\"call\\t%0\"", "\"kernel_helper\"", "0", "\"call\\t%0\"", "\"call\\t%0\"", "\"call\\t%0\"", "\"indirect call in function, which are not supported by eBPF\"", "\"call 0\"", "\"\"" ]

[]

[ "<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "cl", "==", "LPCOUNT_REG", "||", "cl", "==", "WRITABLE_CORE_REGS", ")", "&&", "in_p", "&&", "MEM_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "code", "==", "SUBREG", ")", "{", "rtx", "addr", "=", "NULL_RTX", ";", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x", ")", ")", "{", "int", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "reg_renumber", "[", "regno", "]", ";", "if", "(", "regno", "!=", "-", "1", ")", "return", "NO_REGS", ";", "if", "(", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ")", "{", "rtx", "mem", "=", "reg_equiv_mem", "(", "REGNO", "(", "x", ")", ")", ";", "addr", "=", "find_replacement", "(", "&", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "}", "}", "else", "{", "gcc_assert", "(", "MEM_P", "(", "x", ")", ")", ";", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "addr", "=", "simplify_rtx", "(", "addr", ")", ";", "}", "if", "(", "addr", "&&", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "!", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "addr", ",", "1", ")", ")", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_qi_load", ":", "CODE_FOR_reload_qi_store", ";", "break", ";", "case", "HImode", ":", "sri", "->", "icode", "=", "in_p", "?", "CODE_FOR_reload_hi_load", ":", "CODE_FOR_reload_hi_store", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "." ]

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

[]

[ "<s>", "void", "addLiveInAttr", "(", "unsigned", "VReg", ",", "ISD", "::", "ArgFlagsTy", "Flags", ")", "{", "LiveInAttrs", ".", "push_back", "(", "std", "::", "make_pair", "(", "VReg", ",", "Flags", ")", ")", ";", "}", "</s>" ]

[ "This", "function", "associates", "attributes", "for", "each", "live-in", "virtual", "register", "." ]

[ "PowerPC", "ISD::ArgFlagsTy" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "return", "(", "FuncInfo", "->", "getHasSpills", "(", ")", "||", "FuncInfo", "->", "getHasAllocas", "(", ")", "||", "FuncInfo", "->", "getHasStackArgs", "(", ")", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "void", "rs6000_asm_output_dwarf_datarel", "(", "FILE", "*", "file", ",", "int", "size", ",", "const", "char", "*", "label", ")", "{", "fputs", "(", "integer_asm_op", "(", "size", ",", "FALSE", ")", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "label", ")", ";", "fputs", "(", "\"-__gcc_unwind_dbase\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "a", "symbol", "offset", "relative", "to", "the", "dbase", "for", "the", "current", "object", ".", "We", "use", "__gcc_unwind_dbase", "as", "an", "arbitrary", "base", "for", "dbase", "and", "assume", "signed", "offsets", ".", "__gcc_unwind_dbase", "is", "embedded", "in", "all", "executables/libraries", "through", "libgcc/config/rs6000/crtdbase.S", "." ]

[ "rs6000", "\"-__gcc_unwind_dbase\"" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "_RM", ",", "MipsTargetMachine", "*", "_TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "RM", "(", "_RM", ")", ",", "OverrideMode", "(", "NoOverride", ")", ",", "TM", "(", "_TM", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "PreviousInMips16Mode", "=", "InMips16Mode", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"linux\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "useInlineJumpTables", "(", ")", ")", "{", "return", "MachineJumpTableInfo", "::", "EK_Inline", ";", "}", "else", "{", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "initiate_bundle_states", "(", "void", ")", "{", "bundle_states_num", "=", "0", ";", "free_bundle_state_chain", "=", "NULL", ";", "allocated_bundle_states_chain", "=", "NULL", ";", "}", "</s>" ]

[ "Start", "work", "with", "abstract", "data", "`", "bundle", "states", "'", "." ]

[ "ia64", "0" ]

[]

[ "<s>", "RCPair", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "switch", "(", "Constraint", ".", "size", "(", ")", ")", "{", "case", "1", ":", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'h'", ":", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "hGPRRegClass", ")", ";", "break", ";", "case", "'r'", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPRRegClass", ")", ";", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "GPRRegClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPRRegClass", ")", ";", "break", ";", "case", "'x'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_8RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_8RegClass", ")", ";", "break", ";", "case", "'t'", ":", "if", "(", "VT", "==", "MVT", "::", "Other", ")", "break", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "SPRRegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "DPR_VFP2RegClass", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "QPR_VFP2RegClass", ")", ";", "break", ";", "}", "break", ";", "case", "2", ":", "if", "(", "Constraint", "[", "0", "]", "==", "'T'", ")", "{", "switch", "(", "Constraint", "[", "1", "]", ")", "{", "default", ":", "break", ";", "case", "'e'", ":", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPREvenRegClass", ")", ";", "case", "'o'", ":", "return", "RCPair", "(", "0U", ",", "&", "ARM", "::", "tGPROddRegClass", ")", ";", "}", "}", "break", ";", "default", ":", "break", ";", "}", "if", "(", "StringRef", "(", "\"{cc}\"", ")", ".", "equals_lower", "(", "Constraint", ")", ")", "return", "std", "::", "make_pair", "(", "unsigned", "(", "ARM", "::", "CPSR", ")", ",", "&", "ARM", "::", "CCRRegClass", ")", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "0U", "ARM::hGPRRegClass", "0U", "ARM::tGPRRegClass", "0U", "ARM::GPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPRRegClass", "128", "0U", "ARM::QPRRegClass", "MVT::Other", "MVT::f32", "0U", "ARM::SPR_8RegClass", "64", "0U", "ARM::DPR_8RegClass", "128", "0U", "ARM::QPR_8RegClass", "MVT::Other", "MVT::f32", "MVT::i32", "0U", "ARM::SPRRegClass", "64", "0U", "ARM::DPR_VFP2RegClass", "128", "0U", "ARM::QPR_VFP2RegClass", "2", "0", "1", "0U", "ARM::tGPREvenRegClass", "0U", "ARM::tGPROddRegClass", "\"{cc}\"", "ARM::CPSR", "ARM::CCRRegClass" ]

[]

[ "<s>", "static", "inline", "int", "and_xor_ior_costs", "(", "rtx", "x", ",", "int", "code", ")", "{", "const", "int", "cost_scale", "=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", "?", "2", ":", "1", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "1", "*", "cost_scale", ";", "int", "i", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "(", "i", "==", "0xff", "||", "i", "==", "0xffff", ")", "&&", "code", "==", "AND", ")", "return", "1", "*", "cost_scale", ";", "if", "(", "CONST_OK_FOR_K08", "(", "i", ")", ")", "return", "2", "*", "cost_scale", ";", "if", "(", "CONST_OK_FOR_I08", "(", "i", ")", ")", "return", "2", "*", "cost_scale", ";", "return", "3", "*", "cost_scale", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "an", "AND/XOR/IOR", "operation", "." ]

[ "sh", "2", "1", "1", "1", "1", "0xff", "0xffff", "1", "2", "2", "3" ]

[]

[ "<s>", "MachineBasicBlock", "*", "AMDGPUCFGStructurizer", "::", "clone", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "MachineFunction", "*", "Func", "=", "MBB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "NewMBB", "=", "Func", "->", "CreateMachineBasicBlock", "(", ")", ";", "Func", "->", "push_back", "(", "NewMBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "It", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "MachineInstr", "*", "MI", "=", "Func", "->", "CloneMachineInstr", "(", "It", ")", ";", "NewMBB", "->", "push_back", "(", "MI", ")", ";", "}", "return", "NewMBB", ";", "}", "</s>" ]

[ "Make", "a", "functionally", "equivalent", "copy", "of", "this", "MachineFunctionInfo", "in", "MF", "." ]

[ "R600" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "replaceBranchWithTailCall", "(", "MachineBasicBlock", "&", "MBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "BranchCond", ",", "const", "MachineInstr", "&", "TailCall", ")", "const", "{", "assert", "(", "canMakeTailCallConditional", "(", "BranchCond", ",", "TailCall", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "assert", "(", "0", "&&", "\"Can't find the branch to replace!\"", ")", ";", "X86", "::", "CondCode", "CC", "=", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "BranchCond", ".", "size", "(", ")", "==", "1", ")", ";", "if", "(", "CC", "!=", "BranchCond", "[", "0", "]", ".", "getImm", "(", ")", ")", "continue", ";", "break", ";", "}", "unsigned", "Opc", "=", "TailCall", ".", "getOpcode", "(", ")", "==", "X86", "::", "TCRETURNdi", "?", "X86", "::", "TCRETURNdicc", ":", "X86", "::", "TCRETURNdi64cc", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opc", ")", ")", ";", "MIB", "->", "addOperand", "(", "TailCall", ".", "getOperand", "(", "0", ")", ")", ";", "MIB", ".", "addImm", "(", "0", ")", ";", "MIB", "->", "addOperand", "(", "BranchCond", "[", "0", "]", ")", ";", "MIB", ".", "copyImplicitOps", "(", "TailCall", ")", ";", "LivePhysRegs", "LiveRegs", "(", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "MBB", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "MachineOperand", "*", ">", ",", "8", ">", "Clobbers", ";", "LiveRegs", ".", "stepForward", "(", "*", "MIB", ",", "Clobbers", ")", ";", "for", "(", "const", "auto", "&", "C", ":", "Clobbers", ")", "{", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Define", ")", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "Replace", "the", "conditional", "branch", "in", "MBB", "with", "a", "conditional", "tail", "call", "." ]

[ "X86", "X86", "0", "\"Can't find the branch to replace!\"", "X86::CondCode", "1", "0", "X86::TCRETURNdi", "X86::TCRETURNdicc", "X86::TCRETURNdi64cc", "0", "0", "0", "8" ]

[]

[ "<s>", "Sched", "::", "Preference", "PPCTargetLowering", "::", "getSchedulingPreference", "(", "SDNode", "*", "N", ")", "const", "{", "unsigned", "Directive", "=", "PPCSubTarget", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", ")", "return", "Sched", "::", "ILP", ";", "return", "TargetLowering", "::", "getSchedulingPreference", "(", "N", ")", ";", "}", "</s>" ]

[ "Some", "scheduler", ",", "e.g", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2" ]

[]

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

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

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

[]

[ "<s>", "static", "char", "*", "detect_caches_freebsd", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "size_t", "len", "=", "4", ";", "sysctlbyname", "(", "\"machdep.cacheline_size\"", ",", "&", "l1_line", ",", "&", "len", ",", "NULL", ",", "0", ")", ";", "l1_sizekb", "=", "32", ";", "l1_assoc", "=", "0", ";", "l2_sizekb", "=", "512", ";", "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "on", "FreeBSD", "PPC", "." ]

[ "rs6000", "4", "\"machdep.cacheline_size\"", "0", "32", "0", "512" ]

[]

[ "<s>", "void", "WebAssemblyFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "uint64_t", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "if", "(", "!", "needsSP", "(", "MF", ")", "||", "!", "needsSPWriteback", "(", "MF", ")", ")", "return", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "InsertPt", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "InsertPt", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "InsertPt", "->", "getDebugLoc", "(", ")", ";", "unsigned", "SPReg", "=", "0", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "{", "auto", "FI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "SPReg", "=", "FI", "->", "getBasePointerVreg", "(", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "const", "TargetRegisterClass", "*", "PtrRC", "=", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getPointerRegClass", "(", "MF", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "CONST_I32", ")", ",", "OffsetReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "SPReg", "=", "MRI", ".", "createVirtualRegister", "(", "PtrRC", ")", ";", "BuildMI", "(", "MBB", ",", "InsertPt", ",", "DL", ",", "TII", "->", "get", "(", "WebAssembly", "::", "ADD_I32", ")", ",", "SPReg", ")", ".", "addReg", "(", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ")", ".", "addReg", "(", "OffsetReg", ")", ";", "}", "else", "{", "SPReg", "=", "hasFP", "(", "MF", ")", "?", "WebAssembly", "::", "FP32", ":", "WebAssembly", "::", "SP32", ";", "}", "writeSPToGlobal", "(", "SPReg", ",", "MF", ",", "MBB", ",", "InsertPt", ",", "DL", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "0", "WebAssembly", "WebAssembly::CONST_I32", "WebAssembly::ADD_I32", "WebAssembly::FP32", "WebAssembly::SP32", "WebAssembly::FP32", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "AArch64TTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_ld2", ":", "case", "Intrinsic", "::", "aarch64_neon_ld3", ":", "case", "Intrinsic", "::", "aarch64_neon_ld4", ":", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "false", ";", "Info", ".", "Vol", "=", "false", ";", "Info", ".", "NumMemRefs", "=", "1", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_st2", ":", "case", "Intrinsic", "::", "aarch64_neon_st3", ":", "case", "Intrinsic", "::", "aarch64_neon_st4", ":", "Info", ".", "ReadMem", "=", "false", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "Vol", "=", "false", ";", "Info", ".", "NumMemRefs", "=", "1", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "Inst", "->", "getNumArgOperands", "(", ")", "-", "1", ")", ";", "break", ";", "}", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "aarch64_neon_ld2", ":", "case", "Intrinsic", "::", "aarch64_neon_st2", ":", "Info", ".", "MatchingId", "=", "VECTOR_LDST_TWO_ELEMENTS", ";", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_ld3", ":", "case", "Intrinsic", "::", "aarch64_neon_st3", ":", "Info", ".", "MatchingId", "=", "VECTOR_LDST_THREE_ELEMENTS", ";", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_ld4", ":", "case", "Intrinsic", "::", "aarch64_neon_st4", ":", "Info", ".", "MatchingId", "=", "VECTOR_LDST_FOUR_ELEMENTS", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AArch64", "AArch64", "Intrinsic::aarch64_neon_ld2", "Intrinsic::aarch64_neon_ld3", "Intrinsic::aarch64_neon_ld4", "1", "0", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_st4", "1", "1", "Intrinsic::aarch64_neon_ld2", "Intrinsic::aarch64_neon_st2", "Intrinsic::aarch64_neon_ld3", "Intrinsic::aarch64_neon_st3", "Intrinsic::aarch64_neon_ld4", "Intrinsic::aarch64_neon_st4" ]

[]

[ "<s>", "bool", "SPIRVPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "SPIRVInstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "Z80TargetLowering", "::", "IsDesirableToPromoteOp", "(", "SDValue", "Op", ",", "EVT", "&", "PVT", ")", "const", "{", "if", "(", "isDesirableToShrinkOp", "(", "Op", ".", "getOpcode", "(", ")", ",", "MVT", "::", "i24", ",", "Op", ".", "getValueType", "(", ")", ")", ")", "return", "false", ";", "PVT", "=", "MVT", "::", "i24", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "." ]

[ "Z80", "Z80", "MVT::i24", "MVT::i24" ]

[]

[ "<s>", "bool", "RV16KExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "RV16KInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MBBI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MBBI", ")", "{", "Modified", "|=", "expandBccPseudo", "(", "MBB", ",", "MBBI", ")", ";", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K", "RV16K" ]

[]

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

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

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVSX64rr32", "0", "1", "1", "0", "\"Unreachable!\"", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::sub_8bit", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::sub_16bit", "X86::MOVSX64rr32", "X86::sub_32bit" ]

[]

[ "<s>", "bool", "Z80FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "UseShadow", "=", "shouldUseShadow", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "UseShadow", "&&", "!", "Z80", "::", "I24RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "Z80", "::", "I16RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MachineInstrBuilder", "MIB", ";", "if", "(", "Reg", "==", "Z80", "::", "AF", ")", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "POP24AF", ":", "Z80", "::", "POP16AF", ")", ")", ";", "else", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "POP24r", ":", "Z80", "::", "POP16r", ")", ",", "Reg", ")", ";", "MIB", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "UseShadow", ")", "shadowCalleeSavedRegisters", "(", "MBB", ",", "MI", ",", "DL", ",", "MachineInstr", "::", "FrameDestroy", ",", "CSI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "0", "Z80::I24RegClass", "Z80::I16RegClass", "Z80::AF", "Z80::POP24AF", "Z80::POP16AF", "Z80::POP24r", "Z80::POP16r" ]

[]

[ "<s>", "MCallGraph", "*", "getCallGraph", "(", ")", "{", "return", "&", "MCG", ";", "}", "</s>" ]

[ "The", "internal", "CallGraph", "around", "which", "the", "rest", "of", "this", "interface", "is", "wrapped", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "bool", "isReturnBlock", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "{", "for", "(", "auto", "MI", "=", "MBB", "->", "begin", "(", ")", ",", "ME", "=", "MBB", "->", "end", "(", ")", ";", "MI", "!=", "ME", ";", "MI", "++", ")", "if", "(", "MI", "->", "isReturn", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Convenience", "function", "that", "returns", "true", "if", "the", "block", "ends", "in", "a", "return", "instruction", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "mem_operand_gpr", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "GET_CODE", "(", "addr", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "addr", ")", "==", "PRE_DEC", ")", "&&", "mode_supports_pre_incdec_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "false", ")", ")", "return", "true", ";", "if", "(", "!", "rs6000_offsettable_memref_p", "(", "op", ",", "mode", ",", "false", ")", ")", "return", "false", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "offset", "&", "3", ")", "!=", "0", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "0", ")", "extra", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "return", "offset", "+", "0x8000", "<", "0x10000u", "-", "extra", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "MEM", "operand", "is", "a", "memory", "operand", "suitable", "for", "use", "with", "a", "(", "full", "width", ",", "possibly", "multiple", ")", "gpr", "load/store", ".", "On", "powerpc64", "this", "means", "the", "offset", "must", "be", "divisible", "by", "4", ".", "Implements", "'", "Y", "'", "constraint", ".", "Accept", "direct", ",", "indexed", ",", "offset", ",", "lo_sum", "and", "tocref", ".", "Since", "this", "is", "a", "constraint", "function", "we", "know", "the", "operand", "has", "satisfied", "a", "suitable", "memory", "predicate", ".", "Offsetting", "a", "lo_sum", "should", "not", "be", "allowed", ",", "except", "where", "we", "know", "by", "alignment", "that", "a", "32k", "boundary", "is", "not", "crossed", ".", "Note", "that", "by", "``", "offsetting", "''", "here", "we", "mean", "a", "further", "offset", "to", "access", "parts", "of", "the", "MEM", ".", "It", "'s", "fine", "to", "have", "a", "lo_sum", "where", "the", "inner", "address", "is", "offset", "from", "a", "sym", ",", "since", "the", "same", "sym+offset", "will", "appear", "in", "the", "high", "part", "of", "the", "address", "calculation", "." ]

[ "rs6000", "0", "0", "3", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0x8000", "0x10000u" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "FindSwizzleForVectorSlot", "(", "const", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", ">", "&", "IGSrcs", ",", "std", "::", "vector", "<", "R600InstrInfo", "::", "BankSwizzle", ">", "&", "SwzCandidate", ",", "const", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", "&", "TransSrcs", ",", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", ")", "const", "{", "unsigned", "ValidUpTo", "=", "0", ";", "do", "{", "ValidUpTo", "=", "isLegalUpTo", "(", "IGSrcs", ",", "SwzCandidate", ",", "TransSrcs", ",", "TransSwz", ")", ";", "if", "(", "ValidUpTo", "==", "IGSrcs", ".", "size", "(", ")", ")", "return", "true", ";", "}", "while", "(", "NextPossibleSolution", "(", "SwzCandidate", ",", "ValidUpTo", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Enumerate", "all", "possible", "Swizzle", "sequence", "to", "find", "one", "that", "can", "meet", "all", "read", "port", "requirements", "." ]

[ "R600", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "OpNum", "!=", "0", "||", "!", "hasPartialRegUpdate", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "if", "(", "MO", ".", "readsReg", "(", ")", "||", "MI", "->", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "{", "if", "(", "MI", "->", "readsRegister", "(", "Reg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "16", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

[ "X86", "X86", "0", "0", "0", "0", "0", "16" ]

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "bool", "VERegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "switch", "(", "PhysReg", ")", "{", "case", "VE", "::", "VM0", ":", "case", "VE", "::", "VMP0", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "PhysReg", "is", "unallocatable", "and", "constant", "throughout", "the", "function", "." ]

[ "VE", "VE", "VE::VM0", "VE::VMP0" ]

[]

[ "<s>", "PredicatedBlock", "*", "SPScope", "::", "getHeader", "(", ")", "const", "{", "return", "Priv", "->", "Blocks", ".", "front", "(", ")", ";", "}", "</s>" ]

[ "The", "header", "is", "the", "entry", "for", "each", "iteration", "." ]

[ "Patmos" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "unsigned", "getReg", "(", "const", "void", "*", "D", ",", "unsigned", "RC", ",", "unsigned", "RegNo", ")", "{", "const", "AArch64Disassembler", "*", "Dis", "=", "static_cast", "<", "const", "AArch64Disassembler", "*", ">", "(", "D", ")", ";", "return", "Dis", "->", "getRegInfo", "(", ")", "->", "getRegClass", "(", "RC", ")", ".", "getRegister", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

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

[]

[ "<s>", "bool", "TOYTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "!", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_TOY", ")", ")", "{", "return", "false", ";", "}", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", "&&", "isVarArg", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "ISD::OutputArg", "16", "TOY", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "RegName", "=", "[", "]", "(", "unsigned", "Reg", ")", "{", "if", "(", "Reg", ")", "return", "CSKYInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "else", "return", "\"noreg\"", ";", "}", ";", "switch", "(", "Kind", ")", "{", "case", "CPOP", ":", "OS", "<<", "*", "getConstpoolOp", "(", ")", ";", "break", ";", "case", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"<register \"", "<<", "RegName", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "RegisterSeq", ":", "OS", "<<", "\"<register-seq \"", ";", "OS", "<<", "RegName", "(", "getRegSeq", "(", ")", ".", "first", ")", "<<", "\"-\"", "<<", "RegName", "(", "getRegSeq", "(", ")", ".", "second", ")", "<<", "\">\"", ";", "break", ";", "case", "RegisterList", ":", "OS", "<<", "\"<register-list \"", ";", "OS", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List1From", ")", "<<", "\"-\"", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List1To", ")", "<<", "\",\"", ";", "OS", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List2From", ")", "<<", "\"-\"", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List2To", ")", "<<", "\",\"", ";", "OS", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List3From", ")", "<<", "\"-\"", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List3To", ")", "<<", "\",\"", ";", "OS", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List4From", ")", "<<", "\"-\"", "<<", "RegName", "(", "getRegList", "(", ")", ".", "List4To", ")", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\"noreg\"", "\"<register \"", "\">\"", "\"<register-seq \"", "\"-\"", "\">\"", "\"<register-list \"", "\"-\"", "\",\"", "\"-\"", "\",\"", "\"-\"", "\",\"", "\"-\"", "\"'\"", "\"'\"" ]

[]

[ "<s>", "bool", "isVector", "(", ")", "const", "{", "llvm_unreachable", "(", "\"unimplemented\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Vector", "instructions", "are", "instructions", "that", "must", "fill", "all", "instruction", "slots", "within", "an", "instruction", "group", "." ]

[ "Videocore", "\"unimplemented\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ",", "2", ")", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "(", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ",", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "0", "]", ")", "->", "getLocRange", "(", ")", ")", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "case", "Match_ImmRange0_15", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,15]\"", ")", ";", "}", "case", "Match_ImmRange0_239", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,239]\"", ")", ";", "}", "}", "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", "." ]

[ "ARM", "ARM", "2", "\"deprecated instruction in IT block\"", "ARM::ITasm", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "ARM", "0", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "ARM", "\"immediate operand must be in the range [0,15]\"", "ARM", "\"immediate operand must be in the range [0,239]\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "MRI", "->", "canReserveReg", "(", "FramePtr", ")", ")", "return", "false", ";", "if", "(", "CantUseSP", "(", "MFI", ")", ")", "return", "MRI", "->", "canReserveReg", "(", "BasePtr", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printSymbol", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ",", "bool", "hi", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "O", "<<", "'#'", "<<", "(", "hi", "?", "\"HI\"", ":", "\"LO\"", ")", "<<", "'('", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "O", "<<", "'#'", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "}", "else", "{", "assert", "(", "\"Unknown symbol operand\"", ")", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "}", "O", "<<", "')'", ";", "}", "</s>" ]

[ "Print", "a", "MCSymbol", "as", "an", "operand", "." ]

[ "Hexagon", "Hexagon", "\"HI\"", "\"LO\"", "\"Unknown symbol operand\"" ]

[]

[ "<s>", "virtual", "void", "releaseTopNode", "(", "SUnit", "*", "SU", ")", "{", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "void", "sparc_initialize_trampoline", "(", "rtx", "tramp", ",", "rtx", "fnaddr", ",", "rtx", "cxt", ")", "{", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "0", ")", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "fnaddr", ",", "size_int", "(", "10", ")", ",", "0", ",", "1", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x03000000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "4", ")", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_shift", "(", "RSHIFT_EXPR", ",", "SImode", ",", "cxt", ",", "size_int", "(", "10", ")", ",", "0", ",", "1", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x05000000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "8", ")", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_and", "(", "SImode", ",", "fnaddr", ",", "GEN_INT", "(", "0x3ff", ")", ",", "NULL_RTX", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x81c06000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "12", ")", ")", ",", "expand_binop", "(", "SImode", ",", "ior_optab", ",", "expand_and", "(", "SImode", ",", "cxt", ",", "GEN_INT", "(", "0x3ff", ")", ",", "NULL_RTX", ")", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "0x8410a000", ",", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_insn", "(", "gen_flush", "(", "validize_mem", "(", "gen_rtx_MEM", "(", "SImode", ",", "tramp", ")", ")", ")", ")", ";", "if", "(", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC", "&&", "sparc_cpu", "!=", "PROCESSOR_ULTRASPARC3", ")", "emit_insn", "(", "gen_flush", "(", "validize_mem", "(", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "tramp", ",", "8", ")", ")", ")", ")", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__enable_execute_stack\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "tramp", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", ".", "This", "takes", "16", "insns", ":", "2", "shifts", "&", "2", "ands", "(", "to", "split", "up", "addresses", ")", ",", "4", "sethi", "(", "to", "load", "in", "opcodes", ")", ",", "4", "iors", "(", "to", "merge", "address", "and", "opcodes", ")", ",", "and", "4", "writes", "(", "to", "store", "insns", ")", ".", "This", "is", "a", "bit", "excessive", ".", "Perhaps", "a", "different", "mechanism", "would", "be", "better", "here", ".", "Emit", "enough", "FLUSH", "insns", "to", "synchronize", "the", "data", "and", "instruction", "caches", "." ]

[ "sparc", "0", "10", "0", "1", "0x03000000", "1", "4", "10", "0", "1", "0x05000000", "1", "8", "0x3ff", "0x81c06000", "1", "12", "0x3ff", "0x8410a000", "1", "8", "\"__enable_execute_stack\"", "1" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "else", "{", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot have arguments\"" ]

[]

[ "<s>", "bool", "MipsConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "MCP", "=", "mf", ".", "getConstantPool", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island machine function \"", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", "||", "!", "MipsSubtarget", "::", "useConstantIslands", "(", ")", ")", "{", "return", "false", ";", "}", "TII", "=", "(", "const", "MipsInstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"constant island processing \"", "<<", "\"\\n\"", ")", ";", "prescanForConstants", "(", ")", ";", "MF", "->", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", "->", "isEmpty", "(", ")", ")", "doInitialPlacement", "(", "CPEMIs", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"constant island machine function \"", "\"\\n\"", "Mips", "Mips", "Mips", "Mips", "\"constant island processing \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getUnits", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "TargetSubtargetInfo", "&", "ST", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ";", "const", "InstrItineraryData", "&", "II", "=", "*", "ST", ".", "getInstrItineraryData", "(", ")", ";", "const", "InstrStage", "&", "IS", "=", "*", "II", ".", "beginStage", "(", "MI", "->", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ")", ";", "return", "IS", ".", "getUnits", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "choice", "of", "FUs", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "DLXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestinationRegister", ",", "unsigned", "SourceRegister", ",", "bool", "KillSource", ")", "const", "{", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "bool", "aarch64_handle_attr_isa_flags", "(", "char", "*", "str", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", ";", "unsigned", "long", "isa_flags", "=", "aarch64_isa_flags", ";", "if", "(", "strncmp", "(", "\"+nothing\"", ",", "str", ",", "8", ")", "==", "0", ")", "{", "isa_flags", "=", "0", ";", "str", "+=", "8", ";", "}", "std", "::", "string", "invalid_extension", ";", "parse_res", "=", "aarch64_parse_extension", "(", "str", ",", "&", "isa_flags", ",", "&", "invalid_extension", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "aarch64_isa_flags", "=", "isa_flags", ";", "return", "true", ";", "}", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing value in %<target()%> pragma or attribute\"", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier %s of value (\\\"%s\\\") in \"", "\"%<target()%> pragma or attribute\"", ",", "invalid_extension", ".", "c_str", "(", ")", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Parse", "an", "architecture", "extensions", "target", "attribute", "string", "specified", "in", "STR", ".", "For", "example", "``", "+fp+nosimd", "''", ".", "Show", "any", "errors", "if", "needed", ".", "Return", "TRUE", "if", "successful", ".", "Update", "aarch64_isa_flags", "to", "reflect", "the", "ISA", "features", "modified", ".", "PRAGMA_OR_ATTR", "is", "used", "in", "potential", "error", "messages", "." ]

[ "aarch64", "\"+nothing\"", "8", "0", "0", "8", "\"missing value in %<target()%> pragma or attribute\"", "\"invalid feature modifier %s of value (\\\"%s\\\") in \"", "\"%<target()%> pragma or attribute\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "ErrorInfo", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_ConversionFail", ":", "return", "true", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "}", "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", "." ]

[ "ARM", "ARM", "ARM::ITasm", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "HasDebugInfo", "=", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", ";", "if", "(", "!", "GlobalsEmitted", ")", "{", "emitGlobals", "(", "M", ")", ";", "GlobalsEmitted", "=", "true", ";", "}", "bool", "ret", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "clearAnnotationCache", "(", "&", "M", ")", ";", "if", "(", "HasDebugInfo", ")", "{", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "closeLastSection", "(", ")", ";", "OutStreamer", "->", "emitRawText", "(", "\"\\t.section\\t.debug_loc\\t{\\t}\"", ")", ";", "}", "static_cast", "<", "NVPTXTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", "->", "outputDwarfFileDirectives", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "\"\\t.section\\t.debug_loc\\t{\\t}\"", "NVPTX" ]

[]

[ "<s>", "static", "X86Operand", "CreateReg", "(", "unsigned", "RegNo", ")", "{", "X86Operand", "Res", ";", "Res", ".", "Kind", "=", "Register", ";", "Res", ".", "Reg", ".", "RegNo", "=", "RegNo", ";", "return", "Res", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "char", "*", "construct_save_jarl", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "255", "]", ";", "if", "(", "count", "<=", "(", "TARGET_LONG_CALLS", "?", "3", ":", "2", ")", ")", "{", "error", "(", "\"bogus JARL construction: %d\"", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "0", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", ";", "stack_bytes", "+=", "(", "count", "-", "(", "TARGET_LONG_CALLS", "?", "4", ":", "3", ")", ")", "*", "4", ";", "if", "(", "stack_bytes", "!=", "0", ")", "{", "error", "(", "\"bad amount of stack space removal: %d\"", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", "-", "(", "TARGET_LONG_CALLS", "?", "3", ":", "2", ")", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_SRC", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "1", "<<", "REGNO", "(", "SET_SRC", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "0", ";", "first", "<", "32", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "32", ")", ";", "if", "(", "mask", "&", "(", "1", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "1", "<<", "29", ")", ")", ";", "last", "=", "29", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "40", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "\"__save_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "\"__save_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "if", "(", "TARGET_V850E3V5_UP", ")", "sprintf", "(", "buff", ",", "\"mov hilo(%s), r11\\n\\tjarl [r11], r10\"", ",", "name", ")", ";", "else", "sprintf", "(", "buff", ",", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "\"jarl __save_%s, r10\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "\"jarl __save_%s_%s, r10\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Construct", "a", "JARL", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "as", "a", "parameter", ".", "This", "RTL", "is", "a", "function", "prologue", "that", "saves", "some", "of", "the", "registers", "r20", "-", "r31", "onto", "the", "stack", ",", "and", "possibly", "acquires", "some", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "v850", "0", "255", "3", "2", "\"bogus JARL construction: %d\"", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "4", "3", "4", "0", "\"bad amount of stack space removal: %d\"", "0", "1", "3", "2", "0", "1", "0", "32", "1", "32", "1", "1", "29", "29", "40", "\"__save_%s\"", "\"__save_%s_%s\"", "\"mov hilo(%s), r11\\n\\tjarl [r11], r10\"", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", "\"jarl __save_%s, r10\"", "\"jarl __save_%s_%s, r10\"" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ";", "++", "I", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SystemZOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "SystemZ", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"Unexpected match type\"" ]

[]

[ "<s>", "static", "int", "rs6000_use_sched_lookahead", "(", "void", ")", "{", "switch", "(", "rs6000_tune", ")", "{", "case", "PROCESSOR_PPC8540", ":", "case", "PROCESSOR_PPC8548", ":", "return", "4", ";", "case", "PROCESSOR_CELL", ":", "return", "(", "reload_completed", "?", "8", ":", "0", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "to", "look", "ahead", "for", "better", "insn", "scheduling", "." ]

[ "rs6000", "4", "8", "0", "0" ]

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "int64_t", "invflag", "=", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ";", "Cond", "[", "1", "]", ".", "setImm", "(", "(", "invflag", ")", "?", "0", ":", "-", "1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "1", "1", "0", "1" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">>", "SIInstrInfo", "::", "getSerializableTargetIndices", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">", "TargetIndices", "[", "]", "=", "{", "{", "AMDGPU", "::", "TI_CONSTDATA_START", ",", "\"amdgpu-constdata-start\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD0", ",", "\"amdgpu-scratch-rsrc-dword0\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD1", ",", "\"amdgpu-scratch-rsrc-dword1\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD2", ",", "\"amdgpu-scratch-rsrc-dword2\"", "}", ",", "{", "AMDGPU", "::", "TI_SCRATCH_RSRC_DWORD3", ",", "\"amdgpu-scratch-rsrc-dword3\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetIndices", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "ids", "of", "the", "target", "indices", "(", "used", "for", "the", "TargetIndex", "machine", "operand", ")", "and", "their", "names", "." ]

[ "AMDGPU", "SI", "AMDGPU::TI_CONSTDATA_START", "\"amdgpu-constdata-start\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD0", "\"amdgpu-scratch-rsrc-dword0\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD1", "\"amdgpu-scratch-rsrc-dword1\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD2", "\"amdgpu-scratch-rsrc-dword2\"", "AMDGPU::TI_SCRATCH_RSRC_DWORD3", "\"amdgpu-scratch-rsrc-dword3\"" ]

[]

[ "<s>", "void", "MSP430InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "Op", ".", "isMemset", "(", ")", "&&", "Op", ".", "size", "(", ")", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "Align", "AlignCheck", ")", "{", "if", "(", "Op", ".", "isAligned", "(", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "1", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "Op", ".", "isMemset", "(", ")", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "Align", "(", "16", ")", ")", ")", "return", "MVT", "::", "v2i64", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "Align", "(", "16", ")", ")", ")", "return", "MVT", "::", "f128", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "Align", "(", "8", ")", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "Align", "(", "4", ")", ")", ")", "return", "MVT", "::", "i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "MVT::v2i64", "MVT::f128", "16", "MVT::f128", "8", "MVT::i64", "8", "MVT::i64", "4", "MVT::i32", "4", "MVT::i32", "MVT::Other" ]

[]

[ "<s>", "static", "void", "aarch64_finish_cost", "(", "void", "*", "data", ",", "unsigned", "*", "prologue_cost", ",", "unsigned", "*", "body_cost", ",", "unsigned", "*", "epilogue_cost", ")", "{", "auto", "*", "costs", "=", "static_cast", "<", "aarch64_vector_costs", "*", ">", "(", "data", ")", ";", "*", "prologue_cost", "=", "costs", "->", "region", "[", "vect_prologue", "]", ";", "*", "body_cost", "=", "costs", "->", "region", "[", "vect_body", "]", ";", "*", "epilogue_cost", "=", "costs", "->", "region", "[", "vect_epilogue", "]", ";", "if", "(", "costs", "->", "is_loop", "&&", "costs", "->", "vec_flags", "&&", "aarch64_use_new_vector_costs_p", "(", ")", ")", "*", "body_cost", "=", "aarch64_adjust_body_cost", "(", "costs", ",", "*", "body_cost", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_FINISH_COST", "." ]

[ "aarch64" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64FastISel", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "WebKit_JS", ")", "return", "CC_AArch64_WebKit_JS", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CC_AArch64_GHC", ";", "return", "Subtarget", "->", "isTargetDarwin", "(", ")", "?", "CC_AArch64_DarwinPCS", ":", "CC_AArch64_AAPCS", ";", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

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

[]

[ "<s>", "static", "bool", "alpha_vms_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "alpha_sa_size", "(", ")", ";", "switch", "(", "alpha_procedure_type", ")", "{", "case", "PT_NULL", ":", "return", "to", "==", "STACK_POINTER_REGNUM", ";", "case", "PT_REGISTER", ":", "case", "PT_STACK", ":", "return", "(", "to", "!=", "STACK_POINTER_REGNUM", "||", "vms_unwind_regno", "!=", "HARD_FRAME_POINTER_REGNUM", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

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

[ "alpha" ]

[]

[ "<s>", "void", "MipsTargetMachine", "::", "resetSubtarget", "(", "MachineFunction", "*", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"resetSubtarget\\n\"", ")", ";", "Subtarget", "=", "const_cast", "<", "MipsSubtarget", "*", ">", "(", "getSubtargetImpl", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", ";", "MF", "->", "setSubtarget", "(", "Subtarget", ")", ";", "return", ";", "}", "</s>" ]

[ "Reset", "the", "subtarget", "for", "the", "Mips", "target", "." ]

[ "Mips", "Mips", "\"resetSubtarget\\n\"", "Mips" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "MCInst", "const", "&", "MCB", "=", "DF", "->", "getInst", "(", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "MCInst", "&", "MCI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "HexagonMCInstrInfo", "::", "instruction", "(", "MCB", ",", "Fixup", ".", "getOffset", "(", ")", "/", "HEXAGON_INSTR_SIZE", ")", ")", ";", "if", "(", "!", "Resolved", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "fixup_Hexagon_B22_PCREL", ":", "default", ":", "return", "false", ";", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "break", ";", "}", "}", "}", "bool", "Relaxable", "=", "isInstRelaxable", "(", "MCI", ")", ";", "if", "(", "Relaxable", "==", "false", ")", "return", "false", ";", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "sValue", "=", "Value", ";", "int64_t", "maxValue", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "fixup_Hexagon_B7_PCREL", ":", "maxValue", "=", "1", "<<", "8", ";", "break", ";", "case", "fixup_Hexagon_B9_PCREL", ":", "maxValue", "=", "1", "<<", "10", ";", "break", ";", "case", "fixup_Hexagon_B15_PCREL", ":", "maxValue", "=", "1", "<<", "16", ";", "break", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "maxValue", "=", "1", "<<", "23", ";", "break", ";", "default", ":", "maxValue", "=", "INT64_MAX", ";", "break", ";", "}", "bool", "isFarAway", "=", "-", "maxValue", ">", "sValue", "||", "sValue", ">", "maxValue", "-", "1", ";", "if", "(", "isFarAway", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "8", "Hexagon", "1", "10", "Hexagon", "1", "16", "Hexagon", "1", "23", "1", "Hexagon" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createHexagonELFObjectWriter", "(", "OS", ",", "OSABI", ",", "CPU", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "CreateMem", "(", "OwningPtr", "<", "ARMOperand", ">", "&", "Op", ",", "unsigned", "BaseRegNum", ",", "bool", "OffsetIsReg", ",", "const", "MCExpr", "*", "Offset", ",", "unsigned", "OffsetRegNum", ",", "bool", "OffsetRegShifted", ",", "enum", "ShiftType", "ShiftType", ",", "const", "MCExpr", "*", "ShiftAmount", ",", "bool", "Preindexed", ",", "bool", "Postindexed", ",", "bool", "Negative", ",", "bool", "Writeback", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "Op", ".", "reset", "(", "new", "ARMOperand", ")", ";", "Op", "->", "Kind", "=", "Memory", ";", "Op", "->", "Mem", ".", "BaseRegNum", "=", "BaseRegNum", ";", "Op", "->", "Mem", ".", "OffsetIsReg", "=", "OffsetIsReg", ";", "Op", "->", "Mem", ".", "Offset", "=", "Offset", ";", "Op", "->", "Mem", ".", "OffsetRegNum", "=", "OffsetRegNum", ";", "Op", "->", "Mem", ".", "OffsetRegShifted", "=", "OffsetRegShifted", ";", "Op", "->", "Mem", ".", "ShiftType", "=", "ShiftType", ";", "Op", "->", "Mem", ".", "ShiftAmount", "=", "ShiftAmount", ";", "Op", "->", "Mem", ".", "Preindexed", "=", "Preindexed", ";", "Op", "->", "Mem", ".", "Postindexed", "=", "Postindexed", ";", "Op", "->", "Mem", ".", "Negative", "=", "Negative", ";", "Op", "->", "Mem", ".", "Writeback", "=", "Writeback", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

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

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "static", "const", "char", "*", "const", "CPUDirectives", "[", "]", "=", "{", "\"\"", ",", "\"ppc\"", ",", "\"ppc601\"", ",", "\"ppc602\"", ",", "\"ppc603\"", ",", "\"ppc7400\"", ",", "\"ppc750\"", ",", "\"ppc970\"", ",", "\"ppc64\"", "}", ";", "unsigned", "Directive", "=", "Subtarget", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Subtarget", ".", "isGigaProcessor", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_970", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_7400", ")", "Directive", "=", "PPC", "::", "DIR_7400", ";", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Directive", "<", "PPC", "::", "DIR_970", ")", "Directive", "=", "PPC", "::", "DIR_64", ";", "assert", "(", "Directive", "<=", "PPC", "::", "DIR_64", "&&", "\"Directive out of range.\"", ")", ";", "O", "<<", "\"\\t.machine \"", "<<", "CPUDirectives", "[", "Directive", "]", "<<", "'\\n'", ";", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "assert", "(", "MMI", ")", ";", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getTextCoalSection", "(", ")", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getMachOSection", "(", "\"__TEXT\"", ",", "\"__picsymbolstub1\"", ",", "MCSectionMachO", "::", "S_SYMBOL_STUBS", "|", "MCSectionMachO", "::", "S_ATTR_PURE_INSTRUCTIONS", ",", "32", ",", "SectionKind", "::", "getText", "(", ")", ")", ")", ";", "}", "else", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getMachOSection", "(", "\"__TEXT\"", ",", "\"__symbol_stub1\"", ",", "MCSectionMachO", "::", "S_SYMBOL_STUBS", "|", "MCSectionMachO", "::", "S_ATTR_PURE_INSTRUCTIONS", ",", "16", ",", "SectionKind", "::", "getText", "(", ")", ")", ")", ";", "}", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"\"", "\"ppc\"", "\"ppc601\"", "\"ppc602\"", "\"ppc603\"", "\"ppc7400\"", "\"ppc750\"", "\"ppc970\"", "\"ppc64\"", "PPC::DIR_970", "PPC::DIR_970", "PPC::DIR_7400", "PPC::DIR_7400", "PPC", "PPC::DIR_970", "PPC::DIR_64", "PPC::DIR_64", "\"Directive out of range.\"", "\"\\t.machine \"", "\"__TEXT\"", "\"__picsymbolstub1\"", "32", "\"__TEXT\"", "\"__symbol_stub1\"", "16" ]

[]

[ "<s>", "unsigned", "assignCustomValue", "(", "const", "llvm", "::", "ARMCallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ")", "override", "{", "CCValAssign", "VA", "=", "VAs", "[", "0", "]", ";", "assert", "(", "VA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "CCValAssign", "NextVA", "=", "VAs", "[", "1", "]", ";", "assert", "(", "NextVA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "NextVA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "assert", "(", "VA", ".", "getValNo", "(", ")", "==", "NextVA", ".", "getValNo", "(", ")", "&&", "\"Values belong to different arguments\"", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "assert", "(", "NextVA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "unsigned", "NewRegs", "[", "]", "=", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ";", "assignValueToReg", "(", "NewRegs", "[", "0", "]", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ")", ";", "assignValueToReg", "(", "NewRegs", "[", "1", "]", ",", "NextVA", ".", "getLocReg", "(", ")", ",", "NextVA", ")", ";", "bool", "IsLittle", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isLittle", "(", ")", ";", "if", "(", "!", "IsLittle", ")", "std", "::", "swap", "(", "NewRegs", "[", "0", "]", ",", "NewRegs", "[", "1", "]", ")", ";", "MIRBuilder", ".", "buildSequence", "(", "Arg", ".", "Reg", ",", "NewRegs", ",", "{", "0", ",", "32", "}", ")", ";", "return", "1", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "1", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "\"Values belong to different arguments\"", "\"Value should be in reg\"", "\"Value should be in reg\"", "32", "32", "0", "1", "ARM", "0", "1", "0", "32", "1" ]

[]

[ "<s>", "void", "ix86_initialize_callee_abi", "(", "unsigned", "int", "abi_id", ")", "{", "gcc_assert", "(", "abi_id", "==", "ABI_VZEROUPPER", ")", ";", "predefined_function_abi", "&", "vzeroupper_abi", "=", "function_abis", "[", "abi_id", "]", ";", "if", "(", "!", "vzeroupper_abi", ".", "initialized_p", "(", ")", ")", "{", "HARD_REG_SET", "full_reg_clobbers", ";", "CLEAR_HARD_REG_SET", "(", "full_reg_clobbers", ")", ";", "vzeroupper_abi", ".", "initialize", "(", "ABI_VZEROUPPER", ",", "full_reg_clobbers", ")", ";", "}", "}", "</s>" ]

[ "Initialize", "function_abis", "with", "corresponding", "abi_id", ",", "currently", "only", "handle", "vzeroupper", "." ]

[ "i386" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enableMachinePipeliner", "(", ")", "const", "{", "return", "(", "DarwinDirective", "==", "PPC", "::", "DIR_PWR9", ")", "&&", "EnableMachinePipeliner", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "MachinePipeliner", "." ]

[ "PowerPC", "PPC", "PPC::DIR_PWR9" ]

[]

[ "<s>", "bool", "rs6000_is_valid_insert_mask", "(", "rtx", "mask", ",", "rtx", "shift", ",", "machine_mode", "mode", ")", "{", "int", "nb", ",", "ne", ";", "if", "(", "!", "rs6000_is_valid_mask", "(", "mask", ",", "&", "nb", ",", "&", "ne", ",", "mode", ")", ")", "return", "false", ";", "int", "n", "=", "GET_MODE_PRECISION", "(", "mode", ")", ";", "int", "sh", "=", "INTVAL", "(", "XEXP", "(", "shift", ",", "1", ")", ")", ";", "if", "(", "sh", "<", "0", "||", "sh", ">=", "n", ")", "return", "false", ";", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "if", "(", "sh", "==", "0", ")", "code", "=", "ROTATE", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "ne", ">=", "sh", ")", "code", "=", "ASHIFT", ";", "if", "(", "code", "==", "ROTATE", "&&", "sh", ">=", "0", "&&", "nb", ">=", "ne", "&&", "nb", "<", "sh", ")", "{", "code", "=", "LSHIFTRT", ";", "sh", "=", "n", "-", "sh", ";", "}", "if", "(", "mode", "==", "DImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "ne", "==", "sh", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "code", "==", "ROTATE", ")", "return", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", ")", ";", "if", "(", "ne", ">", "nb", ")", "return", "false", ";", "if", "(", "code", "==", "ASHIFT", "&&", "ne", "<", "sh", ")", "return", "false", ";", "if", "(", "nb", "<", "32", "&&", "ne", "<", "32", "&&", "sh", "<", "32", "&&", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "32", "-", "sh", ")", ")", "return", "true", ";", "if", "(", "code", "==", "LSHIFTRT", ")", "sh", "=", "64", "-", "sh", ";", "if", "(", "ne", "==", "sh", ")", "return", "!", "(", "code", "==", "LSHIFTRT", "&&", "nb", ">=", "sh", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "MASK", "(", "a", "CONST_INT", ")", "is", "a", "valid", "mask", "for", "any", "rlwimi", "or", "rldimi", "instruction", ",", "to", "implement", "an", "insert", "with", "shift", "SHIFT", "(", "a", "ROTATE", ",", "ASHIFT", ",", "or", "LSHIFTRT", ")", "in", "mode", "MODE", "." ]

[ "rs6000", "1", "0", "0", "0", "0", "32", "32", "32", "32", "32", "32", "32", "64" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SystemZ", "::", "Return", "||", "Opcode", "==", "SystemZ", "::", "Return_XPLINK", "||", "Opcode", "==", "SystemZ", "::", "Trap", "||", "Opcode", "==", "SystemZ", "::", "CallJG", "||", "Opcode", "==", "SystemZ", "::", "CallBR", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::Return", "SystemZ::Return_XPLINK", "SystemZ::Trap", "SystemZ::CallJG", "SystemZ::CallBR" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "PPC", "0", "224", "0", "0", "PPC" ]

[]

[ "<s>", "void", "MBlazeOperand", "::", "dump", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register R\"", ";", "OS", "<<", "MBlazeRegisterInfo", "::", "getRegisterNumbering", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Memory", ":", "{", "OS", "<<", "\"<memory R\"", ";", "OS", "<<", "MBlazeRegisterInfo", "::", "getRegisterNumbering", "(", "getMemBase", "(", ")", ")", ";", "OS", "<<", "\", \"", ";", "unsigned", "RegOff", "=", "getMemOffReg", "(", ")", ";", "if", "(", "RegOff", ")", "OS", "<<", "\"R\"", "<<", "MBlazeRegisterInfo", "::", "getRegisterNumbering", "(", "RegOff", ")", ";", "else", "OS", "<<", "getMemOff", "(", ")", ";", "OS", "<<", "\">\"", ";", "}", "break", ";", "case", "Fsl", ":", "getFslImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "\"<register R\"", "MBlaze", "\">\"", "\"'\"", "\"'\"", "\"<memory R\"", "MBlaze", "\", \"", "\"R\"", "MBlaze", "\">\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PPCRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "{", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"AnyReg unimplemented on 32-bit AIX.\"", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "return", "CSR_64_AllRegs_VSX_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_64_AllRegs_Altivec_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "}", "bool", "SaveR2", "=", "MF", "->", "getRegInfo", "(", ")", ".", "isAllocatable", "(", "PPC", "::", "X2", ")", "&&", "!", "Subtarget", ".", "isUsingPCRelativeCalls", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Cold", ")", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"Cold calling unimplemented on AIX.\"", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_Altivec_SaveList", ":", "CSR_SVR64_ColdCC_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_SVR64_ColdCC_R2_SaveList", ":", "CSR_SVR64_ColdCC_SaveList", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR32_ColdCC_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR32_ColdCC_SPE_SaveList", ";", "return", "CSR_SVR32_ColdCC_SaveList", ";", "}", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "SaveR2", "?", "CSR_PPC64_R2_Altivec_SaveList", ":", "CSR_PPC64_Altivec_SaveList", ";", "return", "SaveR2", "?", "CSR_PPC64_R2_SaveList", ":", "CSR_PPC64_SaveList", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "CSR_AIX32_SaveList", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", ")", "return", "CSR_SVR432_Altivec_SaveList", ";", "else", "if", "(", "Subtarget", ".", "hasSPE", "(", ")", ")", "return", "CSR_SVR432_SPE_SaveList", ";", "return", "CSR_SVR432_SaveList", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "\"AnyReg unimplemented on 32-bit AIX.\"", "PPC::X2", "\"Cold calling unimplemented on AIX.\"", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "DAG", "->", "MF", ".", "getSubtarget", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TII", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "delete", "Top", ".", "ResourceModel", ";", "delete", "Bot", ".", "ResourceModel", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "STI", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "const", "std", "::", "vector", "<", "unsigned", ">", "&", "MaxPressure", "=", "DAG", "->", "getRegPressure", "(", ")", ".", "MaxSetPressure", ";", "HighPressureSets", ".", "assign", "(", "MaxPressure", ".", "size", "(", ")", ",", "0", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MaxPressure", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Limit", "=", "DAG", "->", "getRegClassInfo", "(", ")", "->", "getRegPressureSetLimit", "(", "i", ")", ";", "HighPressureSets", "[", "i", "]", "=", "(", "(", "float", ")", "MaxPressure", "[", "i", "]", ">", "(", "(", "float", ")", "Limit", "*", "RPThreshold", ")", ")", ";", "}", "assert", "(", "(", "!", "ForceTopDown", "||", "!", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "Hexagon", "0", "0", "\"-misched-topdown incompatible with -misched-bottomup\"" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUDAGToDAGISel", "::", "getPassName", "(", ")", "const", "{", "return", "\"AMDGPU DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreLegalizeMachineIR", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createAArch64PreLegalizeCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MipsMCExpr", "*", "MipsMCExpr", "::", "Create", "(", "MCSymbolRefExpr", "::", "VariantKind", "VK", ",", "const", "MCExpr", "*", "Expr", ",", "MCContext", "&", "Ctx", ")", "{", "VariantKind", "Kind", ";", "switch", "(", "VK", ")", "{", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ":", "Kind", "=", "VK_Mips_LO", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ":", "Kind", "=", "VK_Mips_HI", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_HIGHER", ":", "Kind", "=", "VK_Mips_HIGHER", ";", "break", ";", "case", "MCSymbolRefExpr", "::", "VK_Mips_HIGHEST", ":", "Kind", "=", "VK_Mips_HIGHEST", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid kind!\"", ")", ";", "}", "return", "new", "(", "Ctx", ")", "MipsMCExpr", "(", "Kind", ",", "Expr", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid kind!\"", "Mips" ]

[]

[ "<s>", "bool", "AMDGPUMIRFormatter", "::", "parseCustomPseudoSourceValue", "(", "StringRef", "Src", ",", "MachineFunction", "&", "MF", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "const", "PseudoSourceValue", "*", "&", "PSV", ",", "ErrorCallbackType", "ErrorCallback", ")", "const", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "static_cast", "<", "const", "AMDGPUTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "if", "(", "Src", "==", "\"BufferResource\"", ")", "{", "PSV", "=", "MFI", "->", "getBufferPSV", "(", "TM", ")", ";", "return", "false", ";", "}", "if", "(", "Src", "==", "\"ImageResource\"", ")", "{", "PSV", "=", "MFI", "->", "getImagePSV", "(", "TM", ")", ";", "return", "false", ";", "}", "if", "(", "Src", "==", "\"GWSResource\"", ")", "{", "PSV", "=", "MFI", "->", "getGWSPSV", "(", "TM", ")", ";", "return", "false", ";", "}", "llvm_unreachable", "(", "\"unknown MIR custom pseudo source value\"", ")", ";", "}", "</s>" ]

[ "Implement", "target", "specific", "parsing", "of", "target", "custom", "pseudo", "source", "value", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "AMDGPU", "AMDGPU", "\"BufferResource\"", "\"ImageResource\"", "\"GWSResource\"", "\"unknown MIR custom pseudo source value\"" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", "<=", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "addPass", "(", "createAMDGPUCFGPreparationPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createAMDGPUCFGStructurizerPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ExpandSpecialInstrsPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "&", "FinalizeMachineBundlesID", ")", ";", "addPass", "(", "createR600LowerConstCopy", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "AMDGPUDeviceInfo::HD6XXX", "SI" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::POP16r" ]

[]

[ "<s>", "bool", "WebAssemblyPassConfig", "::", "addILPOpts", "(", ")", "{", "(", "void", ")", "TargetPassConfig", "::", "addILPOpts", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "aarch64_const_vec_all_in_range_p", "(", "rtx", "vec", ",", "HOST_WIDE_INT", "minval", ",", "HOST_WIDE_INT", "maxval", ")", "{", "if", "(", "GET_CODE", "(", "vec", ")", "!=", "CONST_VECTOR", "||", "GET_MODE_CLASS", "(", "GET_MODE", "(", "vec", ")", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "int", "nunits", ";", "if", "(", "!", "CONST_VECTOR_STEPPED_P", "(", "vec", ")", ")", "nunits", "=", "const_vector_encoded_nelts", "(", "vec", ")", ";", "else", "if", "(", "!", "CONST_VECTOR_NUNITS", "(", "vec", ")", ".", "is_constant", "(", "&", "nunits", ")", ")", "return", "false", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nunits", ";", "i", "++", ")", "{", "rtx", "vec_elem", "=", "CONST_VECTOR_ELT", "(", "vec", ",", "i", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "vec_elem", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "vec_elem", ")", ",", "minval", ",", "maxval", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "VEC", "is", "a", "constant", "in", "which", "every", "element", "is", "in", "the", "range", "[", "MINVAL", ",", "MAXVAL", "]", ".", "The", "elements", "do", "not", "need", "to", "have", "the", "same", "value", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "setReg", "(", "unsigned", "RegNo", ")", "{", "assert", "(", "Kind", "==", "k_Reg", "&&", "\"Invalid access!\"", ")", ";", "Reg", "=", "RegNo", ";", "}", "</s>" ]

[ "Assigns", "the", "associated", "register", "for", "this", "edge", "." ]

[ "MSP430", "\"Invalid access!\"" ]

[]

[ "<s>", "void", "frv_initialize_trampoline", "(", "rtx", "addr", ",", "rtx", "fnaddr", ",", "rtx", "static_chain", ")", "{", "rtx", "sc_reg", "=", "force_reg", "(", "Pmode", ",", "static_chain", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "SImode", ",", "\"__trampoline_setup\"", ")", ",", "FALSE", ",", "VOIDmode", ",", "4", ",", "addr", ",", "Pmode", ",", "GEN_INT", "(", "frv_trampoline_size", "(", ")", ")", ",", "SImode", ",", "fnaddr", ",", "Pmode", ",", "sc_reg", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "A", "C", "statement", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "ADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "trampoline", ";", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "nested", "function", ";", "STATIC_CHAIN", "is", "an", "RTX", "for", "the", "static", "chain", "value", "that", "should", "be", "passed", "to", "the", "function", "when", "it", "is", "called", ".", "The", "template", "is", ":", "setlo", "#", "0", ",", "<", "jmp_reg", ">", "setlo", "#", "0", ",", "<", "static_chain", ">", "sethi", "#", "0", ",", "<", "jmp_reg", ">", "sethi", "#", "0", ",", "<", "static_chain", ">", "jmpl", "@", "(", "gr0", ",", "<", "jmp_reg", ">", ")" ]

[ "frv", "\"__trampoline_setup\"", "4" ]

[]

[ "<s>", "MCContext", "&", "getContext", "(", ")", "const", "{", "return", "Streamer", ".", "getContext", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "LLVMContext", "used", "by", "the", "analysis", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "Bits", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "0", "||", "Imm", ".", "getActiveBits", "(", ")", ">=", "64", ")", "return", "4", ";", "int64_t", "SImmVal", "=", "Imm", ".", "getSExtValue", "(", ")", ";", "uint64_t", "ZImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "ST", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "if", "(", "ST", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "ST", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "if", "(", "Bits", "==", "8", "||", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "256", ")", ")", "return", "1", ";", "if", "(", "(", "~", "SImmVal", "<", "256", ")", "||", "ARM_AM", "::", "isThumbImmShiftedVal", "(", "ZImmVal", ")", ")", "return", "2", ";", "return", "3", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "ARM", "ARM", "0", "64", "4", "0", "65536", "ARM_AM::getSOImmVal", "1", "ARM_AM::getSOImmVal", "1", "1", "2", "3", "0", "65536", "ARM_AM::getT2SOImmVal", "1", "ARM_AM::getT2SOImmVal", "1", "1", "2", "3", "8", "0", "256", "1", "256", "ARM_AM::isThumbImmShiftedVal", "2", "3" ]

[]

[ "<s>", "unsigned", "char", "ix86_memtag_tag_size", "(", ")", "{", "return", "IX86_HWASAN_TAG_SIZE", ";", "}", "</s>" ]

[ "Implement", "TARGET_MEMTAG_TAG_SIZE", "." ]

[ "i386" ]

[]

[ "<s>", "void", "SHUXIDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SDLoc", "dl", "(", "Node", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "assert", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "SHUXI", "::", "ADDri", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "SHUXI", "::", "ADDri", ",", "dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::FrameIndex", "0", "MVT::i32", "MVT::i32", "SHUXI::ADDri", "MVT::i32", "0", "MVT::i32", "SHUXI::ADDri", "MVT::i32", "0", "MVT::i32" ]

[]

[ "<s>", "static", "int", "nvptx_simt_vf", "(", ")", "{", "return", "PTX_WARP_SIZE", ";", "}", "</s>" ]

[ "Implement", "TARGET_SIMT_VF", "target", "hook", ":", "number", "of", "threads", "in", "a", "warp", "." ]

[ "nvptx" ]

[]

[ "<s>", "int", "AArch64FrameLowering", "::", "getNonLocalFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ")", "const", "{", "return", "getSEHFrameIndexOffset", "(", "MF", ",", "FI", ")", ";", "}", "</s>" ]

[ "getNonLocalFrameIndexReference", "-", "This", "method", "returns", "the", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "TriCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineOperand", "&", "FIOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "unsigned", "FI", "=", "FIOp", ".", "getIndex", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "TriCore", "::", "A14", ":", "TriCore", "::", "A10", ")", ";", "unsigned", "ImmOpIdx", "=", "0", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TriCore", "::", "ADDrc", ")", "{", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "Offset", "=", "-", "Offset", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "TriCore", "::", "MOV_Drr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "{", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "ADDrc", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "}", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "TriCore", "::", "ADDrc", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "return", ";", "}", "ImmOpIdx", "=", "FIOperandNum", "+", "1", ";", "MachineOperand", "&", "ImmOp", "=", "MI", ".", "getOperand", "(", "ImmOpIdx", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FI", ")", ";", "FIOp", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "ImmOp", ".", "setImm", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "TriCore", "TriCore", "0", "\"Unexpected\"", "TriCore::A14", "TriCore::A10", "0", "TriCore::ADDrc", "TriCore::MOV_Drr", "0", "0", "0", "TriCore::ADDrc", "TriCore::ADDrc", "1" ]

[]

[ "<s>", "Register", "MipsOutgoingValueHandler", "::", "extendRegister", "(", "Register", "ValReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "LLT", "LocTy", "{", "VA", ".", "getLocVT", "(", ")", "}", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "SExt", ":", "{", "return", "MIRBuilder", ".", "buildSExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "ZExt", ":", "{", "return", "MIRBuilder", ".", "buildZExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "AExt", ":", "{", "return", "MIRBuilder", ".", "buildAnyExt", "(", "LocTy", ",", "ValReg", ")", ".", "getReg", "(", "0", ")", ";", "}", "case", "CCValAssign", "::", "Full", ":", "return", "ValReg", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"unable to extend register\"", ")", ";", "}", "</s>" ]

[ "Extend", "a", "register", "to", "the", "location", "type", "given", "in", "VA", ",", "capped", "at", "extending", "to", "at", "most", "MaxSize", "bits", "." ]

[ "Mips", "Mips", "0", "0", "0", "\"unable to extend register\"" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "S2_storeri_io", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "S2_storerd_io", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "STriw_pred", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::S2_storeri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::S2_storerd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::STriw_pred", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getFMA3OpcodeToCommuteOperands", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "SrcOpIdx1", ",", "unsigned", "SrcOpIdx2", ",", "const", "X86InstrFMA3Group", "&", "FMA3Group", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "SrcOpIdx1", ">", "SrcOpIdx2", ")", "std", "::", "swap", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "if", "(", "FMA3Group", ".", "isIntrinsic", "(", ")", "&&", "SrcOpIdx1", "==", "1", ")", "return", "0", ";", "int", "Case", "=", "getThreeSrcCommuteCase", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "if", "(", "Case", "<", "0", ")", "return", "0", ";", "const", "unsigned", "Form132Index", "=", "0", ";", "const", "unsigned", "Form213Index", "=", "1", ";", "const", "unsigned", "Form231Index", "=", "2", ";", "static", "const", "unsigned", "FormMapping", "[", "]", "[", "3", "]", "=", "{", "{", "Form231Index", ",", "Form213Index", ",", "Form132Index", "}", ",", "{", "Form132Index", ",", "Form231Index", ",", "Form213Index", "}", ",", "{", "Form213Index", ",", "Form132Index", ",", "Form231Index", "}", "}", ";", "unsigned", "FMAForms", "[", "3", "]", ";", "if", "(", "FMA3Group", ".", "isRegOpcodeFromGroup", "(", "Opc", ")", ")", "{", "FMAForms", "[", "0", "]", "=", "FMA3Group", ".", "getReg132Opcode", "(", ")", ";", "FMAForms", "[", "1", "]", "=", "FMA3Group", ".", "getReg213Opcode", "(", ")", ";", "FMAForms", "[", "2", "]", "=", "FMA3Group", ".", "getReg231Opcode", "(", ")", ";", "}", "else", "{", "FMAForms", "[", "0", "]", "=", "FMA3Group", ".", "getMem132Opcode", "(", ")", ";", "FMAForms", "[", "1", "]", "=", "FMA3Group", ".", "getMem213Opcode", "(", ")", ";", "FMAForms", "[", "2", "]", "=", "FMA3Group", ".", "getMem231Opcode", "(", ")", ";", "}", "unsigned", "FormIndex", ";", "for", "(", "FormIndex", "=", "0", ";", "FormIndex", "<", "3", ";", "FormIndex", "++", ")", "if", "(", "Opc", "==", "FMAForms", "[", "FormIndex", "]", ")", "break", ";", "FormIndex", "=", "FormMapping", "[", "Case", "]", "[", "FormIndex", "]", ";", "return", "FMAForms", "[", "FormIndex", "]", ";", "}", "</s>" ]

[ "Returns", "an", "adjusted", "FMA", "opcode", "that", "must", "be", "used", "in", "FMA", "instruction", "that", "performs", "the", "same", "computations", "as", "the", "given", "MI", "but", "which", "has", "the", "operands", "SrcOpIdx1", "and", "SrcOpIdx2", "commuted", "." ]

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

[]