Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RVFI", "->", "getRVVStackSize", "(", ")", "&&", "(", "!", "hasFP", "(", "MF", ")", "||", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ")", ")", "{", "int", "ScalarLocalVarSize", "=", "FrameSize", "-", "RVFI", "->", "getCalleeSavedStackSize", "(", ")", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "auto", "RVVPadding", "=", "offsetToAlignment", "(", "ScalarLocalVarSize", ",", "RVFI", "->", "getRVVStackAlign", "(", ")", ")", ")", "RVFI", "->", "setRVVPadding", "(", "RVVPadding", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "Videocore", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Videocore", "Videocore::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "Mips16InstrInfo", "::", "isCopyInstr", "(", "const", "MachineInstr", "&", "MI", ",", "MachineOperand", "&", "Src", ",", "MachineOperand", "&", "Dest", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "{", "Dest", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "Mips", "Mips", "0", "1" ]

[]

[ "<s>", "Value", "*", "simplify", "(", "Instruction", "*", "I", ",", "const", "TargetLibraryInfo", "*", "TLI", ")", "{", "return", "SimplifyInstruction", "(", "I", ",", "{", "*", "TD", ",", "TLI", ",", "DT", "}", ")", ";", "}", "</s>" ]

[ "Go", "through", "all", "the", "nodes", "in", "the", "graph", "and", "collapse", "any", "two", "nodes", "'", "a", "'", "and", "'", "b", "'", "if", "all", "of", "the", "following", "are", "true", ":" ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "rs6000_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "TARGET_ELF", "&&", "tls_referenced_p", "(", "x", ")", ")", "return", "false", ";", "return", "(", "(", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_VECTOR", ")", "||", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "||", "(", "TARGET_POWERPC64", "&&", "mode", "==", "DImode", ")", "||", "easy_fp_constant", "(", "x", ",", "mode", ")", "||", "easy_vector_constant", "(", "x", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "On", "the", "RS/6000", ",", "all", "integer", "constants", "are", "acceptable", ",", "most", "wo", "n't", "be", "valid", "for", "particular", "insns", ",", "though", ".", "Only", "easy", "FP", "constants", "are", "acceptable", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_get_next_set_bit", "(", "sbitmap", "bmp", ",", "unsigned", "int", "start", ")", "{", "unsigned", "int", "nbits", "=", "SBITMAP_SIZE", "(", "bmp", ")", ";", "if", "(", "start", "==", "nbits", ")", "return", "start", ";", "gcc_assert", "(", "start", "<", "nbits", ")", ";", "for", "(", "unsigned", "int", "i", "=", "start", ";", "i", "<", "nbits", ";", "i", "++", ")", "if", "(", "bitmap_bit_p", "(", "bmp", ",", "i", ")", ")", "return", "i", ";", "return", "nbits", ";", "}", "</s>" ]

[ "Return", "the", "next", "set", "bit", "in", "BMP", "from", "START", "onwards", ".", "Return", "the", "total", "number", "of", "bits", "in", "BMP", "if", "no", "set", "bit", "is", "found", "at", "or", "after", "START", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx", "rs6000_function_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "if", "(", "rs6000_darwin64_abi", "&&", "TYPE_MODE", "(", "valtype", ")", "==", "BLKmode", "&&", "TREE_CODE", "(", "valtype", ")", "==", "RECORD_TYPE", "&&", "int_size_in_bytes", "(", "valtype", ")", ">", "0", ")", "{", "CUMULATIVE_ARGS", "valcum", ";", "rtx", "valret", ";", "valcum", ".", "words", "=", "0", ";", "valcum", ".", "fregno", "=", "FP_ARG_MIN_REG", ";", "valcum", ".", "vregno", "=", "ALTIVEC_ARG_MIN_REG", ";", "valret", "=", "rs6000_darwin64_record_arg", "(", "&", "valcum", ",", "valtype", ",", "1", ",", "true", ")", ";", "if", "(", "valret", ")", "return", "valret", ";", "}", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "TYPE_MODE", "(", "valtype", ")", "==", "DImode", ")", "{", "return", "gen_rtx_PARALLEL", "(", "DImode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", "+", "1", ")", ",", "GEN_INT", "(", "4", ")", ")", ")", ")", ";", "}", "if", "(", "TARGET_32BIT", "&&", "TARGET_POWERPC64", "&&", "TYPE_MODE", "(", "valtype", ")", "==", "DCmode", ")", "{", "return", "gen_rtx_PARALLEL", "(", "DCmode", ",", "gen_rtvec", "(", "4", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", ")", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", "+", "1", ")", ",", "GEN_INT", "(", "4", ")", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", "+", "2", ")", ",", "GEN_INT", "(", "8", ")", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "SImode", ",", "GP_ARG_RETURN", "+", "3", ")", ",", "GEN_INT", "(", "12", ")", ")", ")", ")", ";", "}", "if", "(", "(", "INTEGRAL_TYPE_P", "(", "valtype", ")", "&&", "TYPE_PRECISION", "(", "valtype", ")", "<", "BITS_PER_WORD", ")", "||", "POINTER_TYPE_P", "(", "valtype", ")", ")", "mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "else", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "valtype", ")", "&&", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "COMPLEX_TYPE", "&&", "targetm", ".", "calls", ".", "split_complex_arg", ")", "return", "rs6000_complex_function_value", "(", "mode", ")", ";", "else", "if", "(", "TREE_CODE", "(", "valtype", ")", "==", "VECTOR_TYPE", "&&", "TARGET_ALTIVEC", "&&", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DCmode", ")", ")", "return", "spe_build_register_parallel", "(", "mode", ",", "GP_ARG_RETURN", ")", ";", "else", "regno", "=", "GP_ARG_RETURN", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", ".", "On", "the", "SPE", ",", "both", "FPs", "and", "vectors", "are", "returned", "in", "r3", ".", "On", "RS/6000", "an", "integer", "value", "is", "in", "r3", "and", "a", "floating-point", "value", "is", "in", "fp1", ",", "unless", "-msoft-float", "." ]

[ "rs6000", "0", "0", "1", "2", "1", "4", "4", "1", "4", "2", "8", "3", "12" ]

[]

[ "<s>", "static", "rtvec", "rs6000_const_vec", "(", "machine_mode", "mode", ")", "{", "int", "i", ",", "subparts", ";", "rtvec", "v", ";", "switch", "(", "mode", ")", "{", "case", "V1TImode", ":", "subparts", "=", "1", ";", "break", ";", "case", "V2DFmode", ":", "case", "V2DImode", ":", "subparts", "=", "2", ";", "break", ";", "case", "V4SFmode", ":", "case", "V4SImode", ":", "subparts", "=", "4", ";", "break", ";", "case", "V8HImode", ":", "subparts", "=", "8", ";", "break", ";", "case", "V16QImode", ":", "subparts", "=", "16", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "v", "=", "rtvec_alloc", "(", "subparts", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "subparts", "/", "2", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "+", "subparts", "/", "2", ")", ";", "for", "(", "i", "=", "subparts", "/", "2", ";", "i", "<", "subparts", ";", "++", "i", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "gen_rtx_CONST_INT", "(", "DImode", ",", "i", "-", "subparts", "/", "2", ")", ";", "return", "v", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "of", "constants", "to", "permute", "MODE", "for", "a", "little-endian", "storage", "operation", "by", "swapping", "the", "two", "halves", "of", "a", "vector", "." ]

[ "rs6000", "1", "2", "4", "8", "16", "0", "2", "2", "2", "2" ]

[]

[ "<s>", "rtx_insn", "*", "s390_load_got", "(", "void", ")", "{", "rtx_insn", "*", "insns", ";", "rtx", "got_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "if", "(", "!", "got_symbol", ")", "{", "got_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "got_symbol", ")", "=", "SYMBOL_FLAG_LOCAL", ";", "}", "start_sequence", "(", ")", ";", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "emit_move_insn", "(", "got_rtx", ",", "got_symbol", ")", ";", "}", "else", "{", "rtx", "offset", ";", "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "got_symbol", ")", ",", "UNSPEC_LTREL_OFFSET", ")", ";", "offset", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset", ")", ";", "offset", "=", "force_const_mem", "(", "Pmode", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "offset", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "XEXP", "(", "offset", ",", "0", ")", ")", ",", "UNSPEC_LTREL_BASE", ")", ";", "offset", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "got_rtx", ",", "offset", ")", ";", "emit_move_insn", "(", "got_rtx", ",", "offset", ")", ";", "}", "insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "insns", ";", "}", "</s>" ]

[ "Return", "insn", "sequence", "to", "load", "the", "GOT", "register", "." ]

[ "s390", "12", "\"_GLOBAL_OFFSET_TABLE_\"", "1", "1", "0" ]

[]

[ "<s>", "inline", "static", "void", "drop_front", "(", "StringRef", "&", "str", ",", "size_t", "n", "=", "1", ")", "{", "str", "=", "str", ".", "drop_front", "(", "n", ")", ";", "}", "</s>" ]

[ "Return", "a", "StringRef", "equal", "to", "'this", "'", "but", "with", "the", "first", "N", "elements", "dropped", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "&", "Op", "=", "static_cast", "<", "ARMOperand", "&", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK__35_8", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "8", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK__35_16", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "16", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ModImm", ":", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", ".", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "evaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "std", "::", "numeric_limits", "<", "int32_t", ">", "::", "min", "(", ")", "&&", "Value", "<=", "std", "::", "numeric_limits", "<", "uint32_t", ">", "::", "max", "(", ")", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_rGPR", ":", "if", "(", "hasV8Ops", "(", ")", "&&", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "==", "ARM", "::", "SP", ")", "return", "Match_Success", ";", "return", "Match_rGPR", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", ".", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "8", "16", "\"expression value must be representable in 32 bits\"", "ARM::SP", "ARM::GPRRegClassID" ]

[]

[ "<s>", "void", "MipsTargetELFStreamer", "::", "finish", "(", ")", "{", "MCAssembler", "&", "MCA", "=", "getStreamer", "(", ")", ".", "getAssembler", "(", ")", ";", "MCContext", "&", "Context", "=", "MCA", ".", "getContext", "(", ")", ";", "MCStreamer", "&", "OS", "=", "getStreamer", "(", ")", ";", "const", "MCObjectFileInfo", "&", "OFI", "=", "*", "Context", ".", "getObjectFileInfo", "(", ")", ";", "Triple", "T", "(", "STI", ".", "getTargetTriple", "(", ")", ")", ";", "uint64_t", "Features", "=", "STI", ".", "getFeatureBits", "(", ")", ";", "MCSectionData", "&", "TextSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getTextSection", "(", ")", ")", ";", "MCSectionData", "&", "DataSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getDataSection", "(", ")", ")", ";", "MCSectionData", "&", "BSSSectionData", "=", "MCA", ".", "getOrCreateSectionData", "(", "*", "OFI", ".", "getBSSSection", "(", ")", ")", ";", "TextSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "TextSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "DataSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "DataSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "BSSSectionData", ".", "setAlignment", "(", "std", "::", "max", "(", "16u", ",", "BSSSectionData", ".", "getAlignment", "(", ")", ")", ")", ";", "if", "(", "T", ".", "isArch64Bit", "(", ")", "&&", "(", "Features", "&", "Mips", "::", "FeatureN64", ")", ")", "{", "const", "MCSectionELF", "*", "Sec", "=", "Context", ".", "getELFSection", "(", "\".MIPS.options\"", ",", "ELF", "::", "SHT_MIPS_OPTIONS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MIPS_NOSTRIP", ",", "SectionKind", "::", "getMetadata", "(", ")", ",", "1", ",", "\"\"", ")", ";", "MCA", ".", "getOrCreateSectionData", "(", "*", "Sec", ")", ".", "setAlignment", "(", "8", ")", ";", "OS", ".", "SwitchSection", "(", "Sec", ")", ";", "OS", ".", "EmitIntValue", "(", "1", ",", "1", ")", ";", "OS", ".", "EmitIntValue", "(", "40", ",", "1", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "2", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "8", ")", ";", "}", "else", "{", "const", "MCSectionELF", "*", "Sec", "=", "Context", ".", "getELFSection", "(", "\".reginfo\"", ",", "ELF", "::", "SHT_MIPS_REGINFO", ",", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getMetadata", "(", ")", ",", "24", ",", "\"\"", ")", ";", "MCA", ".", "getOrCreateSectionData", "(", "*", "Sec", ")", ".", "setAlignment", "(", "Features", "&", "Mips", "::", "FeatureN32", "?", "8", ":", "4", ")", ";", "OS", ".", "SwitchSection", "(", "Sec", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "OS", ".", "EmitIntValue", "(", "0", ",", "4", ")", ";", "}", "emitMipsAbiFlags", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "Mips", "Mips", "16u", "16u", "16u", "Mips::FeatureN64", "\".MIPS.options\"", "1", "\"\"", "8", "1", "1", "40", "1", "0", "2", "0", "4", "0", "4", "0", "4", "0", "4", "0", "4", "0", "4", "0", "4", "0", "8", "\".reginfo\"", "24", "\"\"", "Mips::FeatureN32", "8", "4", "0", "4", "0", "4", "0", "4", "0", "4", "0", "4", "0", "4", "Mips" ]

[]

[ "<s>", "SDValue", "AlphaTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Alpha", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "RetValue", ")", ";", "InVals", ".", "push_back", "(", "RetValue", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Alpha", "Alpha", "ISD::InputArg", "16", "Alpha", "0", "1", "0", "2", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "ix86_emit_swsqrtsf", "(", "rtx", "res", ",", "rtx", "a", ",", "machine_mode", "mode", ",", "bool", "recip", ")", "{", "rtx", "x0", ",", "e0", ",", "e1", ",", "e2", ",", "e3", ",", "mthree", ",", "mhalf", ";", "REAL_VALUE_TYPE", "r", ";", "int", "unspec", ";", "x0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e0", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "e3", "=", "gen_reg_rtx", "(", "mode", ")", ";", "real_from_integer", "(", "&", "r", ",", "VOIDmode", ",", "-", "3", ",", "SIGNED", ")", ";", "mthree", "=", "const_double_from_real_value", "(", "r", ",", "SFmode", ")", ";", "real_arithmetic", "(", "&", "r", ",", "NEGATE_EXPR", ",", "&", "dconsthalf", ",", "NULL", ")", ";", "mhalf", "=", "const_double_from_real_value", "(", "r", ",", "SFmode", ")", ";", "unspec", "=", "UNSPEC_RSQRT", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "mthree", "=", "ix86_build_const_vector", "(", "mode", ",", "true", ",", "mthree", ")", ";", "mhalf", "=", "ix86_build_const_vector", "(", "mode", ",", "true", ",", "mhalf", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "unspec", "=", "UNSPEC_RSQRT14", ";", "}", "a", "=", "force_reg", "(", "mode", ",", "a", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x0", ",", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "a", ")", ",", "unspec", ")", ")", ")", ";", "if", "(", "!", "recip", ")", "{", "rtx", "zero", "=", "force_reg", "(", "mode", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "rtx", "mask", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "64", ")", "{", "mask", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_avx512f_cmpv16sf3", "(", "mask", ",", "zero", ",", "a", ",", "GEN_INT", "(", "0x4", ")", ")", ")", ";", "emit_insn", "(", "gen_avx512f_blendmv16sf", "(", "x0", ",", "zero", ",", "x0", ",", "mask", ")", ")", ";", "}", "else", "{", "mask", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "mask", ",", "gen_rtx_NE", "(", "mode", ",", "zero", ",", "a", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x0", ",", "gen_rtx_AND", "(", "mode", ",", "x0", ",", "mask", ")", ")", ")", ";", "}", "}", "emit_insn", "(", "gen_rtx_SET", "(", "e0", ",", "gen_rtx_MULT", "(", "mode", ",", "x0", ",", "a", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "e1", ",", "gen_rtx_MULT", "(", "mode", ",", "e0", ",", "x0", ")", ")", ")", ";", "mthree", "=", "force_reg", "(", "mode", ",", "mthree", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "e2", ",", "gen_rtx_PLUS", "(", "mode", ",", "e1", ",", "mthree", ")", ")", ")", ";", "mhalf", "=", "force_reg", "(", "mode", ",", "mhalf", ")", ";", "if", "(", "recip", ")", "emit_insn", "(", "gen_rtx_SET", "(", "e3", ",", "gen_rtx_MULT", "(", "mode", ",", "x0", ",", "mhalf", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_SET", "(", "e3", ",", "gen_rtx_MULT", "(", "mode", ",", "e0", ",", "mhalf", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "res", ",", "gen_rtx_MULT", "(", "mode", ",", "e2", ",", "e3", ")", ")", ")", ";", "}", "</s>" ]

[ "Output", "code", "to", "perform", "a", "Newton-Rhapson", "approximation", "of", "a", "single", "precision", "floating", "point", "[", "reciprocal", "]", "square", "root", "." ]

[ "i386", "3", "64", "1", "64", "0x4" ]

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "Cpu0", "MVT::i32" ]

[]

[ "<s>", "bool", "HCE", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AssignmentMap", "IMap", ";", "collect", "(", "MF", ")", ";", "std", "::", "sort", "(", "Extenders", ".", "begin", "(", ")", ",", "Extenders", ".", "end", "(", ")", ",", "[", "]", "(", "const", "ExtDesc", "&", "A", ",", "const", "ExtDesc", "&", "B", ")", "{", "return", "ExtValue", "(", "A", ")", "<", "ExtValue", "(", "B", ")", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Collected \"", "<<", "Extenders", ".", "size", "(", ")", "<<", "\" extenders\\n\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Extenders", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "unsigned", "B", "=", "I", ";", "const", "ExtRoot", "&", "T", "=", "Extenders", "[", "B", "]", ".", "getOp", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "ExtRoot", "(", "Extenders", "[", "I", "]", ".", "getOp", "(", ")", ")", "==", "T", ")", "++", "I", ";", "IMap", ".", "clear", "(", ")", ";", "assignInits", "(", "T", ",", "B", ",", "I", ",", "IMap", ")", ";", "Changed", "|=", "replaceExtenders", "(", "IMap", ")", ";", "}", "DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Before \"", "Hexagon", "Hexagon", "\"Collected \"", "\" extenders\\n\"", "0", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", "&&", "!", "isSupportedReturnType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "ArgInfo", "ArgRetInfo", "(", "VRegs", ",", "Val", "->", "getType", "(", ")", ")", ";", "setArgFlags", "(", "ArgRetInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "DL", ",", "ArgRetInfo", ",", "0", ",", "RetInfos", ",", "OrigArgIndices", ")", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "RetInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "MipsOutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "RetInfos", ")", ")", "{", "return", "false", ";", "}", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "8", "8", "0", "ISD::OutputArg", "8", "16", "Mips", "Mips" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Hexagon" ]

[]

[ "<s>", "int", "X86RegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNo", ",", "bool", "isEH", ")", "const", "{", "const", "X86Subtarget", "*", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "unsigned", "Flavour", "=", "DWARFFlavour", "::", "X86_64", ";", "if", "(", "!", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "isEH", ")", "Flavour", "=", "DWARFFlavour", "::", "X86_32_DarwinEH", ";", "else", "Flavour", "=", "DWARFFlavour", "::", "X86_32_Generic", ";", "}", "else", "if", "(", "Subtarget", "->", "isTargetCygMing", "(", ")", ")", "{", "Flavour", "=", "DWARFFlavour", "::", "X86_32_Generic", ";", "}", "else", "{", "Flavour", "=", "DWARFFlavour", "::", "X86_32_Generic", ";", "}", "}", "return", "X86GenRegisterInfo", "::", "getDwarfRegNumFull", "(", "RegNo", ",", "Flavour", ")", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

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

[]

[ "<s>", "int", "arm_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "RTX_CODE", "outer", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "1", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "(", "mode", "==", "DFmode", "&&", "(", "TARGET_SOFT_FLOAT", "||", "TARGET_VFP", ")", ")", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ";", "if", "(", "use_ldrd", "&&", "GET_CODE", "(", "x", ")", "==", "POST_MODIFY", "&&", "GET_CODE", "(", "addend", ")", "==", "REG", ")", "return", "0", ";", "return", "(", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "addend", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ")", ")", "return", "1", ";", "else", "if", "(", "mode", "==", "TImode", ")", "return", "0", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop0", ",", "outer", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "arm_legitimate_index_p", "(", "mode", ",", "xop1", ",", "outer", ",", "strict_p", ")", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "ARM", "state", "address", "operand", "." ]

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

[]

[ "<s>", "static", "inline", "tree", "def_builtin_pure", "(", "HOST_WIDE_INT", "mask", ",", "const", "char", "*", "name", ",", "enum", "ix86_builtin_func_type", "tcode", ",", "enum", "ix86_builtins", "code", ")", "{", "tree", "decl", "=", "def_builtin", "(", "mask", ",", "name", ",", "tcode", ",", "code", ")", ";", "if", "(", "decl", ")", "DECL_PURE_P", "(", "decl", ")", "=", "1", ";", "else", "ix86_builtins_isa", "[", "(", "int", ")", "code", "]", ".", "pure_p", "=", "true", ";", "return", "decl", ";", "}", "</s>" ]

[ "Like", "def_builtin", ",", "but", "also", "marks", "the", "function", "decl", "``", "pure", "''", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "s390_expand_vec_compare", "(", "rtx", "target", ",", "enum", "rtx_code", "cond", ",", "rtx", "cmp_op1", ",", "rtx", "cmp_op2", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "bool", "neg_p", "=", "false", ",", "swap_p", "=", "false", ";", "rtx", "tmp", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp_op1", ")", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "cmp_op2", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op1", ")", ",", "cmp_op2", ")", ";", "switch", "(", "cond", ")", "{", "case", "NE", ":", "cond", "=", "EQ", ";", "neg_p", "=", "true", ";", "break", ";", "case", "UNGT", ":", "emit_insn", "(", "gen_vec_cmpungt", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "UNGE", ":", "emit_insn", "(", "gen_vec_cmpunge", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "LE", ":", "cond", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNLE", ":", "emit_insn", "(", "gen_vec_cmpunge", "(", "target", ",", "cmp_op2", ",", "cmp_op1", ")", ")", ";", "return", ";", "case", "LT", ":", "cond", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "UNLT", ":", "emit_insn", "(", "gen_vec_cmpungt", "(", "target", ",", "cmp_op2", ",", "cmp_op1", ")", ")", ";", "return", ";", "case", "UNEQ", ":", "emit_insn", "(", "gen_vec_cmpuneq", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "LTGT", ":", "emit_insn", "(", "gen_vec_cmpltgt", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "ORDERED", ":", "emit_insn", "(", "gen_vec_cmpordered", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "case", "UNORDERED", ":", "emit_insn", "(", "gen_vec_cmpunordered", "(", "target", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ";", "return", ";", "default", ":", "break", ";", "}", "}", "else", "{", "if", "(", "cond", "==", "LT", "&&", "cmp_op2", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "int", "shift", "=", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", "-", "1", ";", "rtx", "res", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFTRT", ",", "cmp_op1", ",", "GEN_INT", "(", "shift", ")", ",", "target", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "res", "!=", "target", ")", "emit_move_insn", "(", "target", ",", "res", ")", ";", "return", ";", "}", "cmp_op2", "=", "force_reg", "(", "GET_MODE", "(", "cmp_op1", ")", ",", "cmp_op2", ")", ";", "switch", "(", "cond", ")", "{", "case", "NE", ":", "cond", "=", "EQ", ";", "neg_p", "=", "true", ";", "break", ";", "case", "GE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "GEU", ":", "cond", "=", "GTU", ";", "neg_p", "=", "true", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cond", "=", "GT", ";", "neg_p", "=", "true", ";", "break", ";", "case", "LEU", ":", "cond", "=", "GTU", ";", "neg_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cond", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LTU", ":", "cond", "=", "GTU", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "swap_p", ")", "{", "tmp", "=", "cmp_op1", ";", "cmp_op1", "=", "cmp_op2", ";", "cmp_op2", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_fmt_ee", "(", "cond", ",", "mode", ",", "cmp_op1", ",", "cmp_op2", ")", ")", ")", ";", "if", "(", "neg_p", ")", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_NOT", "(", "mode", ",", "target", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "vector", "comparison", "COND", "of", "CMP_OP1", "and", "CMP_OP2", "and", "store", "the", "result", "in", "TARGET", "." ]

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

[]

[ "<s>", "int", "same_cmp_following_p", "(", "rtx_insn", "*", "i1", ")", "{", "rtx_insn", "*", "i2", ",", "*", "i3", ";", "i2", "=", "next_nonnote_insn", "(", "i1", ")", ";", "if", "(", "i2", "==", "NULL", ")", "return", "0", ";", "i3", "=", "next_nonnote_insn", "(", "i2", ")", ";", "if", "(", "i3", "==", "NULL", ")", "return", "0", ";", "return", "(", "INSN_P", "(", "i3", ")", "&&", "rtx_equal_p", "(", "PATTERN", "(", "i1", ")", ",", "PATTERN", "(", "i3", ")", ")", "&&", "any_condjump_p", "(", "i2", ")", "&&", "onlyjump_p", "(", "i2", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "we", "have", "the", "same", "comparison", "insn", "as", "I1", "two", "insns", "after", "I1", ".", "I1", "is", "assumed", "to", "be", "a", "comparison", "insn", "." ]

[ "h8300", "0", "0" ]

[]

[ "<s>", "void", "SICPassConfig", "::", "addPreEmitPass", "(", ")", "{", "SICTargetMachine", "&", "TM", "=", "getSICTargetMachine", "(", ")", ";", "addPass", "(", "createSICDelJmpPass", "(", "TM", ")", ")", ";", "return", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC", "SIC", "SIC" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getABIAlignmentForCallingConv", "(", "Type", "*", "ArgTy", ",", "DataLayout", "DL", ")", "const", "{", "if", "(", "!", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ";", "return", "std", "::", "min", "(", "DL", ".", "getABITypeAlignment", "(", "ArgTy", ")", ",", "DL", ".", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "correct", "alignment", "for", "the", "current", "calling", "convention", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "rx_elf_asm_cdtor", "(", "rtx", "symbol", ",", "int", "priority", ",", "bool", "is_ctor", ")", "{", "section", "*", "s", ";", "if", "(", "priority", "!=", "DEFAULT_INIT_PRIORITY", ")", "{", "char", "buf", "[", "18", "]", ";", "sprintf", "(", "buf", ",", "\"%s.%.5u\"", ",", "is_ctor", "?", "\".init_array\"", ":", "\".fini_array\"", ",", "priority", ")", ";", "s", "=", "get_section", "(", "buf", ",", "SECTION_WRITE", ",", "NULL_TREE", ")", ";", "}", "else", "if", "(", "is_ctor", ")", "s", "=", "ctors_section", ";", "else", "s", "=", "dtors_section", ";", "switch_to_section", "(", "s", ")", ";", "assemble_align", "(", "POINTER_SIZE", ")", ";", "assemble_integer", "(", "symbol", ",", "POINTER_SIZE", "/", "BITS_PER_UNIT", ",", "POINTER_SIZE", ",", "1", ")", ";", "}", "</s>" ]

[ "Place", "an", "element", "into", "a", "constructor", "or", "destructor", "section", ".", "Like", "default_ctor_section_asm_out_constructor", "in", "varasm.cc", "except", "that", "it", "uses", ".init_array", "(", "or", ".fini_array", ")", "and", "it", "handles", "constructor", "priorities", "." ]

[ "rx", "18", "\"%s.%.5u\"", "\".init_array\"", "\".fini_array\"", "1" ]

[]

[ "<s>", "bool", "AAPAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "AAP", "AAP" ]

[]

[ "<s>", "static", "void", "ix86_emit_leave", "(", "rtx_insn", "*", "insn", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "if", "(", "!", "insn", ")", "insn", "=", "emit_insn", "(", "gen_leave", "(", "word_mode", ")", ")", ";", "ix86_add_queued_cfa_restore_notes", "(", "insn", ")", ";", "gcc_assert", "(", "m", "->", "fs", ".", "fp_valid", ")", ";", "m", "->", "fs", ".", "sp_valid", "=", "true", ";", "m", "->", "fs", ".", "sp_realigned", "=", "false", ";", "m", "->", "fs", ".", "sp_offset", "=", "m", "->", "fs", ".", "fp_offset", "-", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "fp_valid", "=", "false", ";", "if", "(", "m", "->", "fs", ".", "cfa_reg", "==", "hard_frame_pointer_rtx", ")", "{", "m", "->", "fs", ".", "cfa_reg", "=", "stack_pointer_rtx", ";", "m", "->", "fs", ".", "cfa_offset", "=", "m", "->", "fs", ".", "sp_offset", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "m", "->", "fs", ".", "sp_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "ix86_add_cfa_restore_note", "(", "insn", ",", "hard_frame_pointer_rtx", ",", "m", "->", "fs", ".", "fp_offset", ")", ";", "}", "</s>" ]

[ "Emit", "code", "and", "notes", "for", "the", "LEAVE", "instruction", "." ]

[ "i386", "1" ]

[]

[ "<s>", "int", "pdp11_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "spoff", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "4", ";", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "else", "{", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "spoff", "=", "pdp11_sp_frame_offset", "(", ")", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "return", "spoff", ";", "gcc_assert", "(", "from", "==", "ARG_POINTER_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "spoff", "+=", "2", ";", "return", "spoff", "+", "2", ";", "}", "}", "</s>" ]

[ "Return", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "pdp11", "4", "0", "2", "2" ]

[]

[ "<s>", "static", "bool", "ia64_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'+'", "||", "code", "==", "','", ")", ";", "}", "</s>" ]

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

[ "ia64" ]

[]

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

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

[ "CAHP" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAtomicTidy", ")", "addPass", "(", "createCFGSimplificationPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Cpu0 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Cpu0", "\"Cpu0 Assembly Printer\"" ]

[]

[ "<s>", "static", "rtx", "compute_frame_addr", "(", "int", "offset_from_fp", ",", "int", "*", "next_scratch_regno", ")", "{", "rtx", "base_reg_rtx", ",", "tmp_reg_rtx", ",", "offset_rtx", ";", "int", "offset_from_base", ";", "if", "(", "frame_pointer_needed", ")", "{", "base_reg_rtx", "=", "hard_frame_pointer_rtx", ";", "offset_from_base", "=", "offset_from_fp", ";", "}", "else", "{", "int", "offset_from_sp", "=", "compute_total_frame_size", "(", ")", "+", "offset_from_fp", ";", "base_reg_rtx", "=", "stack_pointer_rtx", ";", "offset_from_base", "=", "offset_from_sp", ";", "}", "if", "(", "offset_from_base", "==", "0", ")", "return", "base_reg_rtx", ";", "tmp_reg_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "(", "*", "next_scratch_regno", ")", "--", ")", ";", "offset_rtx", "=", "gen_int_si", "(", "offset_from_base", ")", ";", "if", "(", "!", "tilepro_expand_addsi", "(", "tmp_reg_rtx", ",", "base_reg_rtx", ",", "offset_rtx", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp_reg_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base_reg_rtx", ",", "offset_rtx", ")", ")", ")", ";", "}", "return", "tmp_reg_rtx", ";", "}", "</s>" ]

[ "Returns", "an", "rtx", "for", "a", "stack", "slot", "at", "'FP", "+", "offset_from_fp", "'", ".", "If", "there", "is", "a", "frame", "pointer", ",", "it", "computes", "the", "value", "relative", "to", "that", ".", "Otherwise", "it", "uses", "the", "stack", "pointer", "." ]

[ "tilepro", "0" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createRISCVISelDag", "(", "getRISCVTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", "=", "HexagonMCInstrInfo", "::", "createBundle", "(", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "HexagonMCChecker", "Checker", "(", "*", "MCII", ",", "STI", ",", "MI", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

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

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

[]

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

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

[ "FISC", "FISC" ]

[]

[ "<s>", "static", "bool", "riscv_valid_offset_p", "(", "rtx", "x", ",", "enum", "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", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "Clear", "(", ")", "{", "Stack", ".", "clear", "(", ")", ";", "LocalTypes", ".", "clear", "(", ")", ";", "ReturnTypes", ".", "clear", "(", ")", ";", "TypeErrorThisFunction", "=", "false", ";", "Unreachable", "=", "false", ";", "}", "</s>" ]

[ "Clear", "value", "data", "entries", "and", "edge", "counters", "." ]

[ "WebAssembly" ]

[]

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

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

[ "VE", "VE" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "isInt", "<", "15", ">", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ")", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MSP430Subtarget", "::", "MSP430Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "MSP430GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "TSInfo", "(", "*", "TM", ".", "getDataLayout", "(", ")", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "aarch64_could_trap_p", "(", "aarch64_simd_builtin_datum", "*", "d", ")", "{", "unsigned", "int", "flags", "=", "aarch64_call_properties", "(", "d", ")", ";", "if", "(", "flags", "&", "FLAG_RAISE_FP_EXCEPTIONS", ")", "return", "true", ";", "if", "(", "flags", "&", "(", "FLAG_READ_MEMORY", "|", "FLAG_WRITE_MEMORY", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "raise", "a", "signal", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "mips_output_load_label", "(", "rtx", "target", ")", "{", "mips_push_asm_switch", "(", "&", "mips_noat", ")", ";", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "{", "mips_process_load_label", "(", "target", ")", ";", "mips_multi_write", "(", ")", ";", "}", "else", "{", "if", "(", "Pmode", "==", "DImode", ")", "output_asm_insn", "(", "\"dla\\t%@,%0\"", ",", "&", "target", ")", ";", "else", "output_asm_insn", "(", "\"la\\t%@,%0\"", ",", "&", "target", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "asm", "sequence", "to", "start", "a", "noat", "block", "and", "load", "the", "address", "of", "a", "label", "into", "$", "1", "." ]

[ "mips", "\"dla\\t%@,%0\"", "\"la\\t%@,%0\"" ]

[]

[ "<s>", "class", "LLVM_LIBRARY_VISIBILITY", "KudeyarMCInstLower", "{", "typedef", "MachineOperand", "::", "MachineOperandType", "MachineOperandType", ";", "KudeyarAsmPrinter", "&", "Printer", ";", "public", ":", "KudeyarMCInstLower", "(", "KudeyarAsmPrinter", "&", "asmprinter", ")", ";", "void", "Lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", ";", "private", ":", "MCSymbol", "*", "GetGlobalAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetJumpTableSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetConstantPoolIndexSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCSymbol", "*", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", ";", "MCOperand", "LowerSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCSymbol", "*", "Sym", ")", "const", ";", "MCOperand", "LowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "unsigned", "offset", "=", "0", ")", "const", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "Kudeyar", "0" ]

[]

[ "<s>", "int64_t", "ARMBaseRegisterInfo", "::", "getFrameIndexInstrOffset", "(", "const", "MachineInstr", "*", "MI", ",", "int", "Idx", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "int64_t", "InstrOffs", "=", "0", ";", ";", "int", "Scale", "=", "1", ";", "unsigned", "ImmIdx", "=", "0", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "case", "ARMII", "::", "AddrMode_i12", ":", "InstrOffs", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "1", ";", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "{", "const", "MachineOperand", "&", "OffOp", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM5Offset", "(", "OffOp", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM5Op", "(", "OffOp", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "Scale", "=", "4", ";", "break", ";", "}", "case", "ARMII", "::", "AddrMode2", ":", "{", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM2Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM2Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "}", "case", "ARMII", "::", "AddrMode3", ":", "{", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM3Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM3Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "}", "case", "ARMII", "::", "AddrModeT1_s", ":", "{", "ImmIdx", "=", "Idx", "+", "1", ";", "InstrOffs", "=", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "4", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "}", "return", "InstrOffs", "*", "Scale", ";", "}", "</s>" ]

[ "Get", "the", "offset", "from", "the", "referenced", "frame", "index", "in", "the", "instruction", ",", "if", "there", "is", "one", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "1", "0", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i12", "ARMII::AddrMode_i12", "1", "1", "ARMII::AddrMode5", "1", "ARM_AM::getAM5Offset", "ARM_AM::getAM5Op", "ARM_AM::sub", "4", "ARMII::AddrMode2", "2", "ARM_AM::getAM2Offset", "ARM_AM::getAM2Op", "ARM_AM::sub", "ARMII::AddrMode3", "2", "ARM_AM::getAM3Offset", "ARM_AM::getAM3Op", "ARM_AM::sub", "ARMII::AddrModeT1_s", "1", "4", "\"Unsupported addressing mode!\"" ]

[]

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

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

[ "LEG" ]

[]

[ "<s>", "static", "int", "translate_unix", "(", "char", "*", "name", ",", "int", "type", "ATTRIBUTE_UNUSED", ")", "{", "strcpy", "(", "filename_buff", ",", "name", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Action", "routine", "called", "by", "decc", "$", "to_vms", ".", "NAME", "is", "a", "file", "name", "or", "directory", "name", ".", "TYPE", "is", "unused", "." ]

[ "vms", "0" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SystemZ", "::", "GR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_h64", ")", ",", "KillSrc", ")", ";", "MachineInstrBuilder", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "std", "::", "prev", "(", "MBBI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "RegState", "::", "Implicit", ")", ";", "copyPhysReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SystemZ", "::", "subreg_l64", ")", ",", "KillSrc", ")", ";", "MachineInstrBuilder", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "std", "::", "prev", "(", "MBBI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "(", "getKillRegState", "(", "KillSrc", ")", "|", "RegState", "::", "Implicit", ")", ")", ";", "return", ";", "}", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "emitGRX32Move", "(", "MBB", ",", "MBBI", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "SystemZ", "::", "LR", ",", "32", ",", "KillSrc", ",", "false", ")", ";", "return", ";", "}", "unsigned", "Opcode", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LGR", ";", "else", "if", "(", "SystemZ", "::", "FP32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "STI", ".", "hasVector", "(", ")", "?", "SystemZ", "::", "LDR32", ":", "SystemZ", "::", "LER", ";", "else", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LDR", ";", "else", "if", "(", "SystemZ", "::", "FP128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "LXR", ";", "else", "if", "(", "SystemZ", "::", "VR32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR32", ";", "else", "if", "(", "SystemZ", "::", "VR64BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR64", ";", "else", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "VLR", ";", "else", "if", "(", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "CPYA", ";", "else", "if", "(", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "DestReg", ")", "&&", "SystemZ", "::", "GR32BitRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "SAR", ";", "else", "if", "(", "SystemZ", "::", "GR32BitRegClass", ".", "contains", "(", "DestReg", ")", "&&", "SystemZ", "::", "AR32BitRegClass", ".", "contains", "(", "SrcReg", ")", ")", "Opcode", "=", "SystemZ", "::", "EAR", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ::GR128BitRegClass", "SystemZ::subreg_h64", "SystemZ::subreg_h64", "SystemZ::subreg_l64", "SystemZ::subreg_l64", "SystemZ::GRX32BitRegClass", "SystemZ::LR", "32", "SystemZ::GR64BitRegClass", "SystemZ::LGR", "SystemZ::FP32BitRegClass", "SystemZ::LDR32", "SystemZ::LER", "SystemZ::FP64BitRegClass", "SystemZ::LDR", "SystemZ::FP128BitRegClass", "SystemZ::LXR", "SystemZ::VR32BitRegClass", "SystemZ::VLR32", "SystemZ::VR64BitRegClass", "SystemZ::VLR64", "SystemZ::VR128BitRegClass", "SystemZ::VLR", "SystemZ::AR32BitRegClass", "SystemZ::CPYA", "SystemZ::AR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::SAR", "SystemZ::GR32BitRegClass", "SystemZ::AR32BitRegClass", "SystemZ::EAR", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "it", "=", "CSI", ".", "begin", "(", ")", ";", "it", "!=", "CSI", ".", "end", "(", ")", ";", "++", "it", ")", "{", "MBB", ".", "addLiveIn", "(", "it", "->", "getReg", "(", ")", ")", ";", "unsigned", "Reg", "=", "it", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "it", "->", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveLabel", "=", "MF", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "XCore", "::", "PROLOG_LABEL", ")", ")", ".", "addSym", "(", "SaveLabel", ")", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "SaveLabel", ",", "*", "it", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::PROLOG_LABEL" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToUnpredicate", "(", "MachineBasicBlock", "&", "TMBB", ",", "MachineBasicBlock", "&", "FMBB", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "to", "unpredicate", "one", "side", "of", "a", "'diamond", "'", ",", "i.e", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "canMakeTailCallConditional", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "BranchCond", ",", "const", "MachineInstr", "&", "TailCall", ")", "const", "{", "if", "(", "TailCall", ".", "getOpcode", "(", ")", "!=", "X86", "::", "TCRETURNdi", "&&", "TailCall", ".", "getOpcode", "(", ")", "!=", "X86", "::", "TCRETURNdi64", ")", "{", "return", "false", ";", "}", "const", "MachineFunction", "*", "MF", "=", "TailCall", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", "&&", "MF", "->", "hasWinCFI", "(", ")", ")", "{", "return", "false", ";", "}", "assert", "(", "BranchCond", ".", "size", "(", ")", "==", "1", ")", ";", "if", "(", "BranchCond", "[", "0", "]", ".", "getImm", "(", ")", ">", "X86", "::", "LAST_VALID_COND", ")", "{", "return", "false", ";", "}", "const", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "if", "(", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", "!=", "0", "||", "TailCall", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "!=", "0", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "tail", "call", "can", "be", "made", "conditional", "on", "BranchCond", "." ]

[ "X86", "X86", "X86::TCRETURNdi", "X86::TCRETURNdi64", "1", "0", "X86::LAST_VALID_COND", "X86", "X86", "X86", "X86", "0", "1", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "ARMBaseInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb2", "(", ")", "||", "Subtarget", ".", "hasVFP2", "(", ")", ")", "return", "(", "ScheduleHazardRecognizer", "*", ")", "new", "ARMHazardRecognizer", "(", "II", ",", "*", "this", ",", "getRegisterInfo", "(", ")", ",", "Subtarget", ",", "DAG", ")", ";", "return", "TargetInstrInfoImpl", "::", "CreateTargetPostRAHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "RISCV", "::", "SELECT_CC", ":", "case", "RISCV", "::", "SELECT_CC64", ":", "case", "RISCV", "::", "FSELECT_CC_F", ":", "case", "RISCV", "::", "FSELECT_CC_D", ":", "return", "emitSelectCC", "(", "MI", ",", "MBB", ")", ";", "case", "RISCV", "::", "CALL", ":", "case", "RISCV", "::", "CALLREG", ":", "case", "RISCV", "::", "CALL64", ":", "case", "RISCV", "::", "CALLREG64", ":", "return", "emitCALL", "(", "MI", ",", "MBB", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "RISCV", "RISCV", "RISCV::SELECT_CC", "RISCV::SELECT_CC64", "RISCV::FSELECT_CC_F", "RISCV::FSELECT_CC_D", "RISCV::CALL", "RISCV::CALLREG", "RISCV::CALL64", "RISCV::CALLREG64", "\"Unexpected instr type to insert\"" ]

[]

[ "<s>", "static", "int", "epilogue_renumber", "(", "rtx", "*", "where", ",", "int", "test", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "enum", "rtx_code", "code", ";", "if", "(", "*", "where", "==", "0", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "*", "where", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "*", "where", ")", ">=", "8", "&&", "REGNO", "(", "*", "where", ")", "<", "24", ")", "return", "1", ";", "if", "(", "!", "test", "&&", "REGNO", "(", "*", "where", ")", ">=", "24", "&&", "REGNO", "(", "*", "where", ")", "<", "32", ")", "{", "if", "(", "ORIGINAL_REGNO", "(", "*", "where", ")", ")", "{", "rtx", "n", "=", "gen_raw_REG", "(", "GET_MODE", "(", "*", "where", ")", ",", "OUTGOING_REGNO", "(", "REGNO", "(", "*", "where", ")", ")", ")", ";", "ORIGINAL_REGNO", "(", "n", ")", "=", "ORIGINAL_REGNO", "(", "*", "where", ")", ";", "*", "where", "=", "n", ";", "}", "else", "*", "where", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "*", "where", ")", ",", "OUTGOING_REGNO", "(", "REGNO", "(", "*", "where", ")", ")", ")", ";", "}", "return", "0", ";", "case", "SCRATCH", ":", "case", "PC", ":", "case", "CONST_INT", ":", "case", "CONST_WIDE_INT", ":", "case", "CONST_DOUBLE", ":", "return", "0", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "<", "SPARC_STACK_BIAS", ")", ")", "return", "1", ";", "break", ";", "case", "MEM", ":", "if", "(", "SPARC_STACK_BIAS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "*", "where", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "epilogue_renumber", "(", "&", "(", "XVECEXP", "(", "*", "where", ",", "i", ",", "j", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "epilogue_renumber", "(", "&", "(", "XEXP", "(", "*", "where", ",", "i", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", ",", "if", "any", "of", "the", "registers", "of", "the", "instruction", "are", "%", "l", "[", "0-7", "]", "or", "%", "o", "[", "0-7", "]", ".", "Such", "instructions", "can", "not", "be", "used", "in", "the", "delay", "slot", "of", "return", "insn", "on", "v9", ".", "If", "TEST", "is", "0", ",", "also", "rename", "all", "%", "i", "[", "0-7", "]", "registers", "to", "their", "%", "o", "[", "0-7", "]", "counterparts", "." ]

[ "sparc", "0", "0", "8", "24", "1", "24", "32", "0", "0", "0", "0", "1", "1", "1", "0", "0", "1", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "SDNode", "*", "WDC65816DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "NULL", ";", "}", "WDC_LOG", "(", "\"WDC_TODO - Unimplemented method called, opcode=\"", "<<", "N", "->", "getOpcode", "(", ")", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "WRYrr", ",", "dl", ",", "MVT", "::", "Glue", ",", "TopPart", ",", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "}", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "{", "SDValue", "MulLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "MulRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "MULHU", "?", "SP", "::", "UMULrr", ":", "SP", "::", "SMULrr", ";", "SDNode", "*", "Mul", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Glue", ",", "MulLHS", ",", "MulRHS", ")", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "SP", "::", "RDY", ",", "MVT", "::", "i32", ",", "SDValue", "(", "Mul", ",", "1", ")", ")", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC", "1", "WDC", "\"WDC_TODO - Unimplemented method called, opcode=\"", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::WRYrr", "MVT::Glue", "SP::G0", "MVT::i32", "0", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32", "ISD::MULHU", "ISD::MULHS", "0", "1", "ISD::MULHU", "SP::UMULrr", "SP::SMULrr", "MVT::i32", "MVT::Glue", "SP::RDY", "MVT::i32", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "rs6000_pre_atomic_barrier", "(", "rtx", "mem", ",", "enum", "memmodel", "model", ")", "{", "rtx", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", ")", "{", "addr", "=", "force_reg", "(", "Pmode", ",", "addr", ")", ";", "mem", "=", "replace_equiv_address_nv", "(", "mem", ",", "addr", ")", ";", "}", "switch", "(", "model", ")", "{", "case", "MEMMODEL_RELAXED", ":", "case", "MEMMODEL_CONSUME", ":", "case", "MEMMODEL_ACQUIRE", ":", "break", ";", "case", "MEMMODEL_RELEASE", ":", "case", "MEMMODEL_ACQ_REL", ":", "emit_insn", "(", "gen_lwsync", "(", ")", ")", ";", "break", ";", "case", "MEMMODEL_SEQ_CST", ":", "emit_insn", "(", "gen_hwsync", "(", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "mem", ";", "}", "</s>" ]

[ "Expand", "barriers", "before", "and", "after", "a", "load_locked/store_cond", "sequence", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "void", "MetadataStreamerV3", "::", "dump", "(", "StringRef", "HSAMetadataString", ")", "const", "{", "errs", "(", ")", "<<", "\"AMDGPU HSA Metadata:\\n\"", "<<", "HSAMetadataString", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU HSA Metadata:\\n\"" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_unpred_insn", "(", "insn_code", "icode", ")", "{", "gcc_assert", "(", "pred", "==", "PRED_x", "||", "pred", "==", "PRED_none", ")", ";", "unsigned", "int", "nops", "=", "insn_data", "[", "icode", "]", ".", "n_operands", "-", "1", ";", "unsigned", "int", "bias", "=", "(", "pred", "==", "PRED_x", "?", "1", ":", "0", ")", ";", "unsigned", "int", "i", "=", "0", ";", "add_output_operand", "(", "icode", ")", ";", "for", "(", ";", "i", "<", "nops", ";", "++", "i", ")", "add_input_operand", "(", "icode", ",", "args", "[", "i", "+", "bias", "]", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "which", "does", "not", "use", "a", "governing", "predicate", ".", "We", "must", "therefore", "drop", "the", "GP", "from", "an", "_x", "call", "." ]

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

[]

[ "<s>", "MachineRegisterInfo", "*", "getMRI", "(", ")", "{", "return", "&", "MRI", ";", "}", "</s>" ]

[ "Getter", "for", "MRI", "." ]

[ "AMDGPU" ]

[]

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

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

[ "SHUXI", "SHUXI", "SHUXI::JMP", "0", "0", "0", "SHUXI::JCC", "\"Invalid conditional branch\"", "SHUXICC::CondCodes", "SHUXICC::CondCodes", "1", "SHUXICC::COND_INVALID", "0", "1", "0", "SHUXICC::CondCodes", "SHUXICC::CondCodes", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "arm_invalid_return_type", "(", "const_tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_PRECISION", "(", "t", ")", "==", "16", ")", "return", "N_", "(", "\"functions cannot return __fp16 type\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_INVALID_PARAMETER_TYPE", "." ]

[ "arm", "16", "\"functions cannot return __fp16 type\"" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "c6x_output_fn_unwind", "(", "FILE", "*", "f", ")", "{", "if", "(", "!", "(", "flag_unwind_tables", "||", "flag_exceptions", ")", ")", "return", ";", "if", "(", "!", "(", "flag_unwind_tables", "||", "crtl", "->", "uses_eh_lsda", ")", "&&", "(", "TREE_NOTHROW", "(", "current_function_decl", ")", "||", "crtl", "->", "all_throwers_are_sibcalls", ")", ")", "fputs", "(", "\"\\t.cantunwind\\n\"", ",", "f", ")", ";", "fputs", "(", "\"\\t.endp\\n\"", ",", "f", ")", ";", "}", "</s>" ]

[ "Output", "unwind", "directives", "at", "the", "end", "of", "a", "function", "." ]

[ "c6x", "\"\\t.cantunwind\\n\"", "\"\\t.endp\\n\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "getMemOperandsWithOffsetWidth", "(", "const", "MachineInstr", "&", "MemOp", ",", "SmallVectorImpl", "<", "const", "MachineOperand", "*", ">", "&", "BaseOps", ",", "int64_t", "&", "Offset", ",", "bool", "&", "OffsetIsScalable", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MemOp", ".", "getDesc", "(", ")", ";", "int", "MemRefBegin", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemRefBegin", "<", "0", ")", "return", "false", ";", "MemRefBegin", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "const", "MachineOperand", "*", "BaseOp", "=", "&", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrScaleAmt", ")", ".", "getImm", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrIndexReg", ")", ".", "getReg", "(", ")", "!=", "X86", "::", "NoRegister", ")", "return", "false", ";", "const", "MachineOperand", "&", "DispMO", "=", "MemOp", ".", "getOperand", "(", "MemRefBegin", "+", "X86", "::", "AddrDisp", ")", ";", "if", "(", "!", "DispMO", ".", "isImm", "(", ")", ")", "return", "false", ";", "Offset", "=", "DispMO", ".", "getImm", "(", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "OffsetIsScalable", "=", "false", ";", "Width", "=", "!", "MemOp", ".", "memoperands_empty", "(", ")", "?", "MemOp", ".", "memoperands", "(", ")", ".", "front", "(", ")", "->", "getSize", "(", ")", ":", "0", ";", "BaseOps", ".", "push_back", "(", "BaseOp", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Get", "zero", "or", "more", "base", "operands", "and", "the", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "X86", "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::AddrScaleAmt", "1", "X86::AddrIndexReg", "X86::NoRegister", "X86::AddrDisp", "0" ]

[]

[ "<s>", "static", "void", "def_builtin", "(", "const", "char", "*", "name", ",", "tree", "type", ",", "enum", "rs6000_builtins", "code", ")", "{", "tree", "t", ";", "unsigned", "classify", "=", "rs6000_builtin_info", "[", "(", "int", ")", "code", "]", ".", "attr", ";", "const", "char", "*", "attr_string", "=", "\"\"", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "gcc_assert", "(", "IN_RANGE", "(", "(", "int", ")", "code", ",", "0", ",", "(", "int", ")", "RS6000_BUILTIN_COUNT", ")", ")", ";", "if", "(", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", ")", "fatal_error", "(", "input_location", ",", "\"internal error: builtin function %s already processed\"", ",", "name", ")", ";", "rs6000_builtin_decls", "[", "(", "int", ")", "code", "]", "=", "t", "=", "add_builtin_function", "(", "name", ",", "type", ",", "(", "int", ")", "code", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "if", "(", "(", "classify", "&", "RS6000_BTC_CONST", ")", "!=", "0", ")", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", const\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_PURE", ")", "!=", "0", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", pure\"", ";", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_FP", ")", "!=", "0", ")", "{", "TREE_NOTHROW", "(", "t", ")", "=", "1", ";", "if", "(", "flag_rounding_math", ")", "{", "DECL_PURE_P", "(", "t", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, pure\"", ";", "}", "else", "{", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "attr_string", "=", "\", fp, const\"", ";", "}", "}", "else", "if", "(", "(", "classify", "&", "RS6000_BTC_ATTR_MASK", ")", "!=", "0", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "\"rs6000_builtin, code = %4d, %s%s\\n\"", ",", "(", "int", ")", "code", ",", "name", ",", "attr_string", ")", ";", "}", "</s>" ]

[ "Add", "a", "SPARC", "builtin", "function", "with", "NAME", ",", "ICODE", ",", "CODE", "and", "TYPE", ".", "Return", "the", "function", "decl", "or", "NULL_TREE", "if", "the", "builtin", "was", "not", "added", "." ]

[ "powerpcspe", "\"\"", "0", "\"internal error: builtin function %s already processed\"", "0", "1", "1", "\", const\"", "0", "1", "1", "\", pure\"", "0", "1", "1", "1", "\", fp, pure\"", "1", "\", fp, const\"", "0", "\"rs6000_builtin, code = %4d, %s%s\\n\"" ]

[]

[ "<s>", "static", "int", "thumb2_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "int", "strict_p", ")", "{", "bool", "use_ldrd", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "arm_address_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "1", ";", "use_ldrd", "=", "(", "TARGET_LDRD", "&&", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", ")", ";", "if", "(", "code", "==", "POST_INC", "||", "code", "==", "PRE_DEC", "||", "(", "(", "code", "==", "PRE_INC", "||", "code", "==", "POST_DEC", ")", "&&", "(", "use_ldrd", "||", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", ")", ")", "return", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", ";", "else", "if", "(", "(", "code", "==", "POST_MODIFY", "||", "code", "==", "PRE_MODIFY", ")", "&&", "arm_address_register_rtx_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict_p", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "0", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ")", "{", "rtx", "addend", "=", "XEXP", "(", "XEXP", "(", "x", ",", "1", ")", ",", "1", ")", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "!", "CONST_INT_P", "(", "addend", ")", ")", "return", "0", ";", "offset", "=", "INTVAL", "(", "addend", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "return", "(", "offset", ">", "-", "256", "&&", "offset", "<", "256", ")", ";", "return", "(", "use_ldrd", "&&", "offset", ">", "-", "1024", "&&", "offset", "<", "1024", "&&", "(", "offset", "&", "3", ")", "==", "0", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "(", "code", "==", "LABEL_REF", "||", "(", "code", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "LABEL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", ")", ")", ")", "return", "1", ";", "else", "if", "(", "mode", "==", "TImode", "||", "(", "TARGET_NEON", "&&", "VALID_NEON_STRUCT_MODE", "(", "mode", ")", ")", ")", "return", "0", ";", "else", "if", "(", "code", "==", "PLUS", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "(", "arm_address_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "(", "thumb2_legitimate_index_p", "(", "mode", ",", "xop1", ",", "strict_p", ")", "||", "(", "!", "strict_p", "&&", "will_be_in_index_register", "(", "xop1", ")", ")", ")", ")", "||", "(", "arm_address_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "thumb2_legitimate_index_p", "(", "mode", ",", "xop0", ",", "strict_p", ")", ")", ")", ";", "}", "else", "if", "(", "arm_disable_literal_pool", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "0", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", "&&", "code", "==", "SYMBOL_REF", "&&", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", "&&", "!", "(", "flag_pic", "&&", "symbol_mentioned_p", "(", "get_pool_constant", "(", "x", ")", ")", "&&", "!", "pcrel_constant_p", "(", "get_pool_constant", "(", "x", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "a", "valid", "Thumb-2", "address", "operand", "." ]

[ "arm", "1", "4", "0", "0", "1", "1", "0", "0", "1", "1", "0", "4", "256", "256", "1024", "1024", "3", "0", "0", "0", "0", "0", "1", "1", "0", "0", "1", "0", "1", "0" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"EmitCallFramePseudo: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "const", "ARCInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineInstr", "&", "Old", "=", "*", "I", ";", "DebugLoc", "dl", "=", "Old", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Amt", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "auto", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "Amt", ">", "AFI", "->", "MaxCallStackReq", "&&", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKDOWN", ")", "AFI", "->", "MaxCallStackReq", "=", "Amt", ";", "}", "else", "{", "if", "(", "Amt", "!=", "0", ")", "{", "assert", "(", "(", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKDOWN", "||", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKUP", ")", "&&", "\"Unknown Frame Pseudo.\"", ")", ";", "bool", "IsAdd", "=", "(", "Old", ".", "getOpcode", "(", ")", "==", "ARC", "::", "ADJCALLSTACKUP", ")", ";", "emitRegUpdate", "(", "MBB", ",", "I", ",", "dl", ",", "ARC", "::", "SP", ",", "Amt", ",", "IsAdd", ",", "TII", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "ARC", "ARC", "\"EmitCallFramePseudo: \"", "\"\\n\"", "ARC", "ARC", "0", "ARC", "ARC::ADJCALLSTACKDOWN", "0", "ARC::ADJCALLSTACKDOWN", "ARC::ADJCALLSTACKUP", "\"Unknown Frame Pseudo.\"", "ARC::ADJCALLSTACKUP", "ARC::SP" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "bool", "ShouldForce", "=", "false", ";", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "return", "true", ";", "case", "RISCV", "::", "fixup_riscv_pcrel_lo12_i", ":", "case", "RISCV", "::", "fixup_riscv_pcrel_lo12_s", ":", "const", "MCFixup", "*", "T", "=", "cast", "<", "RISCVMCExpr", ">", "(", "Fixup", ".", "getValue", "(", ")", ")", "->", "getPCRelHiFixup", "(", ")", ";", "if", "(", "!", "T", ")", "{", "Asm", ".", "getContext", "(", ")", ".", "reportError", "(", "Fixup", ".", "getLoc", "(", ")", ",", "\"could not find corresponding %pcrel_hi\"", ")", ";", "return", "false", ";", "}", "switch", "(", "(", "unsigned", ")", "T", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected fixup kind for pcrel_lo12\"", ")", ";", "break", ";", "case", "RISCV", "::", "fixup_riscv_got_hi20", ":", "ShouldForce", "=", "true", ";", "break", ";", "case", "RISCV", "::", "fixup_riscv_pcrel_hi20", ":", "ShouldForce", "=", "T", "->", "getValue", "(", ")", "->", "findAssociatedFragment", "(", ")", "!=", "Fixup", ".", "getValue", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "break", ";", "}", "break", ";", "}", "return", "ShouldForce", "||", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", "||", "ForceRelocs", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "RISCV", "RISCV", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_pcrel_lo12_i", "RISCV::fixup_riscv_pcrel_lo12_s", "RISCV", "\"could not find corresponding %pcrel_hi\"", "\"Unexpected fixup kind for pcrel_lo12\"", "RISCV::fixup_riscv_got_hi20", "RISCV::fixup_riscv_pcrel_hi20", "RISCV::FeatureRelax" ]

[]

[ "<s>", "static", "void", "emit_compare", "(", "rtx_code", "code", ",", "rtx", "a", ",", "rtx", "b", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "BImode", ",", "SR_F_REGNUM", ")", ",", "gen_rtx_fmt_ee", "(", "code", ",", "BImode", ",", "a", ",", "b", ")", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "raw", "comparison", "for", "A", "CODE", "B", "." ]

[ "or1k" ]

[]

[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "TargetMachine", "&", "TM", ",", "const", "Module", "&", "M", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "IsXS1A", "(", "false", ")", ",", "IsXS1B", "(", "false", ")", "{", "std", "::", "string", "CPU", "=", "\"xs1a-generic\"", ";", "ParseSubtargetFeatures", "(", "FS", ",", "CPU", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "\"xs1a-generic\"" ]

[]

[ "<s>", "void", "fma_forest", "::", "fma_node_created", "(", "fma_node", "*", "node", ")", "{", "bool", "created", "=", "!", "this", "->", "m_globals", "->", "put_node", "(", "node", ")", ";", "gcc_assert", "(", "created", ")", ";", "this", "->", "m_nb_nodes", "++", ";", "}", "</s>" ]

[ "Act", "on", "the", "creation", "of", "NODE", "by", "updating", "statistics", "in", "FOREST", "and", "adding", "an", "entry", "for", "it", "in", "the", "func_fma_steering", "hashmap", "." ]

[ "aarch64" ]

[]

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

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "void", "copy_fp_args", "(", "rtx", "insn", ")", "{", "rtx", "link", ";", "rtx", "xoperands", "[", "2", "]", ";", "for", "(", "link", "=", "CALL_INSN_FUNCTION_USAGE", "(", "insn", ")", ";", "link", ";", "link", "=", "XEXP", "(", "link", ",", "1", ")", ")", "{", "int", "arg_mode", ",", "regno", ";", "rtx", "use", "=", "XEXP", "(", "link", ",", "0", ")", ";", "if", "(", "!", "(", "GET_CODE", "(", "use", ")", "==", "USE", "&&", "GET_CODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", "==", "REG", "&&", "FUNCTION_ARG_REGNO_P", "(", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ")", ")", ")", "continue", ";", "arg_mode", "=", "GET_MODE", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "regno", "=", "REGNO", "(", "XEXP", "(", "use", ",", "0", ")", ")", ";", "if", "(", "regno", ">=", "32", "&&", "regno", "<=", "39", ")", "{", "if", "(", "arg_mode", "==", "SFmode", ")", "{", "xoperands", "[", "0", "]", "=", "XEXP", "(", "use", ",", "0", ")", ";", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "26", "-", "(", "regno", "-", "32", ")", "/", "2", ")", ";", "output_asm_insn", "(", "\"{fstws|fstw} %0,-16(%%sr0,%%r30)\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -16(%%sr0,%%r30),%1\"", ",", "xoperands", ")", ";", "}", "else", "{", "xoperands", "[", "0", "]", "=", "XEXP", "(", "use", ",", "0", ")", ";", "xoperands", "[", "1", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "25", "-", "(", "regno", "-", "34", ")", "/", "2", ")", ";", "output_asm_insn", "(", "\"{fstds|fstd} %0,-16(%%sr0,%%r30)\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -12(%%sr0,%%r30),%R1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldw -16(%%sr0,%%r30),%1\"", ",", "xoperands", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Copy", "any", "FP", "arguments", "in", "INSN", "into", "integer", "registers", "." ]

[ "pa", "2", "1", "0", "0", "0", "0", "0", "32", "39", "0", "0", "1", "26", "32", "2", "\"{fstws|fstw} %0,-16(%%sr0,%%r30)\"", "\"ldw -16(%%sr0,%%r30),%1\"", "0", "0", "1", "25", "34", "2", "\"{fstds|fstd} %0,-16(%%sr0,%%r30)\"", "\"ldw -12(%%sr0,%%r30),%R1\"", "\"ldw -16(%%sr0,%%r30),%1\"" ]

[]

[ "<s>", "rtx", "sfunc_symbol", "(", "const", "char", "*", "name", ")", "{", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "name", ")", ";", "SYMBOL_REF_FLAGS", "(", "sym", ")", "=", "SYMBOL_FLAG_FUNCTION", "|", "SYMBOL_FLAG_LOCAL", ";", "if", "(", "TARGET_SHORT_CALLS", ")", ";", "else", "if", "(", "can_create_pseudo_p", "(", ")", ")", "sym", "=", "copy_to_mode_reg", "(", "Pmode", ",", "sym", ")", ";", "else", "gcc_assert", "(", "!", "reload_in_progress", "||", "reload_completed", ")", ";", "return", "sym", ";", "}", "</s>" ]

[ "Generate", "a", "SYMBOL_REF", "for", "the", "special", "function", "NAME", ".", "When", "the", "address", "ca", "n't", "be", "placed", "directly", "into", "a", "call", "instruction", ",", "and", "if", "possible", ",", "copy", "it", "to", "a", "register", "so", "that", "cse", "/", "code", "hoisting", "is", "possible", "." ]

[ "epiphany" ]

[]

[ "<s>", "void", "RV16KInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "RV16K", "RV16K" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getIRStackGuard", "(", "IRBuilderBase", "&", "IRB", ")", "const", "{", "if", "(", "hasStackGuardSlotTLS", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ")", ")", "{", "if", "(", "Subtarget", ".", "isTargetFuchsia", "(", ")", ")", "{", "return", "SegmentOffset", "(", "IRB", ",", "0x10", ",", "getAddressSpace", "(", ")", ")", ";", "}", "else", "{", "unsigned", "AddressSpace", "=", "getAddressSpace", "(", ")", ";", "Module", "*", "M", "=", "IRB", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "M", "->", "getStackProtectorGuardOffset", "(", ")", ";", "if", "(", "Offset", "==", "INT_MAX", ")", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x28", ":", "0x14", ";", "StringRef", "GuardReg", "=", "M", "->", "getStackProtectorGuardReg", "(", ")", ";", "if", "(", "GuardReg", "==", "\"fs\"", ")", "AddressSpace", "=", "X86AS", "::", "FS", ";", "else", "if", "(", "GuardReg", "==", "\"gs\"", ")", "AddressSpace", "=", "X86AS", "::", "GS", ";", "return", "SegmentOffset", "(", "IRB", ",", "Offset", ",", "AddressSpace", ")", ";", "}", "}", "return", "TargetLowering", "::", "getIRStackGuard", "(", "IRB", ")", ";", "}", "</s>" ]

[ "If", "the", "target", "has", "a", "standard", "location", "for", "the", "stack", "protector", "cookie", ",", "returns", "the", "address", "of", "that", "location", "." ]

[ "X86", "X86", "0x10", "0x28", "0x14", "\"fs\"", "X86AS::FS", "\"gs\"", "X86AS::GS" ]

[]

[ "<s>", "MCELFStreamer", "&", "AMDGPUTargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "avr_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "done", "=", "avr_rtx_costs_1", "(", "x", ",", "mode", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "avr_edump", "(", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", ",", "done", ",", "speed", "?", "\"speed\"", ":", "\"size\"", ",", "*", "total", ",", "outer_code", ",", "x", ")", ";", "}", "return", "done", ";", "}", "</s>" ]

[ "The", "AVR", "backend", "'s", "rtx_cost", "function", ".", "X", "is", "rtx", "expression", "whose", "cost", "is", "to", "be", "calculated", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "avr", "\"\\n%?=%b (%s) total=%d, outer=%C:\\n%r\\n\"", "\"speed\"", "\"size\"" ]

[]

[ "<s>", "void", "sparc_flat_expand_epilogue", "(", "bool", "for_eh", ")", "{", "HOST_WIDE_INT", "size", "=", "sparc_frame_size", ";", "if", "(", "sparc_n_global_fp_regs", ">", "0", ")", "emit_save_or_restore_global_fp_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", "-", "sparc_apparent_frame_size", ",", "SORR_RESTORE", ")", ";", "if", "(", "frame_pointer_needed", "&&", "!", "for_eh", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "hard_frame_pointer_rtx", ")", ";", "if", "(", "return_addr_reg_needed_p", "(", "sparc_leaf_function_p", ")", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "INCOMING_RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "if", "(", "sparc_save_local_in_regs_p", ")", "emit_save_or_restore_local_in_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", ",", "SORR_RESTORE", ")", ";", "if", "(", "size", "==", "0", "||", "for_eh", ")", ";", "else", "if", "(", "frame_pointer_needed", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "emit_move_insn", "(", "stack_pointer_rtx", ",", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "size", "<=", "4096", ")", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "size", ")", ")", ")", ";", "else", "if", "(", "size", "<=", "8192", ")", "{", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", ")", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "size", "-", "4096", ")", ")", ")", ";", "}", "else", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "reg", ",", "GEN_INT", "(", "size", ")", ")", ";", "emit_insn", "(", "gen_stack_pointer_inc", "(", "reg", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Expand", "the", "function", "epilogue", ",", "either", "normal", "or", "part", "of", "a", "sibcall", ".", "We", "emit", "all", "the", "instructions", "except", "the", "return", "or", "the", "call", "." ]

[ "sparc", "0", "1", "0", "1", "4096", "8192", "4096", "4096", "1" ]

[]

[ "<s>", "static", "rtx", "mips_dwarf_register_span", "(", "rtx", "reg", ")", "{", "rtx", "high", ",", "low", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "if", "(", "FP_REG_P", "(", "REGNO", "(", "reg", ")", ")", "&&", "TARGET_FLOATXX", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_FPREG", ")", "{", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ")", ";", "}", "else", "if", "(", "FP_REG_P", "(", "REGNO", "(", "reg", ")", ")", "&&", "TARGET_BIG_ENDIAN", "&&", "MAX_FPRS_PER_FMT", ">", "1", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_FPREG", ")", "{", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "UNITS_PER_HWFPVALUE", ")", ";", "high", "=", "mips_subword", "(", "reg", ",", "true", ")", ";", "low", "=", "mips_subword", "(", "reg", ",", "false", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "high", ",", "low", ")", ")", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Implement", "TARGET_DWARF_REGISTER_SPAN", "." ]

[ "mips", "1", "1", "2" ]

[]

[ "<s>", "void", "MipsOutgoingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "uint64_t", "LocMemOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "MemTy", ",", "commonAlignment", "(", "STI", ".", "getStackAlignment", "(", ")", ",", "LocMemOffset", ")", ")", ";", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ExtReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "SDValue", "AlphaTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Alpha", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "SDValue", "RetValue", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "RetValue", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "Full", ")", "RetValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "RetValue", ")", ";", "InVals", ".", "push_back", "(", "RetValue", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Alpha", "Alpha", "ISD::InputArg", "16", "Alpha", "0", "1", "0", "2", "ISD::AssertSext", "ISD::AssertZext", "ISD::TRUNCATE" ]

[]

[ "<s>", "void", "Z80InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "Z80", "::", "GR8RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD8xmr", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Z80", "::", "BR16RegClass", "||", "Z80", "::", "BR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD16xmr", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "Z80", "::", "GR16RegClass", "||", "Z80", "::", "GR16RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "get", "(", "Z80", "::", "LD16xmr", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"What the hell register is this?? Unable to store to stack slot!\"", ")", ";", "}", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80::GR8RegClass", "Z80::LD8xmr", "0", "Z80::BR16RegClass", "Z80::BR16RegClass", "Z80::LD16xmr", "0", "Z80::GR16RegClass", "Z80::GR16RegClass", "Z80::LD16xmr", "0", "\"What the hell register is this?? Unable to store to stack slot!\"" ]

[]

[ "<s>", "void", "HSAILAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "HSAILMCInstLower", "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", "." ]

[ "HSAIL", "HSAIL", "HSAIL" ]

[]

[ "<s>", "Register", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "A0_64", ":", "Mips", "::", "A0", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "Mips", "Mips::A0_64", "Mips::A0" ]

[]

[ "<s>", "void", "MetadataStreamerV3", "::", "end", "(", ")", "{", "std", "::", "string", "HSAMetadataString", ";", "raw_string_ostream", "StrOS", "(", "HSAMetadataString", ")", ";", "HSAMetadataDoc", "->", "toYAML", "(", "StrOS", ")", ";", "if", "(", "DumpHSAMetadata", ")", "dump", "(", "StrOS", ".", "str", "(", ")", ")", ";", "if", "(", "VerifyHSAMetadata", ")", "verify", "(", "StrOS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "char", "*", "PTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown opcode\"", ")", ";", "case", "PTXISD", "::", "EXIT", ":", "return", "\"PTXISD::EXIT\"", ";", "case", "PTXISD", "::", "RET", ":", "return", "\"PTXISD::RET\"", ";", "}", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Unknown opcode\"", "PTXISD::EXIT", "\"PTXISD::EXIT\"", "PTXISD::RET", "\"PTXISD::RET\"" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createNVPTXPrologEpilogPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createNVPTXPeephole", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

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

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

[ "M88k", "\"M88kPreLegalizerCombiner\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "PowerPC" ]

[]

[ "<s>", "unsigned", "int", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "AArch64", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "AArch64", "AArch64::NumTargetFixupKinds" ]

[]

[ "<s>", "void", "AMDGPUPromoteKernelArguments", "::", "enqueueUsers", "(", "Value", "*", "Ptr", ")", "{", "SmallVector", "<", "User", "*", ">", "PtrUsers", "(", "Ptr", "->", "users", "(", ")", ")", ";", "while", "(", "!", "PtrUsers", ".", "empty", "(", ")", ")", "{", "Instruction", "*", "U", "=", "dyn_cast", "<", "Instruction", ">", "(", "PtrUsers", ".", "pop_back_val", "(", ")", ")", ";", "if", "(", "!", "U", ")", "continue", ";", "switch", "(", "U", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "{", "LoadInst", "*", "LD", "=", "cast", "<", "LoadInst", ">", "(", "U", ")", ";", "PointerType", "*", "PT", "=", "dyn_cast", "<", "PointerType", ">", "(", "LD", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PT", "||", "(", "PT", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "FLAT_ADDRESS", "&&", "PT", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "GLOBAL_ADDRESS", "&&", "PT", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "||", "LD", "->", "getPointerOperand", "(", ")", "->", "stripInBoundsOffsets", "(", ")", "!=", "Ptr", ")", "break", ";", "const", "MemoryAccess", "*", "MA", "=", "MSSA", "->", "getWalker", "(", ")", "->", "getClobberingMemoryAccess", "(", "LD", ")", ";", "if", "(", "MSSA", "->", "isLiveOnEntryDef", "(", "MA", ")", ")", "Ptrs", ".", "push_back", "(", "LD", ")", ";", "break", ";", "}", "case", "Instruction", "::", "GetElementPtr", ":", "case", "Instruction", "::", "AddrSpaceCast", ":", "case", "Instruction", "::", "BitCast", ":", "if", "(", "U", "->", "getOperand", "(", "0", ")", "->", "stripInBoundsOffsets", "(", ")", "==", "Ptr", ")", "PtrUsers", ".", "append", "(", "U", "->", "user_begin", "(", ")", ",", "U", "->", "user_end", "(", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Enqueue", "the", "users", "of", "this", "instruction", "in", "the", "visit", "worklist", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "*", "F", ")", ")", "return", "false", ";", "HexagonConstEvaluator", "HCE", "(", "MF", ")", ";", "return", "MachineConstPropagator", "(", "HCE", ")", ".", "run", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TSM", ".", "init", "(", "&", "MF", ".", "getSubtarget", "(", ")", ")", ";", "auto", "*", "PSI", "=", "&", "getAnalysis", "<", "ProfileSummaryInfoWrapperPass", ">", "(", ")", ".", "getPSI", "(", ")", ";", "auto", "*", "MBFI", "=", "(", "PSI", "&&", "PSI", "->", "hasProfileSummary", "(", ")", ")", "?", "&", "getAnalysis", "<", "LazyMachineBlockFrequencyInfoPass", ">", "(", ")", ".", "getBFI", "(", ")", ":", "nullptr", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "const", "auto", "&", "ReturnBB", ":", "ReturnBBs", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "ReturnBB", ".", "first", ";", "unsigned", "Cycles", "=", "ReturnBB", ".", "second", ";", "bool", "OptForSize", "=", "llvm", "::", "shouldOptimizeForSize", "(", "MBB", ",", "PSI", ",", "MBFI", ")", ";", "if", "(", "OptForSize", ")", "continue", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugInstr", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

[ "<s>", "bool", "Z80MachineLateOptimization", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Z80", "Z80" ]

[]

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

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

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

[]