Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "ECLairAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OS", ".", "write", "(", "224", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ECLair", "ECLair", "4", "0", "0", "4", "224" ]

[]

[ "<s>", "uint32_t", "ARMMCCodeEmitter", "::", "getBranchTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpIdx", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "isThumb2", "(", "STI", ")", ")", "return", "::", "getBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "ARM", "::", "fixup_t2_condbranch", ",", "Fixups", ",", "STI", ")", ";", "return", "getARMBranchTargetOpValue", "(", "MI", ",", "OpIdx", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "ARM", "ARM", "ARM::fixup_t2_condbranch", "ARM" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getSqrtInputTest", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "const", "DenormalMode", "&", "Mode", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isTypeLegal", "(", "MVT", "::", "i1", ")", "||", "(", "VT", "!=", "MVT", "::", "f64", "&&", "(", "(", "VT", "!=", "MVT", "::", "v2f64", "&&", "VT", "!=", "MVT", "::", "v4f32", ")", "||", "!", "Subtarget", ".", "hasVSX", "(", ")", ")", ")", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "FTSQRT", "=", "DAG", ".", "getNode", "(", "PPCISD", "::", "FTSQRT", ",", "DL", ",", "MVT", "::", "i32", ",", "Op", ")", ";", "SDValue", "SRIdxVal", "=", "DAG", ".", "getTargetConstant", "(", "PPC", "::", "sub_eq", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "return", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "EXTRACT_SUBREG", ",", "DL", ",", "MVT", "::", "i1", ",", "FTSQRT", ",", "SRIdxVal", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "a", "target-dependent", "comparison", "result", "if", "the", "input", "operand", "is", "suitable", "for", "use", "with", "a", "square", "root", "estimate", "calculation", "." ]

[ "PowerPC", "PPC", "MVT::i1", "MVT::f64", "MVT::v2f64", "MVT::v4f32", "PPCISD::FTSQRT", "MVT::i32", "PPC::sub_eq", "MVT::i32", "MVT::i1", "0" ]

[]

[ "<s>", "void", "function_builder", "::", "add_overloaded_functions", "(", "const", "function_group_info", "&", "group", ",", "mode_suffix_index", "mode", ")", "{", "if", "(", "m_direct_overloads", ")", "return", ";", "unsigned", "int", "explicit_type0", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "0", ")", ";", "unsigned", "int", "explicit_type1", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "1", ")", ";", "for", "(", "unsigned", "int", "pi", "=", "0", ";", "group", ".", "preds", "[", "pi", "]", "!=", "NUM_PREDS", ";", "++", "pi", ")", "{", "if", "(", "!", "explicit_type0", "&&", "!", "explicit_type1", ")", "{", "function_instance", "instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "mode", ",", "types_none", "[", "0", "]", ",", "group", ".", "preds", "[", "pi", "]", ")", ";", "add_overloaded_function", "(", "instance", ",", "group", ".", "required_extensions", ")", ";", "}", "else", "for", "(", "unsigned", "int", "ti", "=", "0", ";", "group", ".", "types", "[", "ti", "]", "[", "0", "]", "!=", "NUM_TYPE_SUFFIXES", ";", "++", "ti", ")", "{", "type_suffix_pair", "types", "=", "{", "explicit_type0", "?", "group", ".", "types", "[", "ti", "]", "[", "0", "]", ":", "NUM_TYPE_SUFFIXES", ",", "explicit_type1", "?", "group", ".", "types", "[", "ti", "]", "[", "1", "]", ":", "NUM_TYPE_SUFFIXES", "}", ";", "function_instance", "instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "mode", ",", "types", ",", "group", ".", "preds", "[", "pi", "]", ")", ";", "add_overloaded_function", "(", "instance", ",", "group", ".", "required_extensions", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "we", "are", "using", "manual", "overload", "resolution", ",", "add", "one", "function", "decl", "for", "each", "overloaded", "function", "in", "GROUP", ".", "Take", "the", "function", "base", "name", "from", "GROUP", "and", "the", "mode", "from", "MODE", "." ]

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

[]

[ "<s>", "void", "ARMELFStreamer", "::", "EmitRegSave", "(", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "RegList", ",", "bool", "IsVector", ")", "{", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "for", ".save", "directives", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "RAInfo", "::", "dump", "(", "raw_ostream", "&", "os", ",", "unsigned", "indent", ")", "const", "{", "os", ".", "indent", "(", "indent", ")", "<<", "\"[MBB#\"", "<<", "Scope", "->", "getHeader", "(", ")", "->", "getMBB", "(", ")", "->", "getNumber", "(", ")", "<<", "\"] depth=\"", "<<", "Scope", "->", "getDepth", "(", ")", "<<", "\"\\n\"", ";", "for", "(", "auto", "pair", ":", "Priv", "->", "LRs", ")", "{", "os", ".", "indent", "(", "indent", ")", "<<", "\" LR(p\"", "<<", "pair", ".", "first", "<<", "\") = [\"", "<<", "pair", ".", "second", ".", "str", "(", ")", "<<", "\"]\\n\"", ";", "}", "auto", "blocks", "=", "Scope", "->", "getBlocksTopoOrd", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "blocks", ".", "size", "(", ")", ";", "i", "<", "e", ";", "i", "++", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "blocks", "[", "i", "]", "->", "getMBB", "(", ")", ";", "os", ".", "indent", "(", "indent", ")", "<<", "\" \"", "<<", "i", "<<", "\"| MBB#\"", "<<", "MBB", "->", "getNumber", "(", ")", ";", "os", "<<", "\" UseLocs{\\n\"", ";", "for", "(", "auto", "predUl", ":", "Priv", "->", "UseLocs", "[", "MBB", "]", ")", "{", "os", "<<", "\" (Pred: \"", "<<", "predUl", ".", "first", "<<", "\", loc=\"", "<<", "predUl", ".", "second", ".", "loc", "<<", "\", load=\"", ";", "if", "(", "predUl", ".", "second", ".", "load", ".", "first", ")", "{", "os", "<<", "predUl", ".", "second", ".", "load", ".", "second", ";", "}", "else", "{", "os", "<<", "\"none\"", ";", "}", "dbgs", "(", ")", "<<", "\", spill=\"", ";", "if", "(", "predUl", ".", "second", ".", "spill", ".", "first", ")", "{", "os", "<<", "predUl", ".", "second", ".", "spill", ".", "second", ";", "}", "else", "{", "os", "<<", "\"none\"", ";", "}", "os", "<<", "\"), \"", ";", "}", "os", "<<", "\"}\\n\"", ";", "}", "os", ".", "indent", "(", "indent", ")", "<<", "\" DefLocs: \"", ";", "for", "(", "auto", "pair", ":", "Priv", "->", "DefLocs", ")", "{", "os", "<<", "\" p\"", "<<", "pair", ".", "first", "<<", "\"=\"", "<<", "pair", ".", "second", "<<", "\", \"", ";", "}", "os", "<<", "\"\\n\"", ";", "os", ".", "indent", "(", "indent", ")", "<<", "\" NumLocs: \"", "<<", "Priv", "->", "NumLocs", "<<", "\"\\n\"", "\" CumLocs: \"", "<<", "Priv", "->", "getCumLocs", "(", ")", "<<", "\"\\n\"", "\" Offset: \"", "<<", "Priv", "->", "FirstUsableReg", "<<", "\"\\n\"", "\" SpillOffset: \"", "<<", "Priv", "->", "FirstUsableStackSlot", "<<", "\"\\n\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"[MBB#\"", "\"] depth=\"", "\"\\n\"", "\" LR(p\"", "\") = [\"", "\"]\\n\"", "0", "\" \"", "\"| MBB#\"", "\" UseLocs{\\n\"", "\" (Pred: \"", "\", loc=\"", "\", load=\"", "\"none\"", "\", spill=\"", "\"none\"", "\"), \"", "\"}\\n\"", "\" DefLocs: \"", "\" p\"", "\"=\"", "\", \"", "\"\\n\"", "\" NumLocs: \"", "\"\\n\"", "\" CumLocs: \"", "\"\\n\"", "\" Offset: \"", "\"\\n\"", "\" SpillOffset: \"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_multi_last_index", "(", "void", ")", "{", "return", "mips_multi_members", ".", "length", "(", ")", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "index", "of", "the", "last", "member", "of", "the", "current", "multi-insn", "sequence", "." ]

[ "mips", "1" ]

[]

[ "<s>", "void", "WebAssemblyDebugValueManager", "::", "move", "(", "MachineInstr", "*", "Insert", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "Insert", "->", "getParent", "(", ")", ";", "for", "(", "MachineInstr", "*", "DBI", ":", "reverse", "(", "DbgValues", ")", ")", "MBB", "->", "splice", "(", "Insert", ",", "DBI", "->", "getParent", "(", ")", ",", "DBI", ")", ";", "}", "</s>" ]

[ "Move", "in", "the", "provide", "values", "in", "ValuesToLink", "from", "Src", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "const", "std", "::", "string", "&", "MipsLA25Stub", "::", "name", "(", ")", "const", "{", "return", "m_Name", ";", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "ARMBaseRegisterInfo", "::", "getMatchingSuperRegClass", "(", "const", "TargetRegisterClass", "*", "A", ",", "const", "TargetRegisterClass", "*", "B", ",", "unsigned", "SubIdx", ")", "const", "{", "switch", "(", "SubIdx", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "ssub_0", ":", "case", "ARM", "::", "ssub_1", ":", "case", "ARM", "::", "ssub_2", ":", "case", "ARM", "::", "ssub_3", ":", "{", "if", "(", "A", "->", "getSize", "(", ")", "==", "8", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "SPR_8RegClass", ")", "return", "&", "ARM", "::", "DPR_8RegClass", ";", "assert", "(", "B", "==", "&", "ARM", "::", "SPRRegClass", "&&", "\"Expecting SPR register class!\"", ")", ";", "if", "(", "A", "==", "&", "ARM", "::", "DPR_8RegClass", ")", "return", "A", ";", "return", "&", "ARM", "::", "DPR_VFP2RegClass", ";", "}", "if", "(", "A", "->", "getSize", "(", ")", "==", "16", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "SPR_8RegClass", ")", "return", "&", "ARM", "::", "QPR_8RegClass", ";", "return", "&", "ARM", "::", "QPR_VFP2RegClass", ";", "}", "if", "(", "A", "->", "getSize", "(", ")", "==", "32", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "SPR_8RegClass", ")", "return", "0", ";", "return", "&", "ARM", "::", "QQPR_VFP2RegClass", ";", "}", "assert", "(", "A", "->", "getSize", "(", ")", "==", "64", "&&", "\"Expecting a QQQQ register class!\"", ")", ";", "return", "0", ";", "}", "case", "ARM", "::", "dsub_0", ":", "case", "ARM", "::", "dsub_1", ":", "case", "ARM", "::", "dsub_2", ":", "case", "ARM", "::", "dsub_3", ":", "{", "if", "(", "A", "->", "getSize", "(", ")", "==", "16", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "DPR_VFP2RegClass", ")", "return", "&", "ARM", "::", "QPR_VFP2RegClass", ";", "if", "(", "B", "==", "&", "ARM", "::", "DPR_8RegClass", ")", "return", "0", ";", "return", "A", ";", "}", "if", "(", "A", "->", "getSize", "(", ")", "==", "32", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "DPR_VFP2RegClass", ")", "return", "&", "ARM", "::", "QQPR_VFP2RegClass", ";", "if", "(", "B", "==", "&", "ARM", "::", "DPR_8RegClass", ")", "return", "0", ";", "return", "A", ";", "}", "assert", "(", "A", "->", "getSize", "(", ")", "==", "64", "&&", "\"Expecting a QQQQ register class!\"", ")", ";", "if", "(", "B", "!=", "&", "ARM", "::", "DPRRegClass", ")", "return", "0", ";", "return", "A", ";", "}", "case", "ARM", "::", "dsub_4", ":", "case", "ARM", "::", "dsub_5", ":", "case", "ARM", "::", "dsub_6", ":", "case", "ARM", "::", "dsub_7", ":", "{", "if", "(", "A", "->", "getSize", "(", ")", "==", "64", "&&", "B", "==", "&", "ARM", "::", "DPRRegClass", ")", "return", "A", ";", "return", "0", ";", "}", "case", "ARM", "::", "qsub_0", ":", "case", "ARM", "::", "qsub_1", ":", "{", "if", "(", "A", "->", "getSize", "(", ")", "==", "32", ")", "{", "if", "(", "B", "==", "&", "ARM", "::", "QPR_VFP2RegClass", ")", "return", "&", "ARM", "::", "QQPR_VFP2RegClass", ";", "if", "(", "B", "==", "&", "ARM", "::", "QPR_8RegClass", ")", "return", "0", ";", "return", "A", ";", "}", "assert", "(", "A", "->", "getSize", "(", ")", "==", "64", "&&", "\"Expecting a QQQQ register class!\"", ")", ";", "if", "(", "B", "==", "&", "ARM", "::", "QPRRegClass", ")", "return", "A", ";", "return", "0", ";", "}", "case", "ARM", "::", "qsub_2", ":", "case", "ARM", "::", "qsub_3", ":", "{", "if", "(", "A", "->", "getSize", "(", ")", "==", "64", "&&", "B", "==", "&", "ARM", "::", "QPRRegClass", ")", "return", "A", ";", "return", "0", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "getMatchingSuperRegClass", "-", "Return", "a", "subclass", "of", "the", "specified", "register", "class", "A", "so", "that", "each", "register", "in", "it", "has", "a", "sub-register", "of", "the", "specified", "sub-register", "index", "which", "is", "in", "the", "specified", "register", "class", "B", "." ]

[ "ARM", "ARM", "0", "ARM::ssub_0", "ARM::ssub_1", "ARM::ssub_2", "ARM::ssub_3", "8", "ARM::SPR_8RegClass", "ARM::DPR_8RegClass", "ARM::SPRRegClass", "\"Expecting SPR register class!\"", "ARM::DPR_8RegClass", "ARM::DPR_VFP2RegClass", "16", "ARM::SPR_8RegClass", "ARM::QPR_8RegClass", "ARM::QPR_VFP2RegClass", "32", "ARM::SPR_8RegClass", "0", "ARM::QQPR_VFP2RegClass", "64", "\"Expecting a QQQQ register class!\"", "0", "ARM::dsub_0", "ARM::dsub_1", "ARM::dsub_2", "ARM::dsub_3", "16", "ARM::DPR_VFP2RegClass", "ARM::QPR_VFP2RegClass", "ARM::DPR_8RegClass", "0", "32", "ARM::DPR_VFP2RegClass", "ARM::QQPR_VFP2RegClass", "ARM::DPR_8RegClass", "0", "64", "\"Expecting a QQQQ register class!\"", "ARM::DPRRegClass", "0", "ARM::dsub_4", "ARM::dsub_5", "ARM::dsub_6", "ARM::dsub_7", "64", "ARM::DPRRegClass", "0", "ARM::qsub_0", "ARM::qsub_1", "32", "ARM::QPR_VFP2RegClass", "ARM::QQPR_VFP2RegClass", "ARM::QPR_8RegClass", "0", "64", "\"Expecting a QQQQ register class!\"", "ARM::QPRRegClass", "0", "ARM::qsub_2", "ARM::qsub_3", "64", "ARM::QPRRegClass", "0", "0" ]

[]

[ "<s>", "void", "print", "(", "std", "::", "ostream", "*", "O", ")", "const", "{", "if", "(", "O", ")", "print", "(", "*", "O", ")", ";", "}", "</s>" ]

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

[ "ARM" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "addPass", "(", "createAMDGPUAnnotateKernelFeaturesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", "&&", "EnableLowerKernelArguments", ")", "addPass", "(", "createAMDGPULowerKernelArgumentsPass", "(", ")", ")", ";", "addPass", "(", "&", "AMDGPUPerfHintAnalysisID", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "if", "(", "EnableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addPass", "(", "createLowerSwitchPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "HexagonISD", "::", "OP_BEGIN", "&&", "Opc", "<", "HexagonISD", "::", "OP_END", ")", "errs", "(", ")", "<<", "\"Error: check for a non-legal type in this operation\\n\"", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "return", "LowerREADCYCLECOUNTER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "return", "LowerHvxMul", "(", "Op", ",", "DAG", ")", ";", "break", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "HexagonISD::OP_BEGIN", "HexagonISD::OP_END", "\"Error: check for a non-legal type in this operation\\n\"", "\"Should not custom lower this!\"", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SRA", "ISD::SHL", "ISD::SRL", "ISD::ConstantPool", "ISD::JumpTable", "ISD::EH_RETURN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GLOBAL_OFFSET_TABLE", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::SETCC", "ISD::VSELECT", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "ISD::INLINEASM", "ISD::PREFETCH", "ISD::READCYCLECOUNTER", "ISD::MUL" ]

[]

[ "<s>", "void", "emitFill", "(", "const", "MCExpr", "&", "NumBytes", ",", "uint64_t", "FillValue", ",", "SMLoc", "Loc", ")", "override", "{", "EmitDataMappingSymbol", "(", ")", ";", "MCObjectStreamer", "::", "emitFill", "(", "NumBytes", ",", "FillValue", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Emit", "Size", "bytes", "worth", "of", "the", "value", "specified", "by", "FillValue", "." ]

[ "ARM" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Peephole SDWA\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Peephole SDWA\"" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "CommentStream", ")", "HasCustomInstComment", "=", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "unsigned", "Flags", "=", "MI", "->", "getFlags", "(", ")", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_LOCK", ")", ")", "OS", "<<", "\"\\tlock\\t\"", ";", "if", "(", "(", "TSFlags", "&", "X86II", "::", "NOTRACK", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_NOTRACK", ")", ")", "OS", "<<", "\"\\tnotrack\\t\"", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "OS", "<<", "\"\\trepne\\t\"", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "OS", "<<", "\"\\trep\\t\"", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "\"\\tcallq\\t\"", ";", "printPCRelImm", "(", "MI", ",", "0", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", "{", "OS", "<<", "\"\\tdata32\"", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86II::LOCK", "X86::IP_HAS_LOCK", "\"\\tlock\\t\"", "X86II::NOTRACK", "X86::IP_HAS_NOTRACK", "\"\\tnotrack\\t\"", "X86::IP_HAS_REPEAT_NE", "\"\\trepne\\t\"", "X86::IP_HAS_REPEAT", "\"\\trep\\t\"", "X86::CALLpcrel32", "X86::Mode64Bit", "\"\\tcallq\\t\"", "0", "X86::DATA16_PREFIX", "X86::Mode16Bit", "\"\\tdata32\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "const", "MachineFunction", "&", "MF", ",", "bool", "UseEstimate", ",", "unsigned", "*", "NewMaxCallFrameSize", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", ".", "estimateStackSize", "(", "MF", ")", ":", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "TargetAlign", "=", "getStackAlign", "(", ")", ";", "Align", "MaxAlign", "=", "MFI", ".", "getMaxAlign", "(", ")", ";", "Align", "Alignment", "=", "std", "::", "max", "(", "TargetAlign", ",", "MaxAlign", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoRedZone", ")", ";", "bool", "CanUseRedZone", "=", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", "&&", "!", "MustSaveLR", "(", "MF", ",", "LR", ")", "&&", "!", "FI", "->", "mustSaveTOC", "(", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ";", "bool", "FitsInRedZone", "=", "FrameSize", "<=", "Subtarget", ".", "getRedZoneSize", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "CanUseRedZone", "&&", "FitsInRedZone", ")", "{", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "alignTo", "(", "maxCallFrameSize", ",", "Alignment", ")", ";", "if", "(", "NewMaxCallFrameSize", ")", "*", "NewMaxCallFrameSize", "=", "maxCallFrameSize", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "Alignment", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "mips_set_return_address", "(", "rtx", "address", ",", "rtx", "scratch", ")", "{", "rtx", "slot_address", ";", "gcc_assert", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "slot_address", "=", "mips_add_offset", "(", "scratch", ",", "stack_pointer_rtx", ",", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", ")", ";", "mips_emit_move", "(", "gen_frame_mem", "(", "GET_MODE", "(", "address", ")", ",", "slot_address", ")", ",", "address", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "change", "the", "current", "function", "'s", "return", "address", "to", "ADDRESS", ".", "SCRATCH", "is", "available", "as", "a", "scratch", "register", ",", "if", "needed", ".", "ADDRESS", "and", "SCRATCH", "are", "both", "word-mode", "GPRs", "." ]

[ "mips" ]

[]

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

[ "True", "if", "the", "machine", "scheduler", "should", "disable", "the", "TLI", "preference", "for", "preRA", "scheduling", "with", "the", "source", "level", "scheduler", "." ]

[ "TPC" ]

[]

[ "<s>", "static", "bool", "s390_fix_long_loop_prediction", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "rtx", "code_label", ",", "label_ref", ",", "new_label", ";", "rtx_insn", "*", "uncond_jump", ";", "rtx_insn", "*", "cur_insn", ";", "rtx", "tmp", ";", "int", "distance", ";", "if", "(", "!", "set", "||", "SET_DEST", "(", "set", ")", "!=", "pc_rtx", "||", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "!=", "IF_THEN_ELSE", ")", "return", "false", ";", "if", "(", "ANY_RETURN_P", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "&&", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "==", "pc_rtx", ")", "return", "false", ";", "label_ref", "=", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ")", "==", "LABEL_REF", "?", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ":", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "label_ref", ")", "==", "LABEL_REF", ")", ";", "code_label", "=", "XEXP", "(", "label_ref", ",", "0", ")", ";", "if", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "==", "-", "1", "||", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "==", "-", "1", "||", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "code_label", ")", ")", "<", "PREDICT_DISTANCE", ")", ")", "return", "false", ";", "for", "(", "distance", "=", "0", ",", "cur_insn", "=", "PREV_INSN", "(", "insn", ")", ";", "distance", "<", "PREDICT_DISTANCE", "-", "6", ";", "distance", "+=", "get_attr_length", "(", "cur_insn", ")", ",", "cur_insn", "=", "PREV_INSN", "(", "cur_insn", ")", ")", "if", "(", "!", "cur_insn", "||", "JUMP_P", "(", "cur_insn", ")", "||", "LABEL_P", "(", "cur_insn", ")", ")", "return", "false", ";", "new_label", "=", "gen_label_rtx", "(", ")", ";", "uncond_jump", "=", "emit_jump_insn_after", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "code_label", ")", ")", ",", "insn", ")", ";", "emit_label_after", "(", "new_label", ",", "uncond_jump", ")", ";", "tmp", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "1", ")", "=", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", ";", "XEXP", "(", "SET_SRC", "(", "set", ")", ",", "2", ")", "=", "tmp", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "XEXP", "(", "label_ref", ",", "0", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "insn", ")", "=", "new_label", ";", "JUMP_LABEL", "(", "uncond_jump", ")", "=", "code_label", ";", "return", "true", ";", "}", "</s>" ]

[ "On", "z10", "and", "later", "the", "dynamic", "branch", "prediction", "must", "see", "the", "backward", "jump", "within", "a", "certain", "windows", ".", "If", "not", "it", "falls", "back", "to", "the", "static", "prediction", ".", "This", "function", "rearranges", "the", "loop", "backward", "branch", "in", "a", "way", "which", "makes", "the", "static", "prediction", "always", "correct", ".", "The", "function", "returns", "true", "if", "it", "added", "an", "instruction", "." ]

[ "s390", "1", "2", "1", "1", "2", "0", "1", "1", "0", "6", "1", "1", "2", "2", "1", "0" ]

[]

[ "<s>", "void", "MOSTargetAsmStreamer", "::", "changeSection", "(", "const", "MCSection", "*", "CurSection", ",", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "SubSection", ",", "raw_ostream", "&", "OS", ")", "{", "MCTargetStreamer", "::", "changeSection", "(", "CurSection", ",", "Section", ",", "SubSection", ",", "OS", ")", ";", "HasBSS", "|=", "Section", "->", "getName", "(", ")", ".", "startswith", "(", "\".bss\"", ")", ";", "HasData", "|=", "Section", "->", "getName", "(", ")", ".", "startswith", "(", "\".data\"", ")", ";", "HasInitArray", "|=", "Section", "->", "getName", "(", ")", ".", "startswith", "(", "\".init_array\"", ")", ";", "HasFiniArray", "|=", "Section", "->", "getName", "(", ")", ".", "startswith", "(", "\".fini_array\"", ")", ";", "}", "</s>" ]

[ "Update", "streamer", "for", "a", "new", "active", "section", "." ]

[ "MOS", "MOS", "\".bss\"", "\".data\"", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "assert", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", "&&", "\"shouldAssumeDSOLocal gave inconsistent answer\"", ")", ";", "return", "X86II", "::", "MO_DLLIMPORT", ";", "}", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", "&&", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_PLT", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "\"shouldAssumeDSOLocal gave inconsistent answer\"", "X86II::MO_DLLIMPORT", "X86", "X86II::MO_GOTPCREL", "X86II::MO_GOTPCREL", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "void", "BPFAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "BPFMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "Nyuzi" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "if", "(", "Level", "==", "BeforeLegalizeTypes", ")", "return", "true", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", "&&", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "true", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "ARM", "ARM", "ISD::SHL" ]

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "X86" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "RC", "==", "&", "ARM", "::", "GPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "tcGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "rGPRRegClass", "||", "RC", "==", "&", "ARM", "::", "GPRnopcRegClass", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::tGPRRegClass", "ARM::tcGPRRegClass", "ARM::rGPRRegClass", "ARM::GPRnopcRegClass", "ARM::t2STRi12", "0", "ARM" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STM", "=", "&", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", "->", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "CreatedX2", "=", "0", ";", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "if", "(", "CreatedX2", ">=", "1", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "\"Must be run on SSA\"", "\"Running SILoadStoreOptimizer\\n\"", "0", "1" ]

[]

[ "<s>", "static", "void", "tilegx_gen_bundles", "(", "void", ")", "{", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx_insn", "*", "insn", ",", "*", "next", ",", "*", "prev", ";", "rtx_insn", "*", "end", "=", "NEXT_INSN", "(", "BB_END", "(", "bb", ")", ")", ";", "prev", "=", "NULL", ";", "for", "(", "insn", "=", "next_insn_to_bundle", "(", "BB_HEAD", "(", "bb", ")", ",", "end", ")", ";", "insn", ";", "prev", "=", "insn", ",", "insn", "=", "next", ")", "{", "next", "=", "next_insn_to_bundle", "(", "NEXT_INSN", "(", "insn", ")", ",", "end", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ASM_INPUT", ")", "{", "if", "(", "next", "==", "NULL_RTX", "||", "GET_MODE", "(", "next", ")", "==", "TImode", "||", "CALL_P", "(", "insn", ")", ")", "{", "PUT_MODE", "(", "insn", ",", "QImode", ")", ";", "}", "else", "{", "PUT_MODE", "(", "insn", ",", "SImode", ")", ";", "}", "}", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_NOTHING", ")", "{", "if", "(", "GET_MODE", "(", "insn", ")", "==", "QImode", "&&", "prev", "!=", "NULL", "&&", "GET_MODE", "(", "prev", ")", "==", "SImode", ")", "{", "PUT_MODE", "(", "prev", ",", "QImode", ")", ";", "}", "delete_insn", "(", "insn", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Go", "through", "all", "insns", ",", "and", "use", "the", "information", "generated", "during", "scheduling", "to", "generate", "SEQUENCEs", "to", "represent", "bundles", "of", "instructions", "issued", "simultaneously", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "arc_epilogue_uses", "(", "int", "regno", ")", "{", "unsigned", "int", "fn_type", ";", "if", "(", "regno", "==", "arc_tp_regno", ")", "return", "true", ";", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "if", "(", "reload_completed", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "cfun", "->", "machine", "->", "fn_type", ")", ")", "{", "if", "(", "!", "fixed_regs", "[", "regno", "]", ")", "return", "true", ";", "return", "(", "(", "regno", "==", "arc_return_address_register", "(", "fn_type", ")", ")", "||", "(", "regno", "==", "RETURN_ADDR_REGNUM", ")", ")", ";", "}", "else", "return", "regno", "==", "RETURN_ADDR_REGNUM", ";", "}", "else", "return", "regno", "==", "arc_return_address_register", "(", "fn_type", ")", ";", "}", "</s>" ]

[ "Implement", "EPILOGUE__USES", ".", "Return", "true", "if", "REGNO", "should", "be", "added", "to", "the", "deemed", "uses", "of", "the", "epilogue", ".", "We", "use", "the", "return", "address", "arc_return_address_regs", "[", "arc_compute_function_type", "(", "cfun", ")", "]", ".", "But", "also", ",", "we", "have", "to", "make", "sure", "all", "the", "register", "restore", "instructions", "are", "known", "to", "be", "live", "in", "interrupt", "functions", ",", "plus", "the", "blink", "register", "if", "it", "is", "clobbered", "by", "the", "isr", "." ]

[ "arc" ]

[]

[ "<s>", "bool", "TVMMoveMaterializable", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Moving materializable close to their usage **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "C", "=", "&", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "runOnBasicBlocks", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "\"********** Moving materializable close to their usage **********\\n\"", "\"********** Function: \"", "TVM" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addRegBankSelect", "(", ")", "{", "addPass", "(", "new", "RegBankSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "register", "bank", "selector", "pass", ",", "which", "assigns", "register", "banks", "to", "virtual", "registers", "without", "a", "register", "class", "or", "register", "banks", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "int", "loongarch_address_insns", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "might_split_p", ")", "{", "struct", "loongarch_address_info", "addr", ";", "int", "factor", ";", "if", "(", "!", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "return", "0", ";", "if", "(", "mode", "!=", "BLKmode", "&&", "might_split_p", ")", "factor", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "else", "factor", "=", "1", ";", "if", "(", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "switch", "(", "addr", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "return", "factor", ";", "case", "ADDRESS_REG_REG", ":", "return", "factor", ";", "case", "ADDRESS_CONST_INT", ":", "return", "factor", ";", "case", "ADDRESS_SYMBOLIC", ":", "return", "factor", "*", "loongarch_symbol_insns", "(", "addr", ".", "symbol_type", ",", "mode", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "or", "store", "a", "value", "of", "mode", "MODE", "at", "address", "X", ".", "Return", "0", "if", "X", "is", "n't", "valid", "for", "MODE", ".", "Assume", "that", "multiword", "moves", "may", "need", "to", "be", "split", "into", "word", "moves", "if", "MIGHT_SPLIT_P", ",", "otherwise", "assume", "that", "a", "single", "load", "or", "store", "is", "enough", "." ]

[ "loongarch", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "bool", "s390_call_saved_register_used", "(", "tree", "call_expr", ")", "{", "CUMULATIVE_ARGS", "cum_v", ";", "cumulative_args_t", "cum", ";", "tree", "parameter", ";", "machine_mode", "mode", ";", "tree", "type", ";", "rtx", "parm_rtx", ";", "int", "reg", ",", "i", ";", "INIT_CUMULATIVE_ARGS", "(", "cum_v", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "cum", "=", "pack_cumulative_args", "(", "&", "cum_v", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "call_expr_nargs", "(", "call_expr", ")", ";", "i", "++", ")", "{", "parameter", "=", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "type", "=", "TREE_TYPE", "(", "parameter", ")", ";", "gcc_assert", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "gcc_assert", "(", "mode", ")", ";", "if", "(", "pass_by_reference", "(", "&", "cum_v", ",", "mode", ",", "type", ",", "true", ")", ")", "{", "mode", "=", "Pmode", ";", "type", "=", "build_pointer_type", "(", "type", ")", ";", "}", "parm_rtx", "=", "s390_function_arg", "(", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "s390_function_arg_advance", "(", "cum", ",", "mode", ",", "type", ",", "0", ")", ";", "if", "(", "!", "parm_rtx", ")", "continue", ";", "if", "(", "REG_P", "(", "parm_rtx", ")", ")", "{", "for", "(", "reg", "=", "0", ";", "reg", "<", "HARD_REGNO_NREGS", "(", "REGNO", "(", "parm_rtx", ")", ",", "GET_MODE", "(", "parm_rtx", ")", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_regs", "[", "reg", "+", "REGNO", "(", "parm_rtx", ")", "]", ")", "return", "true", ";", "}", "if", "(", "GET_CODE", "(", "parm_rtx", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "parm_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "r", "=", "XEXP", "(", "XVECEXP", "(", "parm_rtx", ",", "0", ",", "i", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "r", ")", ")", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "HARD_REGNO_NREGS", "(", "REGNO", "(", "r", ")", ",", "GET_MODE", "(", "r", ")", ")", ";", "reg", "++", ")", "if", "(", "!", "call_used_regs", "[", "reg", "+", "REGNO", "(", "r", ")", "]", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "ARGUMENT_LIST", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

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

[]

[ "<s>", "unsigned", "AAPRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "getFramePtrRegister", "(", ")", ":", "getStackPtrRegister", "(", ")", ";", "}", "</s>" ]

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

[ "AAP", "AAP" ]

[]

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

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

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

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be reloaded into\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MIB", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Define", ")", ";", "}", "MIB", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "0" ]

[]

[ "<s>", "static", "rtx", "h8300_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "R0_REG", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_LIBCALL_VALUE", ".", "On", "the", "H8", "the", "return", "value", "is", "in", "R0/R1", "." ]

[ "h8300" ]

[]

[ "<s>", "bool", "AArch64DeadRegisterDefinitions", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64DeadRegisterDefinitions *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "if", "(", "processMachineBasicBlock", "(", "MBB", ")", ")", "Changed", "=", "true", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64DeadRegisterDefinitions *****\\n\"" ]

[]

[ "<s>", "bool", "cris_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "const_rtx", "x1", ",", "x2", ";", "if", "(", "cris_base_or_autoincr_p", "(", "x", ",", "strict", ")", ")", "return", "true", ";", "else", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "(", "cris_base_p", "(", "x1", ",", "strict", ")", "&&", "CONSTANT_P", "(", "x2", ")", ")", "||", "(", "cris_base_p", "(", "x2", ",", "strict", ")", "&&", "CONSTANT_P", "(", "x1", ")", ")", "||", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "&&", "(", "(", "cris_base_p", "(", "x1", ",", "strict", ")", "&&", "cris_bdap_index_p", "(", "x2", ",", "strict", ")", ")", "||", "(", "cris_base_p", "(", "x2", ",", "strict", ")", "&&", "cris_bdap_index_p", "(", "x1", ",", "strict", ")", ")", "||", "(", "cris_base_p", "(", "x1", ",", "strict", ")", "&&", "cris_biap_index_p", "(", "x2", ",", "strict", ")", ")", "||", "(", "cris_base_p", "(", "x2", ",", "strict", ")", "&&", "cris_biap_index_p", "(", "x1", ",", "strict", ")", ")", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "&&", "cris_base_or_autoincr_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "cris", "0", "1", "0" ]

[]

[ "<s>", "bool", "ARMSubtarget", "::", "useFastISel", "(", ")", "const", "{", "return", "TM", ".", "Options", ".", "EnableFastISel", "&&", "(", "(", "isTargetMachO", "(", ")", "&&", "!", "isThumb1Only", "(", ")", ")", "||", "(", "isTargetLinux", "(", ")", "&&", "!", "isThumb", "(", ")", ")", "||", "(", "isTargetNaCl", "(", ")", "&&", "!", "isThumb", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "fast-isel", "is", "used", "." ]

[ "ARM", "ARM" ]

[]

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

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

[ "JVM", "JVM", "0" ]

[]

[ "<s>", "void", "RISCVELFTargetObjectFile", "::", "getModuleMetadata", "(", "Module", "&", "M", ")", "{", "TargetLoweringObjectFileELF", "::", "getModuleMetadata", "(", "M", ")", ";", "SmallVector", "<", "Module", "::", "ModuleFlagEntry", ",", "8", ">", "ModuleFlags", ";", "M", ".", "getModuleFlagsMetadata", "(", "ModuleFlags", ")", ";", "for", "(", "const", "auto", "&", "MFE", ":", "ModuleFlags", ")", "{", "StringRef", "Key", "=", "MFE", ".", "Key", "->", "getString", "(", ")", ";", "if", "(", "Key", "==", "\"SmallDataLimit\"", ")", "{", "SSThreshold", "=", "mdconst", "::", "extract", "<", "ConstantInt", ">", "(", "MFE", ".", "Val", ")", "->", "getZExtValue", "(", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Get", "the", "module-level", "metadata", "that", "the", "platform", "cares", "about", "." ]

[ "RISCV", "RISCV", "8", "\"SmallDataLimit\"" ]

[]

[ "<s>", "static", "rtx", "frv_expand_load_builtin", "(", "enum", "insn_code", "icode", ",", "machine_mode", "target_mode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "cookie", "=", "frv_io_address_cookie", "(", "op0", ")", ";", "if", "(", "target", "==", "0", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "target_mode", ")", ";", "op0", "=", "frv_volatile_memref", "(", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ",", "op0", ")", ";", "convert_move", "(", "target", ",", "op0", ",", "1", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "icode", ")", "(", "copy_rtx", "(", "op0", ")", ",", "cookie", ",", "GEN_INT", "(", "FRV_IO_READ", ")", ")", ")", ";", "cfun", "->", "machine", "->", "has_membar_p", "=", "1", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "__builtin_read", "*", "function", ".", "ICODE", "is", "the", "instruction", "code", "for", "the", "membar", "and", "TARGET_MODE", "is", "the", "mode", "that", "the", "loaded", "value", "should", "have", "." ]

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

[]

[ "<s>", "void", "MCS51MCInstLower", "::", "lowerInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "MachineOperand", "const", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "MI", ".", "print", "(", "errs", "(", ")", ")", ";", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "continue", ";", "MCOp", "=", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "continue", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "MCOp", "=", "lowerSymbolOperand", "(", "MO", ",", "Printer", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ")", ";", "break", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "Lowers", "a", "MachineInstr", "into", "a", "MCInst", "." ]

[ "MCS51", "MCS51", "\"unknown operand type\"" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "unsigned", "getMemSize", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Memory", "&&", "\"Invalid access!\"", ")", ";", "return", "Mem", ".", "Size", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "memory", "access", "." ]

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

[]

[ "<s>", "static", "int", "ep_memory_offset", "(", "machine_mode", "mode", ",", "int", "unsignedp", "ATTRIBUTE_UNUSED", ")", "{", "int", "max_offset", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "if", "(", "TARGET_SMALL_SLD", ")", "max_offset", "=", "(", "1", "<<", "4", ")", ";", "else", "if", "(", "(", "TARGET_V850E_UP", ")", "&&", "unsignedp", ")", "max_offset", "=", "(", "1", "<<", "4", ")", ";", "else", "max_offset", "=", "(", "1", "<<", "7", ")", ";", "break", ";", "case", "HImode", ":", "if", "(", "TARGET_SMALL_SLD", ")", "max_offset", "=", "(", "1", "<<", "5", ")", ";", "else", "if", "(", "(", "TARGET_V850E_UP", ")", "&&", "unsignedp", ")", "max_offset", "=", "(", "1", "<<", "5", ")", ";", "else", "max_offset", "=", "(", "1", "<<", "8", ")", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "max_offset", "=", "(", "1", "<<", "8", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "max_offset", ";", "}", "</s>" ]

[ "Return", "maximum", "offset", "supported", "for", "a", "short", "EP", "memory", "reference", "of", "mode", "MODE", "and", "signedness", "UNSIGNEDP", "." ]

[ "v850", "0", "1", "4", "1", "4", "1", "7", "1", "5", "1", "5", "1", "8", "1", "8" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateKernelFeatures", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "Triple", "TT", "(", "M", ".", "getTargetTriple", "(", ")", ")", ";", "static", "const", "StringRef", "IntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.workitem.id.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workitem.id.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.amdgcn.workgroup.id.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tgid.y\"", ",", "\"amdgpu-work-group-id-y\"", "}", ",", "{", "\"llvm.r600.read.tgid.z\"", ",", "\"amdgpu-work-group-id-z\"", "}", ",", "{", "\"llvm.r600.read.tidig.y\"", ",", "\"amdgpu-work-item-id-y\"", "}", ",", "{", "\"llvm.r600.read.tidig.z\"", ",", "\"amdgpu-work-item-id-z\"", "}", "}", ";", "static", "const", "StringRef", "HSAIntrinsicToAttr", "[", "]", "[", "2", "]", "=", "{", "{", "\"llvm.amdgcn.dispatch.ptr\"", ",", "\"amdgpu-dispatch-ptr\"", "}", ",", "{", "\"llvm.amdgcn.queue.ptr\"", ",", "\"amdgpu-queue-ptr\"", "}", ",", "{", "\"llvm.amdgcn.dispatch.id\"", ",", "\"amdgpu-dispatch-id\"", "}", "}", ";", "bool", "Changed", "=", "addAttrsForIntrinsics", "(", "M", ",", "IntrinsicToAttr", ")", ";", "if", "(", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ")", "{", "Changed", "|=", "addAttrsForIntrinsics", "(", "M", ",", "HSAIntrinsicToAttr", ")", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-queue-ptr\"", ")", ")", "continue", ";", "if", "(", "hasAddrSpaceCast", "(", "F", ")", ")", "F", ".", "addFnAttr", "(", "\"amdgpu-queue-ptr\"", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "2", "\"llvm.amdgcn.workitem.id.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.amdgcn.workitem.id.z\"", "\"amdgpu-work-item-id-z\"", "\"llvm.amdgcn.workgroup.id.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.amdgcn.workgroup.id.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tgid.y\"", "\"amdgpu-work-group-id-y\"", "\"llvm.r600.read.tgid.z\"", "\"amdgpu-work-group-id-z\"", "\"llvm.r600.read.tidig.y\"", "\"amdgpu-work-item-id-y\"", "\"llvm.r600.read.tidig.z\"", "\"amdgpu-work-item-id-z\"", "2", "\"llvm.amdgcn.dispatch.ptr\"", "\"amdgpu-dispatch-ptr\"", "\"llvm.amdgcn.queue.ptr\"", "\"amdgpu-queue-ptr\"", "\"llvm.amdgcn.dispatch.id\"", "\"amdgpu-dispatch-id\"", "\"amdgpu-queue-ptr\"", "\"amdgpu-queue-ptr\"" ]

[]

[ "<s>", "bool", "PTXInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "!", "isPredicated", "(", "MI", ")", "&&", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "isTerminator", "(", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "FeatureBitset", "MissingFeatures", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MissingFeatures", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "ensureLocals", "(", "Out", ")", ";", "auto", "Align", "=", "WebAssembly", "::", "GetDefaultP2AlignAny", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Align", "!=", "-", "1U", ")", "{", "auto", "&", "Op0", "=", "Inst", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getImm", "(", ")", "==", "-", "1", ")", "Op0", ".", "setImm", "(", "Align", ")", ";", "}", "if", "(", "is64", ")", "{", "auto", "Opc64", "=", "WebAssembly", "::", "getWasm64Opcode", "(", "static_cast", "<", "uint16_t", ">", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "if", "(", "Opc64", ">=", "0", ")", "{", "Inst", ".", "setOpcode", "(", "Opc64", ")", ";", "}", "}", "if", "(", "!", "SkipTypeCheck", "&&", "TC", ".", "typeCheck", "(", "IDLoc", ",", "Inst", ")", ")", "return", "true", ";", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "if", "(", "CurrentState", "==", "EndFunction", ")", "{", "onEndOfFunction", "(", "IDLoc", ")", ";", "}", "else", "{", "CurrentState", "=", "Instructions", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "{", "assert", "(", "MissingFeatures", ".", "count", "(", ")", ">", "0", "&&", "\"Expected missing features\"", ")", ";", "SmallString", "<", "128", ">", "Message", ";", "raw_svector_ostream", "OS", "(", "Message", ")", ";", "OS", "<<", "\"instruction requires:\"", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MissingFeatures", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "MissingFeatures", ".", "test", "(", "i", ")", ")", "OS", "<<", "' '", "<<", "getSubtargetFeatureName", "(", "i", ")", ";", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "Message", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "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", "." ]

[ "WebAssembly", "WebAssembly::GetDefaultP2AlignAny", "1U", "0", "1", "WebAssembly::getWasm64Opcode", "0", "0", "\"Expected missing features\"", "128", "\"instruction requires:\"", "0", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARMISD", "::", "ADDC", ":", "case", "ARMISD", "::", "ADDE", ":", "case", "ARMISD", "::", "SUBC", ":", "case", "ARMISD", "::", "SUBE", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "{", "SDValue", "LHS", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "ADDE", "&&", "isNullConstant", "(", "LHS", ")", "&&", "isNullConstant", "(", "RHS", ")", ")", "{", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "return", ";", "}", "}", "break", ";", "case", "ARMISD", "::", "CMOV", ":", "{", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "if", "(", "Known", ".", "isUnknown", "(", ")", ")", "return", ";", "KnownBits", "KnownRHS", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Depth", "+", "1", ")", ";", "Known", ".", "Zero", "&=", "KnownRHS", ".", "Zero", ";", "Known", ".", "One", "&=", "KnownRHS", ".", "One", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "case", "ARMISD", "::", "BFI", ":", "{", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "ConstantSDNode", "*", "CI", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "const", "APInt", "&", "Mask", "=", "CI", "->", "getAPIntValue", "(", ")", ";", "Known", ".", "Zero", "&=", "Mask", ";", "Known", ".", "One", "&=", "Mask", ";", "return", ";", "}", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "ARMISD::ADDC", "ARMISD::ADDE", "ARMISD::SUBC", "ARMISD::SUBE", "0", "0", "1", "ARMISD::ADDE", "1", "ARMISD::CMOV", "0", "1", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex", "ARMISD::BFI", "0", "1", "2" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "ARM" ]

[]

[ "<s>", "LanaiSubtarget", "&", "LanaiSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ")", "{", "bool", "reg_offset_p", "=", "reg_offset_addressing_ok_p", "(", "mode", ")", ";", "bool", "quad_offset_p", "=", "mode_supports_vsx_dform_quad", "(", "mode", ")", ";", "if", "(", "VECTOR_MEM_ALTIVEC_P", "(", "mode", ")", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "-", "16", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "TARGET_ELF", "&&", "RS6000_SYMBOL_REF_TLS_P", "(", "x", ")", ")", "return", "0", ";", "if", "(", "legitimate_indirect_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "TARGET_UPDATE", "&&", "(", "GET_CODE", "(", "x", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "&&", "mode_supports_pre_incdec_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "quad_offset_p", ")", "{", "if", "(", "quad_address_p", "(", "x", ",", "mode", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "}", "else", "if", "(", "virtual_stack_registers_memory_p", "(", "x", ")", ")", "return", "1", ";", "else", "if", "(", "reg_offset_p", ")", "{", "if", "(", "legitimate_small_data_p", "(", "mode", ",", "x", ")", ")", "return", "1", ";", "if", "(", "legitimate_constant_pool_address_p", "(", "x", ",", "mode", ",", "reg_ok_strict", "||", "lra_in_progress", ")", ")", "return", "1", ";", "if", "(", "reg_addr", "[", "mode", "]", ".", "fused_toc", "&&", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_FUSION_ADDIS", ")", "return", "1", ";", "}", "if", "(", "mode", "==", "TImode", "&&", "TARGET_VSX", ")", "return", "0", ";", "if", "(", "!", "reg_ok_strict", "&&", "reg_offset_p", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "REG", "&&", "(", "XEXP", "(", "x", ",", "0", ")", "==", "virtual_stack_vars_rtx", "||", "XEXP", "(", "x", ",", "0", ")", "==", "arg_pointer_rtx", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "return", "1", ";", "if", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ",", "false", ")", ")", "return", "1", ";", "if", "(", "!", "FLOAT128_2REG_P", "(", "mode", ")", "&&", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ")", "||", "TARGET_POWERPC64", "||", "(", "mode", "!=", "DFmode", "&&", "mode", "!=", "DDmode", ")", ")", "&&", "(", "TARGET_POWERPC64", "||", "mode", "!=", "DImode", ")", "&&", "(", "mode", "!=", "TImode", "||", "VECTOR_MEM_VSX_P", "(", "TImode", ")", ")", "&&", "mode", "!=", "PTImode", "&&", "!", "avoiding_indexed_address_p", "(", "mode", ")", "&&", "legitimate_indexed_address_p", "(", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "if", "(", "TARGET_UPDATE", "&&", "GET_CODE", "(", "x", ")", "==", "PRE_MODIFY", "&&", "mode_supports_pre_modify_p", "(", "mode", ")", "&&", "legitimate_indirect_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "reg_ok_strict", ")", "&&", "(", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ",", "reg_ok_strict", ",", "false", ")", "||", "(", "!", "avoiding_indexed_address_p", "(", "mode", ")", "&&", "legitimate_indexed_address_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "reg_ok_strict", ")", ")", ")", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "return", "1", ";", "if", "(", "reg_offset_p", "&&", "!", "quad_offset_p", "&&", "legitimate_lo_sum_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "TARGET_LEGITIMATE_ADDRESS_P", "recognizes", "an", "RTL", "expression", "that", "is", "a", "valid", "memory", "address", "for", "an", "instruction", ".", "The", "MODE", "argument", "is", "the", "machine", "mode", "for", "the", "MEM", "expression", "that", "wants", "to", "use", "this", "address", ".", "On", "the", "RS/6000", ",", "there", "are", "four", "valid", "address", ":", "a", "SYMBOL_REF", "that", "refers", "to", "a", "constant", "pool", "entry", "of", "an", "address", "(", "or", "the", "sum", "of", "it", "plus", "a", "constant", ")", ",", "a", "short", "(", "16-bit", "signed", ")", "constant", "plus", "a", "register", ",", "the", "sum", "of", "two", "registers", ",", "or", "a", "register", "indirect", ",", "possibly", "with", "an", "auto-increment", ".", "For", "DFmode", ",", "DDmode", "and", "DImode", "with", "a", "constant", "plus", "register", ",", "we", "must", "ensure", "that", "both", "words", "are", "addressable", "or", "PowerPC64", "with", "offset", "word", "aligned", ".", "For", "modes", "spanning", "multiple", "registers", "(", "DFmode", "and", "DDmode", "in", "32-bit", "GPRs", ",", "32-bit", "DImode", ",", "TImode", ",", "TFmode", ",", "TDmode", ")", ",", "indexed", "addressing", "can", "not", "be", "used", "because", "adjacent", "memory", "cells", "are", "accessed", "by", "adding", "word-sized", "offsets", "during", "assembly", "output", "." ]

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

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "report_fatal_error", "(", "\"TOYAsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "\"TOYAsmBackend::relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "static", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "fntype", ";", "if", "(", "decl", ")", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "else", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "TARGET_ALTIVEC_VRSAVE", "&&", "!", "(", "decl", "&&", "decl", "==", "current_function_decl", ")", ")", "{", "function_args_iterator", "args_iter", ";", "tree", "type", ";", "int", "nvreg", "=", "0", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "++", ";", "FOREACH_FUNCTION_ARGS", "(", "TREE_TYPE", "(", "current_function_decl", ")", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "--", ";", "if", "(", "nvreg", ">", "0", ")", "return", "false", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "||", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "decl", "&&", "!", "DECL_EXTERNAL", "(", "decl", ")", "&&", "!", "DECL_WEAK", "(", "decl", ")", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "!", "TARGET_SECURE_PLT", "||", "!", "flag_pic", "||", "(", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ")", ")", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "fntype", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "powerpcspe", "0", "0", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "return", "RegInfo", "->", "hasFP", "(", "MF", ")", "?", "4", ":", "5", ";", "case", "ARM", "::", "GPRRegClassID", ":", "{", "unsigned", "FP", "=", "RegInfo", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "10", "-", "FP", "-", "(", "Subtarget", "->", "isR9Reserved", "(", ")", "?", "1", ":", "0", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "32", "-", "10", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "ARM", "ARM", "0", "ARM::tGPRRegClassID", "4", "5", "ARM::GPRRegClassID", "1", "0", "10", "1", "0", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "32", "10" ]

[]

[ "<s>", "DecodeStatus", "MMIXDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "uint32_t", "Inst", "=", "support", "::", "endian", "::", "read32be", "(", "Bytes", ".", "data", "(", ")", ")", ";", "return", "decodeInstruction", "(", "DecoderTableMMIX32", ",", "MI", ",", "Inst", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "4", "4", "0", "support::endian", "MMIX" ]

[]

[ "<s>", "bool", "X86TargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "int", "ix86_fp_comparison_cost", "(", "enum", "rtx_code", "code", ")", "{", "int", "arith_cost", ";", "switch", "(", "code", ")", "{", "case", "UNLE", ":", "case", "UNLT", ":", "case", "LTGT", ":", "case", "GT", ":", "case", "GE", ":", "case", "UNORDERED", ":", "case", "ORDERED", ":", "case", "UNEQ", ":", "arith_cost", "=", "4", ";", "break", ";", "case", "LT", ":", "case", "NE", ":", "case", "EQ", ":", "case", "UNGE", ":", "arith_cost", "=", "TARGET_IEEE_FP", "?", "5", ":", "4", ";", "break", ";", "case", "LE", ":", "case", "UNGT", ":", "arith_cost", "=", "TARGET_IEEE_FP", "?", "6", ":", "4", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "ix86_fp_comparison_strategy", "(", "code", ")", ")", "{", "case", "IX86_FPCMP_COMI", ":", "return", "arith_cost", ">", "4", "?", "3", ":", "2", ";", "case", "IX86_FPCMP_SAHF", ":", "return", "arith_cost", ">", "4", "?", "4", ":", "3", ";", "default", ":", "return", "arith_cost", ";", "}", "}", "</s>" ]

[ "Compute", "cost", "of", "the", "comparison", "done", "using", "any", "method", ".", "See", "ix86_fp_comparison_arithmetics_cost", "for", "the", "metrics", "." ]

[ "i386", "4", "5", "4", "6", "4", "4", "3", "2", "4", "4", "3" ]

[]

[ "<s>", "int", "fp_zero_operand", "(", "rtx", "op", ")", "{", "REAL_VALUE_TYPE", "r", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "0", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "return", "REAL_VALUES_EQUAL", "(", "r", ",", "dconst0", ")", "&&", "!", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ";", "}", "</s>" ]

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

[ "sh", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "BlackfinFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "BlackfinRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "BlackfinRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "BlackfinInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "BlackfinInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "RegInfo", "->", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "UNLINK", ")", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "0", "\"Misaligned frame size\"", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "BF::UNLINK" ]

[]

[ "<s>", "const", "RegisterBankInfo", "*", "X86Subtarget", "::", "getRegBankInfo", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getRegBankInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Access to GlobalISel APIs not set\"" ]

[]

[ "<s>", "void", "AArch64TTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "BaseT", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "UP", ".", "UpperBound", "=", "true", ";", "if", "(", "L", "->", "getLoopDepth", "(", ")", ">", "1", ")", "UP", ".", "PartialThreshold", "*=", "2", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "ST", "->", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "Falkor", "&&", "EnableFalkorHWPFUnrollFix", ")", "getFalkorUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "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", ";", "}", "}", "}", "if", "(", "ST", "->", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Others", "&&", "!", "ST", "->", "getSchedModel", "(", ")", ".", "isOutOfOrder", "(", ")", ")", "{", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1", "2", "0", "AArch64", "AArch64", "4", "60" ]

[]

[ "<s>", "static", "bool", "unspec_caller_rtx_p", "(", "rtx", "pat", ")", "{", "switch", "(", "GET_CODE", "(", "pat", ")", ")", "{", "case", "CONST", ":", "return", "unspec_caller_rtx_p", "(", "XEXP", "(", "pat", ",", "0", ")", ")", ";", "case", "PLUS", ":", "case", "MINUS", ":", "if", "(", "unspec_caller_rtx_p", "(", "XEXP", "(", "pat", ",", "0", ")", ")", ")", "return", "true", ";", "return", "unspec_caller_rtx_p", "(", "XEXP", "(", "pat", ",", "1", ")", ")", ";", "case", "UNSPEC", ":", "if", "(", "XINT", "(", "pat", ",", "1", ")", "==", "UNSPEC_CALLER", ")", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "PAT", "includes", "UNSPEC_CALLER", "unspec", "pattern", "." ]

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

[]

[ "<s>", "const", "char", "*", "aarch64_output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ";", "rtx", "xops", "[", "2", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"sub\\t%0, %0, %1\"", ",", "xops", ")", ";", "output_asm_insn", "(", "\"str\\txzr, [%0]\"", ",", "xops", ")", ";", "xops", "[", "1", "]", "=", "reg2", ";", "output_asm_insn", "(", "\"cmp\\t%0, %1\"", ",", "xops", ")", ";", "fputs", "(", "\"\\tb.ne\\t\"", ",", "asm_out_file", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Probe", "a", "range", "of", "stack", "addresses", "from", "REG1", "to", "REG2", "inclusive", ".", "These", "are", "absolute", "addresses", "." ]

[ "aarch64", "0", "32", "2", "\"LPSRL\"", "0", "1", "\"sub\\t%0, %0, %1\"", "\"str\\txzr, [%0]\"", "1", "\"cmp\\t%0, %1\"", "\"\\tb.ne\\t\"", "\"\"" ]

[]

[ "<s>", "int", "iq2000_reg_mode_ok_for_base_p", "(", "rtx", "reg", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "strict", ")", "{", "return", "(", "strict", "?", "REGNO_MODE_OK_FOR_BASE_P", "(", "REGNO", "(", "reg", ")", ",", "mode", ")", ":", "GP_REG_OR_PSEUDO_NONSTRICT_P", "(", "REGNO", "(", "reg", ")", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REG", "is", "valid", "for", "MODE", "." ]

[ "iq2000" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "addPass", "(", "new", "ARMExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "this", "->", "TM", "->", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ".", "restrictIT", "(", ")", ";", "}", ")", ")", ";", "addPass", "(", "createIfConverter", "(", "[", "]", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "!", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ";", "}", ")", ")", ";", "}", "addPass", "(", "createMVEVPTBlockPass", "(", ")", ")", ";", "addPass", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "reg", ",", "count", ";", "int", "int_or_sig_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", "return", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "(", "REG_Y", "+", "1", ")", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "." ]

[ "avr", "0", "0", "0", "32", "1" ]

[]

[ "<s>", "void", "AMDGPUTTI", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "Count", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "800", ";", "}", "}", "}", "}", "</s>" ]

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

[ "R600", "300", "AMDGPUAS::PRIVATE_ADDRESS", "800" ]

[]

[ "<s>", "static", "int", "riscv_binary_cost", "(", "rtx", "x", ",", "int", "single_insns", ",", "int", "double_insns", ")", "{", "if", "(", "!", "riscv_v_ext_vector_mode_p", "(", "GET_MODE", "(", "x", ")", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ".", "to_constant", "(", ")", "==", "UNITS_PER_WORD", "*", "2", ")", "return", "COSTS_N_INSNS", "(", "double_insns", ")", ";", "return", "COSTS_N_INSNS", "(", "single_insns", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "binary", "operation", "X", ",", "given", "that", "the", "instruction", "sequence", "for", "a", "word-sized", "or", "smaller", "operation", "takes", "SIGNLE_INSNS", "instructions", "and", "that", "the", "sequence", "of", "a", "double-word", "operation", "takes", "DOUBLE_INSNS", "instructions", "." ]

[ "riscv", "2" ]

[]

[ "<s>", "MCObjectWriter", "*", "createObjectWriter", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "return", "createAArch64ELFObjectWriter", "(", "OS", ",", "OSABI", ",", "IsLittleEndian", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getGPRsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "</s>" ]

[ "getGPRsForTailCall", "-", "Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "." ]

[ "X86", "X86", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

[]

[ "<s>", "static", "bool", "mips_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "mprocDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "mproc", "mproc" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "GlobalBaseReg", "=", "0", ";", "PPCLowering", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getTargetLowering", "(", ")", ";", "PPCSubTarget", "=", "TM", ".", "getSubtargetImpl", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "if", "(", "!", "PPCSubTarget", "->", "isSVR4ABI", "(", ")", ")", "InsertVRSaveCode", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "movd44_even_dep_p", "(", "rtx_insn", "*", "insn", ",", "rtx", "def_reg", ")", "{", "if", "(", "!", "movd44_insn_p", "(", "insn", ")", ")", "return", "false", ";", "rtx", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "if", "(", "REG_P", "(", "def_reg", ")", ")", "{", "return", "rtx_equal_p", "(", "def_reg", ",", "use_rtx", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "def_reg", ")", "==", "SUBREG", "&&", "GET_MODE", "(", "def_reg", ")", "==", "SImode", "&&", "rtx_equal_p", "(", "SUBREG_REG", "(", "def_reg", ")", ",", "use_rtx", ")", ")", "{", "if", "(", "TARGET_BIG_ENDIAN", "&&", "SUBREG_BYTE", "(", "def_reg", ")", "==", "4", ")", "return", "true", ";", "if", "(", "!", "TARGET_BIG_ENDIAN", "&&", "SUBREG_BYTE", "(", "def_reg", ")", "==", "0", ")", "return", "true", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "a", "movd44", "insn", "consuming", "DEF_REG", "." ]

[ "nds32", "4", "0" ]

[]

[ "<s>", "static", "bool", "mips16_unextended_reference_p", "(", "machine_mode", "mode", ",", "rtx", "base", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "mode", "!=", "BLKmode", "&&", "offset", "%", "GET_MODE_SIZE", "(", "mode", ")", "==", "0", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", "&&", "base", "==", "stack_pointer_rtx", ")", "return", "offset", "<", "256U", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "offset", "<", "32U", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "value", "at", "OFFSET", "bytes", "from", "BASE", "can", "be", "accessed", "using", "an", "unextended", "mips16", "instruction", ".", "MODE", "is", "the", "mode", "of", "the", "value", ".", "Usually", "the", "offset", "in", "an", "unextended", "instruction", "is", "a", "5-bit", "field", ".", "The", "offset", "is", "unsigned", "and", "shifted", "left", "once", "for", "HIs", ",", "twice", "for", "SIs", ",", "and", "so", "on", ".", "An", "exception", "is", "SImode", "accesses", "off", "the", "stack", "pointer", ",", "which", "have", "an", "8-bit", "immediate", "field", "." ]

[ "mips", "0", "4", "256U", "32U" ]

[]

[ "<s>", "static", "int", "res_mii", "(", "unit_req_table", "reqs", ")", "{", "int", "side", ",", "req", ";", "int", "worst", "=", "1", ";", "for", "(", "side", "=", "0", ";", "side", "<", "2", ";", "side", "++", ")", "for", "(", "req", "=", "0", ";", "req", "<", "UNIT_REQ_MAX", ";", "req", "++", ")", "{", "int", "factor", "=", "unit_req_factor", "(", "(", "enum", "unitreqs", ")", "req", ")", ";", "worst", "=", "MAX", "(", "(", "reqs", "[", "side", "]", "[", "UNIT_REQ_D", "]", "+", "factor", "-", "1", ")", "/", "factor", ",", "worst", ")", ";", "}", "return", "worst", ";", "}", "</s>" ]

[ "Return", "the", "resource-constrained", "minimum", "iteration", "interval", "given", "the", "data", "in", "the", "REQS", "table", ".", "This", "must", "have", "been", "processed", "with", "merge_unit_reqs", "already", "." ]

[ "c6x", "1", "0", "2", "0", "1" ]

[]

[ "<s>", "bool", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "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", "(", ")", "." ]

[ "Hexagon" ]

[]

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

[ "targetHandlesStackFrameRounding", "-", "Returns", "true", "if", "the", "target", "is", "responsible", "for", "rounding", "up", "the", "stack", "frame", "(", "probably", "at", "emitPrologue", "time", ")", "." ]

[ "MBlaze" ]

[]

[ "<s>", "void", "update", "(", "Register", "R", ",", "const", "LatticeCell", "&", "L", ")", "{", "Map", "[", "R", "]", "=", "L", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "OR1KAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "OR1KOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "Error", "(", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "\"unexpected token in operand list\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "OR1K", "OR1K", "OR1KOperand::CreateToken", "\"unexpected token in operand list\"" ]

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "case", "MSP430", "::", "RETI", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FP", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "FP", ")", ";", "if", "(", "CSSize", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "CSSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SP", ")", ".", "addReg", "(", "MSP430", "::", "SP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "MSP430::RETI", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FP", "MSP430::POP16r", "MSP430::MOV16rr", "MSP430::SP", "MSP430::FP", "MSP430::SUB16ri", "MSP430::SP", "MSP430::SP", "3", "MSP430::ADD16ri", "MSP430::SP", "MSP430::SP", "3" ]

[]

[ "<s>", "int", "aarch64_partial_ptrue_length", "(", "rtx_vector_builder", "&", "builder", ",", "unsigned", "int", "elt_size", ")", "{", "if", "(", "builder", ".", "nelts_per_pattern", "(", ")", "==", "3", ")", "return", "0", ";", "unsigned", "int", "nelts", "=", "builder", ".", "encoded_nelts", "(", ")", ";", "unsigned", "int", "i", "=", "0", ";", "for", "(", ";", "i", "<", "nelts", ";", "i", "+=", "elt_size", ")", "if", "(", "INTVAL", "(", "builder", ".", "elt", "(", "i", ")", ")", "==", "0", ")", "break", ";", "unsigned", "int", "vl", "=", "i", "/", "elt_size", ";", "if", "(", "i", "==", "nelts", ")", "return", "-", "1", ";", "if", "(", "builder", ".", "nelts_per_pattern", "(", ")", "!=", "2", ")", "return", "0", ";", "if", "(", "i", ">", "builder", ".", "npatterns", "(", ")", "&&", "maybe_ne", "(", "nelts", ",", "builder", ".", "full_nelts", "(", ")", ")", ")", "return", "0", ";", "for", "(", ";", "i", "<", "nelts", ";", "i", "+=", "elt_size", ")", "if", "(", "INTVAL", "(", "builder", ".", "elt", "(", "i", ")", ")", "!=", "0", ")", "return", "0", ";", "return", "vl", ";", "}", "</s>" ]

[ "BUILDER", "is", "a", "predicate", "constant", "of", "mode", "VNx16BI", ".", "Consider", "the", "value", "that", "the", "constant", "would", "have", "with", "predicate", "element", "size", "ELT_SIZE", "(", "ignoring", "the", "upper", "bits", "in", "each", "element", ")", "and", "return", ":", "*", "-1", "if", "all", "bits", "are", "set", "*", "N", "if", "the", "predicate", "has", "N", "leading", "set", "bits", "followed", "by", "all", "clear", "bits", "*", "0", "if", "the", "predicate", "does", "not", "have", "any", "of", "these", "forms", "." ]

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

[]

[ "<s>", "LLT", "AArch64TargetLowering", "::", "getOptimalMemOpLLT", "(", "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", "LLT", "::", "vector", "(", "2", ",", "64", ")", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "Align", "(", "16", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "128", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "Align", "(", "8", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "Align", "(", "4", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "32", ")", ";", "return", "LLT", "(", ")", ";", "}", "</s>" ]

[ "LLT", "returning", "variant", "." ]

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

[]

[ "<s>", "rtx", "legitimize_pic_address", "(", "rtx", "orig", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "reg", ")", "{", "if", "(", "tls_symbolic_operand", "(", "orig", ",", "Pmode", ")", ")", "return", "orig", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_LOCAL_P", "(", "orig", ")", ")", ")", "{", "if", "(", "reg", "==", "0", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_symGOTOFF2reg", "(", "reg", ",", "orig", ")", ")", ";", "return", "reg", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "reg", "==", "0", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_symGOT2reg", "(", "reg", ",", "orig", ")", ")", ";", "return", "reg", ";", "}", "return", "orig", ";", "}", "</s>" ]

[ "Legitimize", "PIC", "addresses", ".", "If", "the", "address", "is", "already", "position-independent", ",", "we", "return", "ORIG", ".", "Newly", "generated", "position-independent", "addresses", "go", "into", "a", "reg", ".", "This", "is", "REG", "if", "nonzero", ",", "otherwise", "we", "allocate", "register", "(", "s", ")", "as", "necessary", "." ]

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

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "std", "::", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", ".", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", ".", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "hexagon_L2_loadrd_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadri_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrh_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadruh_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrb_pbr", ":", "case", "Intrinsic", "::", "hexagon_L2_loadrub_pbr", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "auto", "&", "DL", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "&", "Cont", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getParent", "(", ")", "->", "getContext", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "I", ".", "getCalledFunction", "(", ")", "->", "getReturnType", "(", ")", "->", "getContainedType", "(", "0", ")", "->", "getPointerTo", "(", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "PtrTy", "->", "getElementType", "(", ")", ")", ";", "llvm", "::", "Value", "*", "BasePtrVal", "=", "I", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "ptrVal", "=", "getUnderLyingObjectForBrevLdIntr", "(", "BasePtrVal", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "DL", ".", "getABITypeAlignment", "(", "Info", ".", "memVT", ".", "getTypeForEVT", "(", "Cont", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", ";", "return", "true", ";", "}", "case", "Intrinsic", "::", "hexagon_V6_vgathermw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq_128B", ":", "{", "const", "Module", "&", "M", "=", "*", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Type", "*", "VecTy", "=", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "VecTy", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "M", ".", "getDataLayout", "(", ")", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", "/", "8", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Intrinsic::hexagon_L2_loadrd_pbr", "Intrinsic::hexagon_L2_loadri_pbr", "Intrinsic::hexagon_L2_loadrh_pbr", "Intrinsic::hexagon_L2_loadruh_pbr", "Intrinsic::hexagon_L2_loadrb_pbr", "Intrinsic::hexagon_L2_loadrub_pbr", "ISD::INTRINSIC_W_CHAIN", "0", "MVT::getVT", "0", "0", "Intrinsic::hexagon_V6_vgathermw", "Intrinsic::hexagon_V6_vgathermw_128B", "Intrinsic::hexagon_V6_vgathermh", "Intrinsic::hexagon_V6_vgathermh_128B", "Intrinsic::hexagon_V6_vgathermhw", "Intrinsic::hexagon_V6_vgathermhw_128B", "Intrinsic::hexagon_V6_vgathermwq", "Intrinsic::hexagon_V6_vgathermwq_128B", "Intrinsic::hexagon_V6_vgathermhq", "Intrinsic::hexagon_V6_vgathermhq_128B", "Intrinsic::hexagon_V6_vgathermhwq", "Intrinsic::hexagon_V6_vgathermhwq_128B", "ISD::INTRINSIC_W_CHAIN", "1", "MVT::getVT", "0", "0", "8" ]

[]

[ "<s>", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "ARMBaseInstrInfo", "::", "getExecutionDomain", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVD", "&&", "!", "isPredicated", "(", "MI", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "if", "(", "Subtarget", ".", "isLikeA9", "(", ")", "&&", "!", "isPredicated", "(", "MI", ")", "&&", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVRS", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVSR", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "VMOVS", ")", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "(", "1", "<<", "ExeVFP", ")", "|", "(", "1", "<<", "ExeNEON", ")", ")", ";", "unsigned", "Domain", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainNEON", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "(", "Domain", "&", "ARMII", "::", "DomainNEONA8", ")", "&&", "Subtarget", ".", "isCortexA8", "(", ")", ")", "return", "std", "::", "make_pair", "(", "ExeNEON", ",", "0", ")", ";", "if", "(", "Domain", "&", "ARMII", "::", "DomainVFP", ")", "return", "std", "::", "make_pair", "(", "ExeVFP", ",", "0", ")", ";", "return", "std", "::", "make_pair", "(", "ExeGeneric", ",", "0", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::VMOVD", "1", "1", "ARM::VMOVRS", "ARM::VMOVSR", "ARM::VMOVS", "1", "1", "ARMII::DomainMask", "ARMII::DomainNEON", "0", "ARMII::DomainNEONA8", "0", "ARMII::DomainVFP", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "std", "::", "string", "CPU", ",", "std", "::", "string", "FS", ")", "const", "{", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "I", "=", "llvm", "::", "make_unique", "<", "WebAssemblySubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "MBlaze" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isCandidateToMergeOrPair", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "\"Expected a reg or frame index operand.\"", ")", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", ")", "{", "Register", "BaseReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "if", "(", "MI", ".", "modifiesRegister", "(", "BaseReg", ",", "TRI", ")", ")", "return", "false", ";", "}", "if", "(", "isLdStPairSuppressed", "(", "MI", ")", ")", "return", "false", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MI", ".", "getMF", "(", ")", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "bool", "NeedsWinCFI", "=", "MAI", "->", "usesWindowsCFI", "(", ")", "&&", "MI", ".", "getMF", "(", ")", "->", "getFunction", "(", ")", ".", "needsUnwindTableEntry", "(", ")", ";", "if", "(", "NeedsWinCFI", "&&", "(", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "||", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "isPaired128Slow", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "STRQui", ":", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "is", "a", "load/store", "that", "can", "be", "potentially", "paired/merged", "." ]

[ "AArch64", "AArch64", "1", "1", "\"Expected a reg or frame index operand.\"", "2", "1", "1", "AArch64::LDURQi", "AArch64::STURQi", "AArch64::LDRQui", "AArch64::STRQui" ]

[]