Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "MBlaze" ]

[]

[ "<s>", "unsigned", "M88kMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "uint64_t", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"Expected MCExpr\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "assert", "(", "isa", "<", "M88kMCExpr", ">", "(", "Expr", ")", "&&", "\"Expected M88kMCExpr\"", ")", ";", "const", "uint32_t", "Offset", "=", "2", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "Offset", ",", "Expr", ",", "MCFixupKind", "(", "FixupKind", "(", "Expr", ")", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "M88k", "M88k", "\"Expected MCExpr\"", "M88k", "\"Expected M88kMCExpr\"", "2", "0" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "BranchFolderPassID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXFavorNonGenericAddrSpacesPass", "(", ")", ")", ";", "addPass", "(", "createDeadCodeEliminationPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "mips_arg_partial_bytes", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "struct", "mips_arg_info", "info", ";", "mips_get_arg_info", "(", "&", "info", ",", "get_cumulative_args", "(", "cum", ")", ",", "mode", ",", "type", ",", "named", ")", ";", "return", "info", ".", "stack_words", ">", "0", "?", "info", ".", "reg_words", "*", "UNITS_PER_WORD", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ARG_PARTIAL_BYTES", "." ]

[ "mips", "0", "0" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "callingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MFI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "MVT", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "VarargVreg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "PtrVT", ")", ")", ";", "MFI", "->", "setVarargBufferVreg", "(", "VarargVreg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VarargVreg", ",", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstant", "(", "Ins", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "MFI", "->", "addParam", "(", "PtrVT", ")", ";", "}", "SmallVector", "<", "MVT", ",", "4", ">", "Params", ";", "SmallVector", "<", "MVT", ",", "4", ">", "Results", ";", "computeSignatureVTs", "(", "MF", ".", "getFunction", "(", ")", ".", "getFunctionType", "(", ")", ",", "MF", ".", "getFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "Params", ",", "Results", ")", ";", "for", "(", "MVT", "VT", ":", "Results", ")", "MFI", "->", "addResult", "(", "VT", ")", ";", "assert", "(", "MFI", "->", "getParams", "(", ")", ".", "size", "(", ")", "==", "Params", ".", "size", "(", ")", "&&", "std", "::", "equal", "(", "MFI", "->", "getParams", "(", ")", ".", "begin", "(", ")", ",", "MFI", "->", "getParams", "(", ")", ".", "end", "(", ")", ",", "Params", ".", "begin", "(", ")", ")", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssemblyISD::ARGUMENT", "MVT::i32", "4", "4" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "RISCVAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_riscv_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_pcrel_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_i\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_s\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tprel_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_tls_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tls_gd_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_jal\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_branch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_jump\"", ",", "2", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_branch\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call_plt\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_relax\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_align\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "RISCV", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "RISCV", "RISCV", "\"fixup_riscv_hi20\"", "12", "20", "0", "\"fixup_riscv_lo12_i\"", "20", "12", "0", "\"fixup_riscv_lo12_s\"", "0", "32", "0", "\"fixup_riscv_pcrel_hi20\"", "12", "20", "\"fixup_riscv_pcrel_lo12_i\"", "20", "12", "\"fixup_riscv_pcrel_lo12_s\"", "0", "32", "\"fixup_riscv_got_hi20\"", "12", "20", "\"fixup_riscv_tprel_hi20\"", "12", "20", "0", "\"fixup_riscv_tprel_lo12_i\"", "20", "12", "0", "\"fixup_riscv_tprel_lo12_s\"", "0", "32", "0", "\"fixup_riscv_tprel_add\"", "0", "0", "0", "\"fixup_riscv_tls_got_hi20\"", "12", "20", "\"fixup_riscv_tls_gd_hi20\"", "12", "20", "\"fixup_riscv_jal\"", "12", "20", "\"fixup_riscv_branch\"", "0", "32", "\"fixup_riscv_rvc_jump\"", "2", "11", "\"fixup_riscv_rvc_branch\"", "0", "16", "\"fixup_riscv_call\"", "0", "64", "\"fixup_riscv_call_plt\"", "0", "64", "\"fixup_riscv_relax\"", "0", "0", "0", "\"fixup_riscv_align\"", "0", "0", "0", "RISCV::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "BF", "::", "ALLRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVE", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "if", "(", "BF", "::", "D16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "SLL16i", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "BF", "::", "DRegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "if", "(", "SrcReg", "==", "BF", "::", "NCC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVENCC_z", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "BITTGL", ")", ",", "DestReg", ")", ".", "addReg", "(", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "SrcReg", "==", "BF", "::", "CC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVECC_zext", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "}", "if", "(", "BF", "::", "DRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "DestReg", "==", "BF", "::", "NCC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "SETEQri_not", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "DestReg", "==", "BF", "::", "CC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVECC_nz", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "}", "if", "(", "DestReg", "==", "BF", "::", "NCC", "&&", "SrcReg", "==", "BF", "::", "CC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVE_ncccc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "if", "(", "DestReg", "==", "BF", "::", "CC", "&&", "SrcReg", "==", "BF", "::", "NCC", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "MOVE_ccncc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Bad reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::ALLRegClass", "BF::MOVE", "BF::D16RegClass", "BF::SLL16i", "0", "BF::DRegClass", "BF::NCC", "BF::MOVENCC_z", "BF::BITTGL", "0", "BF::CC", "BF::MOVECC_zext", "BF::DRegClass", "BF::NCC", "BF::SETEQri_not", "0", "BF::CC", "BF::MOVECC_nz", "BF::NCC", "BF::CC", "BF::MOVE_ncccc", "BF::CC", "BF::NCC", "BF::MOVE_ccncc", "\"Bad reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "override", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "{", "if", "(", "CurrentState", "==", "FunctionStart", ")", "{", "auto", "&", "TOut", "=", "reinterpret_cast", "<", "WebAssemblyTargetStreamer", "&", ">", "(", "*", "Out", ".", "getTargetStreamer", "(", ")", ")", ";", "TOut", ".", "emitLocal", "(", "SmallVector", "<", "wasm", "::", "ValType", ",", "0", ">", "(", ")", ")", ";", "}", "CurrentState", "=", "Instructions", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"instruction requires a WASM feature not currently enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_NearMisses", ":", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"ambiguous instruction\"", ")", ";", "case", "Match_InvalidTiedOperand", ":", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Parser", ".", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "Operands", "[", "ErrorInfo", "]", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Parser", ".", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "wasm::ValType", "0", "\"instruction requires a WASM feature not currently enabled\"", "\"invalid instruction\"", "\"ambiguous instruction\"", "0ULL", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "void", "HSAILPassConfig", "::", "addPostRegAlloc", "(", ")", "{", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "void", "ix86_expand_floorceildf_32", "(", "rtx", "operand0", ",", "rtx", "operand1", ",", "bool", "do_floor", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operand0", ")", ";", "rtx", "xa", ",", "TWO52", ",", "tmp", ",", "one", ",", "res", ",", "mask", ";", "rtx_code_label", "*", "label", ";", "TWO52", "=", "ix86_gen_TWO52", "(", "mode", ")", ";", "res", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "res", ",", "operand1", ")", ";", "xa", "=", "ix86_expand_sse_fabs", "(", "res", ",", "&", "mask", ")", ";", "label", "=", "ix86_expand_sse_compare_and_jump", "(", "UNLE", ",", "TWO52", ",", "xa", ",", "false", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "PLUS", ",", "xa", ",", "TWO52", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "xa", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa", ",", "TWO52", ",", "xa", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "ix86_sse_copysign_to_positive", "(", "xa", ",", "xa", ",", "res", ",", "mask", ")", ";", "one", "=", "force_reg", "(", "mode", ",", "const_double_from_real_value", "(", "do_floor", "?", "dconst1", ":", "dconstm1", ",", "mode", ")", ")", ";", "tmp", "=", "ix86_expand_sse_compare_mask", "(", "UNGT", ",", "xa", ",", "res", ",", "!", "do_floor", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_AND", "(", "mode", ",", "one", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "xa", ",", "tmp", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "emit_move_insn", "(", "res", ",", "tmp", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "emit_move_insn", "(", "operand0", ",", "res", ")", ";", "}", "</s>" ]

[ "Expand", "SSE2", "sequence", "for", "computing", "floor", "or", "ceil", "from", "OPERAND1", "storing", "into", "OPERAND0", "." ]

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

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "DebugLoc", "dl", "=", "Old", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "unsigned", "Opc", "=", "Old", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "-", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "MBB", ",", "I", ",", "TII", ",", "dl", ",", "*", "this", ",", "Amount", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "ARM", "0", "0", "1", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP" ]

[]

[ "<s>", "static", "void", "ia64_output_function_end_prologue", "(", "FILE", "*", "file", ")", "{", "if", "(", "ia64_except_unwind_info", "(", "&", "global_options", ")", "!=", "UI_TARGET", ")", "return", ";", "fputs", "(", "\"\\t.body\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Emit", "the", ".body", "directive", "at", "the", "scheduled", "end", "of", "the", "prologue", "." ]

[ "ia64", "\"\\t.body\\n\"" ]

[]

[ "<s>", "unsigned", "AArch64InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "{", "auto", "Op", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Op", "==", "AArch64", "::", "INLINEASM", "||", "Op", "==", "AArch64", "::", "INLINEASM_BR", ")", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MAI", ")", ";", "}", "if", "(", "MI", ".", "isMetaInstruction", "(", ")", ")", "return", "0", ";", "unsigned", "NumBytes", "=", "0", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "TargetOpcode", "::", "STACKMAP", ":", "NumBytes", "=", "StackMapOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "PATCHPOINT", ":", "NumBytes", "=", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "break", ";", "case", "TargetOpcode", "::", "STATEPOINT", ":", "NumBytes", "=", "StatepointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "assert", "(", "NumBytes", "%", "4", "==", "0", "&&", "\"Invalid number of NOP bytes requested!\"", ")", ";", "if", "(", "NumBytes", "==", "0", ")", "NumBytes", "=", "4", ";", "break", ";", "case", "AArch64", "::", "TLSDESC_CALLSEQ", ":", "NumBytes", "=", "16", ";", "break", ";", "case", "AArch64", "::", "SpeculationBarrierISBDSBEndBB", ":", "NumBytes", "=", "8", ";", "break", ";", "case", "AArch64", "::", "SpeculationBarrierSBEndBB", ":", "NumBytes", "=", "4", ";", "break", ";", "case", "AArch64", "::", "JumpTableDest32", ":", "case", "AArch64", "::", "JumpTableDest16", ":", "case", "AArch64", "::", "JumpTableDest8", ":", "NumBytes", "=", "12", ";", "break", ";", "case", "AArch64", "::", "SPACE", ":", "NumBytes", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "break", ";", "case", "AArch64", "::", "StoreSwiftAsyncContext", ":", "NumBytes", "=", "20", ";", "break", ";", "case", "TargetOpcode", "::", "BUNDLE", ":", "NumBytes", "=", "getInstBundleLength", "(", "MI", ")", ";", "break", ";", "}", "return", "NumBytes", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "AArch64", "AArch64", "AArch64::INLINEASM", "AArch64::INLINEASM_BR", "0", "0", "0", "4", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "4", "0", "\"Invalid number of NOP bytes requested!\"", "0", "4", "AArch64::TLSDESC_CALLSEQ", "16", "AArch64::SpeculationBarrierISBDSBEndBB", "8", "AArch64::SpeculationBarrierSBEndBB", "4", "AArch64::JumpTableDest32", "AArch64::JumpTableDest16", "AArch64::JumpTableDest8", "12", "AArch64::SPACE", "1", "AArch64::StoreSwiftAsyncContext", "20" ]

[]

[ "<s>", "static", "rtx", "riscv_add_offset", "(", "rtx", "temp", ",", "rtx", "reg", ",", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "!", "SMALL_OPERAND", "(", "offset", ")", ")", "{", "rtx", "high", ";", "high", "=", "gen_int_mode", "(", "CONST_HIGH_PART", "(", "offset", ")", ",", "Pmode", ")", ";", "offset", "=", "CONST_LOW_PART", "(", "offset", ")", ";", "high", "=", "riscv_force_temporary", "(", "temp", ",", "high", ")", ";", "reg", "=", "riscv_force_temporary", "(", "temp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "high", ",", "reg", ")", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "reg", ",", "offset", ")", ";", "}", "</s>" ]

[ "Return", "a", "legitimate", "address", "for", "REG", "+", "OFFSET", ".", "TEMP", "is", "as", "for", "riscv_force_temporary", ";", "it", "is", "only", "needed", "when", "OFFSET", "is", "not", "a", "SMALL_OPERAND", "." ]

[ "riscv" ]

[]

[ "<s>", "MSP430Subtarget", "::", "MSP430Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "MSP430GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "DL", "(", "\"e-m:e-p:16:16-i32:16:32-a:16-n8:16\"", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "DL", ")", "{", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "\"e-m:e-p:16:16-i32:16:32-a:16-n8:16\"" ]

[]

[ "<s>", "void", "PatmosFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "TargetInstrInfo", "*", "TII", "=", "STC", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "stackSize", "=", "assignFrameObjects", "(", "MF", ",", "!", "DisableStackCache", ")", ";", "if", "(", "!", "DisableStackCache", ")", "{", "MachineInstr", "*", "MI", "=", "emitSTC", "(", "MF", ",", "MBB", ",", "MBBI", ",", "Patmos", "::", "SRESi", ")", ";", "if", "(", "MI", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "patchCallSites", "(", "MF", ")", ";", "}", "if", "(", "stackSize", ")", "{", "if", "(", "stackSize", "<=", "0xFFF", ")", "{", "MachineInstr", "*", "MI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Patmos", "::", "SUBi", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "stackSize", ")", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", "->", "get", "(", "Patmos", "::", "SUBl", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "stackSize", ")", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::SRESi", "0xFFF", "Patmos::SUBi", "Patmos::RSP", "Patmos::RSP", "Patmos::SUBl", "Patmos::RSP", "Patmos::RSP" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "ARMOperand", ">", "CreateReg", "(", "unsigned", "RegNum", ",", "SMLoc", "S", ",", "SMLoc", "E", ")", "{", "auto", "Op", "=", "std", "::", "make_unique", "<", "ARMOperand", ">", "(", "k_Register", ")", ";", "Op", "->", "Reg", ".", "RegNum", "=", "RegNum", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

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

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

[]

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

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

[ "TVM" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "RISCV", "::", "SD", ":", "RISCV", "::", "SW", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSW", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "RISCV", "::", "FSD", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::SD", "RISCV::SW", "RISCV::FPR32RegClass", "RISCV::FSW", "RISCV::FPR64RegClass", "RISCV::FSD", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "X86_RegCall", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "{", "return", "(", "HasSSE", "?", "CSR_Win64_RegCall_RegMask", ":", "CSR_Win64_RegCall_NoSSE_RegMask", ")", ";", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_SysV64_RegCall_RegMask", ":", "CSR_SysV64_RegCall_NoSSE_RegMask", ")", ";", "}", "}", "else", "{", "return", "(", "HasSSE", "?", "CSR_32_RegCall_RegMask", ":", "CSR_32_RegCall_NoSSE_RegMask", ")", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "vax_output_function_prologue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", ")", "{", "int", "regno", ";", "int", "mask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "mask", "|=", "1", "<<", "regno", ";", "fprintf", "(", "file", ",", "\"\\t.word 0x%x\\n\"", ",", "mask", ")", ";", "if", "(", "dwarf2out_do_frame", "(", ")", ")", "{", "const", "char", "*", "label", "=", "dwarf2out_cfi_label", "(", ")", ";", "int", "offset", "=", "0", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "--", "regno", ")", "if", "(", "regs_ever_live", "[", "regno", "]", "&&", "!", "call_used_regs", "[", "regno", "]", ")", "dwarf2out_reg_save", "(", "label", ",", "regno", ",", "offset", "-=", "4", ")", ";", "dwarf2out_reg_save", "(", "label", ",", "PC_REGNUM", ",", "offset", "-=", "4", ")", ";", "dwarf2out_reg_save", "(", "label", ",", "FRAME_POINTER_REGNUM", ",", "offset", "-=", "4", ")", ";", "dwarf2out_reg_save", "(", "label", ",", "ARG_POINTER_REGNUM", ",", "offset", "-=", "4", ")", ";", "dwarf2out_def_cfa", "(", "label", ",", "FRAME_POINTER_REGNUM", ",", "-", "(", "offset", "-", "4", ")", ")", ";", "}", "size", "-=", "STARTING_FRAME_OFFSET", ";", "if", "(", "size", ">=", "64", ")", "asm_fprintf", "(", "file", ",", "\"\\tmovab %wd(%Rsp),%Rsp\\n\"", ",", "-", "size", ")", ";", "else", "if", "(", "size", ")", "asm_fprintf", "(", "file", ",", "\"\\tsubl2 $%wd,%Rsp\\n\"", ",", "size", ")", ";", "}", "</s>" ]

[ "Generate", "the", "assembly", "code", "for", "function", "entry", ".", "FILE", "is", "a", "stdio", "stream", "to", "output", "the", "code", "to", ".", "SIZE", "is", "an", "int", ":", "how", "many", "units", "of", "temporary", "storage", "to", "allocate", ".", "Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", "." ]

[ "vax", "0", "0", "1", "\"\\t.word 0x%x\\n\"", "0", "1", "0", "4", "4", "4", "4", "4", "64", "\"\\tmovab %wd(%Rsp),%Rsp\\n\"", "\"\\tsubl2 $%wd,%Rsp\\n\"" ]

[]

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

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

[ "ARM64", "\"ARM64 Assembly Printer\"" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "InVals", ".", "push_back", "(", "SDValue", "(", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "R600", "ISD::InputArg", "0" ]

[]

[ "<s>", "bool", "SILowerSGPRSpills", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "LIS", "=", "getAnalysisIfAvailable", "<", "LiveIntervals", ">", "(", ")", ";", "assert", "(", "SaveBlocks", ".", "empty", "(", ")", "&&", "RestoreBlocks", ".", "empty", "(", ")", ")", ";", "calculateSaveRestoreBlocks", "(", "MF", ")", ";", "bool", "HasCSRs", "=", "spillCalleeSavedRegs", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", "&&", "!", "HasCSRs", ")", "{", "SaveBlocks", ".", "clear", "(", ")", ";", "RestoreBlocks", ".", "clear", "(", ")", ";", "return", "false", ";", "}", "bool", "MadeChange", "=", "false", ";", "bool", "NewReservedRegs", "=", "false", ";", "const", "bool", "HasSGPRSpillToVGPR", "=", "TRI", "->", "spillSGPRToVGPR", "(", ")", "&&", "(", "HasCSRs", "||", "FuncInfo", "->", "hasSpilledSGPRs", "(", ")", ")", ";", "if", "(", "HasSGPRSpillToVGPR", ")", "{", "BitVector", "SpillFIs", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ",", "false", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "MBB", ")", ")", "{", "if", "(", "!", "TII", "->", "isSGPRSpill", "(", "MI", ")", ")", "continue", ";", "int", "FI", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "addr", ")", "->", "getIndex", "(", ")", ";", "assert", "(", "MFI", ".", "getStackID", "(", "FI", ")", "==", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "FuncInfo", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "FI", ")", ")", "{", "NewReservedRegs", "=", "true", ";", "bool", "Spilled", "=", "TRI", "->", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MI", ",", "FI", ",", "nullptr", ",", "LIS", ")", ";", "(", "void", ")", "Spilled", ";", "assert", "(", "Spilled", "&&", "\"failed to spill SGPR to VGPR when allocated\"", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "}", "}", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "SSpill", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "SSpill", ".", "VGPR", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "SpillFIs", "[", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", "]", ")", "{", "MI", ".", "getOperand", "(", "0", ")", ".", "ChangeToRegister", "(", "Register", "(", ")", ",", "false", ")", ";", "}", "}", "}", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MFI", ",", "false", ")", ";", "MadeChange", "=", "true", ";", "}", "SaveBlocks", ".", "clear", "(", ")", ";", "RestoreBlocks", ".", "clear", "(", ")", ";", "if", "(", "NewReservedRegs", ")", "MRI", ".", "freezeReservedRegs", "(", "MF", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::OpName", "\"failed to spill SGPR to VGPR when allocated\"", "0", "0", "0" ]

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "II", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "Is64BitMode", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "do", "{", "DOUT", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "TargetInstrDesc", "&", "Desc", "=", "I", "->", "getDesc", "(", ")", ";", "emitInstruction", "(", "*", "I", ",", "&", "Desc", ")", ";", "if", "(", "Desc", ".", "getOpcode", "(", ")", "==", "X86", "::", "MOVPC32r", ")", "emitInstruction", "(", "*", "I", ",", "&", "II", "->", "get", "(", "X86", "::", "POP32r", ")", ")", ";", "NumEmitted", "++", ";", "}", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"JITTing function '\"", "\"'\\n\"", "X86::MOVPC32r", "X86::POP32r" ]

[]

[ "<s>", "Register", "LanaiTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", ",", "const", "MachineFunction", "&", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"pc\"", ",", "Lanai", "::", "PC", ")", ".", "Case", "(", "\"sp\"", ",", "Lanai", "::", "SP", ")", ".", "Case", "(", "\"fp\"", ",", "Lanai", "::", "FP", ")", ".", "Case", "(", "\"rr1\"", ",", "Lanai", "::", "RR1", ")", ".", "Case", "(", "\"r10\"", ",", "Lanai", "::", "R10", ")", ".", "Case", "(", "\"rr2\"", ",", "Lanai", "::", "RR2", ")", ".", "Case", "(", "\"r11\"", ",", "Lanai", "::", "R11", ")", ".", "Case", "(", "\"rca\"", ",", "Lanai", "::", "RCA", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Lanai", "Lanai", "\"pc\"", "Lanai::PC", "\"sp\"", "Lanai::SP", "\"fp\"", "Lanai::FP", "\"rr1\"", "Lanai::RR1", "\"r10\"", "Lanai::R10", "\"rr2\"", "Lanai::RR2", "\"r11\"", "Lanai::R11", "\"rca\"", "Lanai::RCA", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "Cond", "[", "1", "]", ".", "setImm", "(", "Cond", "[", "1", "]", ".", "getImm", "(", ")", "^", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "1", "1", "0" ]

[]

[ "<s>", "enum", "calling_abi", "ix86_cfun_abi", "(", "void", ")", "{", "return", "cfun", "?", "cfun", "->", "machine", "->", "call_abi", ":", "ix86_abi", ";", "}", "</s>" ]

[ "Returns", "value", "SYSV_ABI", ",", "MS_ABI", "dependent", "on", "cfun", ",", "specifying", "the", "call", "abi", "used", "." ]

[ "i386" ]

[]

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

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

[ "mproc", "\"mproc Assembly Printer\"" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "getMCOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "StringRef", "(", "GV", "->", "getName", "(", ")", ")", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "Ctx", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_TargetIndex", ":", "{", "assert", "(", "MO", ".", "getIndex", "(", ")", "==", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "StringRef", "(", "END_OF_TEXT_LABEL_NAME", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "Ctx", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ";", "break", ";", "}", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

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

[]

[ "<s>", "unsigned", "int", "call_properties", "(", "const", "function_instance", "&", ")", "const", "OVERRIDE", "{", "return", "CP_WRITE_MEMORY", ";", "}", "</s>" ]

[ "Default", "implementation", "of", "function_base", ":", ":call_properties", ",", "with", "conservatively", "correct", "behavior", "for", "floating-point", "instructions", "." ]

[ "aarch64" ]

[]

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

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

[ "Patmos", "Patmos" ]

[]

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

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

[ "TMS320C64X", "TMS320C64X" ]

[]

[ "<s>", "unsigned", "X86TTI", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TCC_Free", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "(", "Idx", "==", "1", ")", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "}", "return", "X86TTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "Intrinsic::ID", "0", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "64", "32", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "X86" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "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", ")", "." ]

[ "PowerPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "16", "0xFFFF" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Annotate Kernel Features\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Annotate Kernel Features\"" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isTargetAndroid", "(", ")", ")", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "unsigned", "AddressSpace", ",", "Offset", ";", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "Offset", "=", "0x48", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Kernel", ")", "AddressSpace", "=", "256", ";", "else", "AddressSpace", "=", "257", ";", "}", "else", "{", "Offset", "=", "0x24", ";", "AddressSpace", "=", "256", ";", "}", "return", "ConstantExpr", "::", "getIntToPtr", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "IRB", ".", "getContext", "(", ")", ")", ",", "Offset", ")", ",", "Type", "::", "getInt8PtrTy", "(", "IRB", ".", "getContext", "(", ")", ")", "->", "getPointerTo", "(", "AddressSpace", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "X86", "X86", "0x48", "256", "257", "0x24", "256" ]

[]

[ "<s>", "static", "int", "extended_reg_mentioned_1", "(", "rtx", "*", "p", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "regno", ";", "if", "(", "!", "REG_P", "(", "*", "p", ")", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "*", "p", ")", ";", "return", "REX_INT_REGNO_P", "(", "regno", ")", "||", "REX_SSE_REGNO_P", "(", "regno", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "when", "P", "points", "to", "register", "encoded", "via", "REX", "prefix", ".", "Called", "via", "for_each_rtx", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", ".", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", ".", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", ".", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "I", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "bool", "nds32_rtx_costs_impl", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "speed", ")", "return", "rtx_cost_model", ".", "speed_prefer", "(", "x", ",", "code", ",", "outer_code", ",", "opno", ",", "total", ")", ";", "else", "return", "rtx_cost_model", ".", "size_prefer", "(", "x", ",", "code", ",", "outer_code", ",", "opno", ",", "total", ")", ";", "}", "</s>" ]

[ "This", "target", "hook", "describes", "the", "relative", "costs", "of", "RTL", "expressions", ".", "Return", "'true", "'", "when", "all", "subexpressions", "of", "x", "have", "been", "processed", ".", "Return", "'false", "'", "to", "sum", "the", "costs", "of", "sub-rtx", ",", "plus", "cost", "of", "this", "operation", ".", "Refer", "to", "gcc/rtlanal.cc", "for", "more", "information", "." ]

[ "nds32" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "DOUT", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ";", "DOUT", "<<", "\"<--------->\\n\"", ";", "MI", ".", "print", "(", "DOUT", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "int", "stackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "int", "spOffset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "DOUT", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ";", "DOUT", "<<", "\"spOffset : \"", "<<", "spOffset", "<<", "\"\\n\"", ";", "DOUT", "<<", "\"stackSize : \"", "<<", "stackSize", "<<", "\"\\n\"", ";", "int", "Offset", "=", "(", "(", "spOffset", "<", "0", ")", "?", "(", "stackSize", "+", "(", "-", "(", "spOffset", "+", "4", ")", ")", ")", ":", "(", "spOffset", ")", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "getImm", "(", ")", ";", "DOUT", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", ";", "DOUT", "<<", "\"<--------->\\n\"", ";", "MI", ".", "getOperand", "(", "i", "-", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "getFrameRegister", "(", "MF", ")", ",", "false", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "\"Instr doesn't have FrameIndex operand!\"", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"spOffset : \"", "\"\\n\"", "\"stackSize : \"", "\"\\n\"", "0", "4", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "1" ]

[]

[ "<s>", "SDValue", "AArch64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "char", "*", "bzeroEntry", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "DAG", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getBZeroEntry", "(", ")", ":", "nullptr", ";", "if", "(", "bzeroEntry", "&&", "(", "!", "SizeValue", "||", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "DAG", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", ")", ";", "Type", "*", "IntPtrTy", "=", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "CallingConv", "::", "C", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroEntry", ",", "IntPtr", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "256", "AArch64", "AArch64", "0" ]

[]

[ "<s>", "bool", "HexagonTTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ",", "Align", ")", "{", "return", "HexagonMaskedVMem", "&&", "isTypeForHVX", "(", "DataType", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "load", "." ]

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

[]

[ "<s>", "HOST_WIDE_INT", "bpf_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "HOST_WIDE_INT", "ret", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "ret", "=", "(", "cfun", "->", "machine", "->", "local_vars_size", "+", "cfun", "->", "machine", "->", "callee_saved_reg_size", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "ret", "=", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Return", "the", "initial", "difference", "between", "the", "specified", "pair", "of", "registers", ".", "The", "registers", "that", "can", "figure", "in", "FROM", ",", "and", "TO", ",", "are", "specified", "by", "ELIMINABLE_REGS", "in", "bpf.h", ".", "This", "function", "is", "used", "in", "the", "definition", "of", "INITIAL_ELIMINATION_OFFSET", "in", "bpf.h" ]

[ "bpf", "0" ]

[]

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

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

[ "OR1K" ]

[]

[ "<s>", "void", "CAHPRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "CAHPInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "CAHPSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", "=", "getFrameLowering", "(", "MF", ")", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "report_fatal_error", "(", "\"Frame offsets outside of the signed 16-bit range not supported\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "if", "(", "!", "isInt", "<", "10", ">", "(", "Offset", ")", ")", "{", "unsigned", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "CAHP", "::", "GPRRegClass", ")", ";", "TII", "->", "movImm16", "(", "MBB", ",", "II", ",", "DL", ",", "ScratchReg", ",", "Offset", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", "->", "get", "(", "CAHP", "::", "ADD", ")", ",", "ScratchReg", ")", ".", "addReg", "(", "ScratchReg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "Offset", "=", "0", ";", "FrameReg", "=", "ScratchReg", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "CAHP", "CAHP", "0", "\"Unexpected non-zero SPAdj value\"", "CAHP", "CAHP", "1", "16", "\"Frame offsets outside of the signed 16-bit range not supported\"", "10", "CAHP::GPRRegClass", "CAHP::ADD", "0", "1" ]

[]

[ "<s>", "static", "void", "vax_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "*", "cum", "+=", "(", "arg", ".", "promoted_size_in_bytes", "(", ")", "+", "3", ")", "&", "~", "3", ";", "}", "</s>" ]

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

[ "vax", "3", "3" ]

[]

[ "<s>", "bool", "WebAssemblyArgumentMove", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Argument Move **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "InsertPt", "=", "EntryMBB", ".", "end", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "IsArgument", "(", "MI", ")", ")", "{", "InsertPt", "=", "MI", ";", "break", ";", "}", "}", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_range", "(", "InsertPt", ",", "EntryMBB", ".", "end", "(", ")", ")", ")", "{", "if", "(", "IsArgument", "(", "MI", ")", ")", "{", "EntryMBB", ".", "insert", "(", "InsertPt", ",", "MI", ".", "removeFromParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Argument Move **********\\n\"", "\"********** Function: \"" ]

[]

[ "<s>", "static", "void", "emit_fusion_load", "(", "rtx", "load_reg", ",", "rtx", "addis_reg", ",", "rtx", "offset", ",", "const", "char", "*", "insn_str", ")", "{", "rtx", "fuse_ops", "[", "10", "]", ";", "char", "insn_template", "[", "80", "]", ";", "fuse_ops", "[", "0", "]", "=", "load_reg", ";", "fuse_ops", "[", "1", "]", "=", "addis_reg", ";", "if", "(", "CONST_INT_P", "(", "offset", ")", "&&", "satisfies_constraint_I", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "UNSPEC", "&&", "XINT", "(", "offset", ",", "1", ")", "==", "UNSPEC_TOCREL", ")", "{", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "offset", ",", "0", ",", "0", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "offset", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "offset", ",", "0", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XEXP", "(", "offset", ",", "0", ")", ",", "1", ")", "==", "UNSPEC_TOCREL", "&&", "CONST_INT_P", "(", "XEXP", "(", "offset", ",", "1", ")", ")", ")", "{", "rtx", "tocrel_unspec", "=", "XEXP", "(", "offset", ",", "0", ")", ";", "if", "(", "TARGET_ELF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", ",", "insn_str", ")", ";", "else", "if", "(", "TARGET_XCOFF", ")", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2+%%3@l(%%1)\"", ",", "insn_str", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "fuse_ops", "[", "2", "]", "=", "XVECEXP", "(", "tocrel_unspec", ",", "0", ",", "0", ")", ";", "fuse_ops", "[", "3", "]", "=", "XEXP", "(", "offset", ",", "1", ")", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "if", "(", "TARGET_ELF", "&&", "!", "TARGET_POWERPC64", "&&", "CONSTANT_P", "(", "offset", ")", ")", "{", "sprintf", "(", "insn_template", ",", "\"%s %%0,%%2@l(%%1)\"", ",", "insn_str", ")", ";", "fuse_ops", "[", "2", "]", "=", "offset", ";", "output_asm_insn", "(", "insn_template", ",", "fuse_ops", ")", ";", "}", "else", "fatal_insn", "(", "\"Unable to generate load/store offset for fusion\"", ",", "offset", ")", ";", "return", ";", "}", "</s>" ]

[ "Emit", "a", "D-form", "load", "or", "store", "instruction", "that", "is", "the", "second", "instruction", "of", "a", "fusion", "sequence", "." ]

[ "rs6000", "10", "80", "0", "1", "\"%s %%0,%%2(%%1)\"", "2", "1", "\"%s %%0,%%2@toc@l(%%1)\"", "\"%s %%0,%%2@l(%%1)\"", "2", "0", "0", "0", "0", "1", "1", "0", "\"%s %%0,%%2+%%3@toc@l(%%1)\"", "\"%s %%0,%%2+%%3@l(%%1)\"", "2", "0", "0", "3", "1", "\"%s %%0,%%2@l(%%1)\"", "2", "\"Unable to generate load/store offset for fusion\"" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "GPRDest", "=", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "GPRSrc", "=", "ARM", "::", "GPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "if", "(", "GPRDest", "&&", "GPRSrc", ")", "{", "AddDefaultCC", "(", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "MOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ")", ")", ";", "return", ";", "}", "bool", "SPRDest", "=", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "SPRSrc", "=", "ARM", "::", "SPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "unsigned", "Opc", ";", "if", "(", "SPRDest", "&&", "SPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVS", ";", "else", "if", "(", "GPRDest", "&&", "SPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVRS", ";", "else", "if", "(", "SPRDest", "&&", "GPRSrc", ")", "Opc", "=", "ARM", "::", "VMOVSR", ";", "else", "if", "(", "ARM", "::", "DPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VMOVD", ";", "else", "if", "(", "ARM", "::", "QPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VMOVQ", ";", "else", "if", "(", "ARM", "::", "QQPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VMOVQQ", ";", "else", "if", "(", "ARM", "::", "QQQQPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "ARM", "::", "VMOVQQQQ", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ";", "MIB", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "if", "(", "Opc", "!=", "ARM", "::", "VMOVQQ", "&&", "Opc", "!=", "ARM", "::", "VMOVQQQQ", ")", "AddDefaultPred", "(", "MIB", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::GPRRegClass", "ARM::GPRRegClass", "ARM::MOVr", "ARM::SPRRegClass", "ARM::SPRRegClass", "ARM::VMOVS", "ARM::VMOVRS", "ARM::VMOVSR", "ARM::DPRRegClass", "ARM::VMOVD", "ARM::QPRRegClass", "ARM::VMOVQ", "ARM::QQPRRegClass", "ARM::VMOVQQ", "ARM::QQQQPRRegClass", "ARM::VMOVQQQQ", "\"Impossible reg-to-reg copy\"", "ARM::VMOVQQ", "ARM::VMOVQQQQ" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "AVRFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", "&&", "!", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", ")", "{", "return", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "->", "getDesc", "(", ")", ".", "isReturn", "(", ")", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "AFI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "FrameSize", "&&", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "{", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "return", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "int", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "AVR", "::", "POPRd", "&&", "Opc", "!=", "AVR", "::", "POPWRd", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "{", "break", ";", "}", "--", "MBBI", ";", "}", "if", "(", "FrameSize", ")", "{", "unsigned", "Opcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "FrameSize", ")", ")", "{", "Opcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "Opcode", "=", "AVR", "::", "SUBIWRdK", ";", "FrameSize", "=", "-", "FrameSize", ";", "}", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "AVR", "::", "R29R28", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "FrameSize", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R29R28", ",", "RegState", "::", "Kill", ")", ";", "restoreStatusRegister", "(", "MF", ",", "MBB", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "\"Can only insert epilog into returning blocks\"", "AVR", "AVR", "AVR", "AVR::POPRd", "AVR::POPWRd", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::R29R28", "AVR::R29R28", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R29R28" ]

[]

[ "<s>", "virtual", "const", "MipsSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "inline", "bool", "reg_ok_for_index_p", "(", "const_rtx", "x", ",", "bool", "strict", ")", "{", "return", "reg_ok_for_base_p", "(", "x", ",", "strict", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "X", "is", "a", "hard", "reg", "that", "can", "be", "used", "as", "an", "index", "." ]

[ "cris" ]

[]

[ "<s>", "const", "uint32_t", "*", "Cpu0RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", ")", "const", "{", "return", "CSR_O32_RegMask", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8mr", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16mr", "0", "MSP430::GR8RegClass", "MSP430::MOV8mr", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "aarch64_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_SIMD", "&&", "(", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V2DImode", "||", "mode", "==", "V2SImode", "||", "mode", "==", "V4HImode", "||", "mode", "==", "V8QImode", "||", "mode", "==", "V2SFmode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V2DFmode", "||", "mode", "==", "V1DFmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "aarch64" ]

[]

[ "<s>", "EVT", "Z80oldTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "assert", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "\"No default SetCC type for vectors!\"", ")", ";", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "Z80old", "Z80old", "\"No default SetCC type for vectors!\"", "MVT::i8" ]

[]

[ "<s>", "static", "bool", "alpha_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "decl", ")", "return", "false", ";", "return", "decl_has_samegp", "(", "decl", ")", ";", "}", "</s>" ]

[ "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ",", "nor", "can", "we", "allow", "a", "call", "to", "a", "function", "with", "a", "different", "GP", "to", "be", "optimized", "into", "a", "sibcall", "." ]

[ "alpha" ]

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "DebugLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "OR1K", "OR1K", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "static", "void", "add_to_dispatch_window", "(", "rtx_insn", "*", "insn", ")", "{", "int", "byte_len", ";", "dispatch_windows", "*", "window_list", ";", "dispatch_windows", "*", "next_list", ";", "dispatch_windows", "*", "window0_list", ";", "enum", "insn_path", "path", ";", "enum", "dispatch_group", "insn_group", ";", "bool", "insn_fits", ";", "int", "num_insn", ";", "int", "num_uops", ";", "int", "window_num", ";", "int", "insn_num_uops", ";", "int", "sum", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "<", "0", ")", "return", ";", "byte_len", "=", "min_insn_size", "(", "insn", ")", ";", "window_list", "=", "dispatch_window_list", ";", "next_list", "=", "window_list", "->", "next", ";", "path", "=", "get_insn_path", "(", "insn", ")", ";", "insn_group", "=", "get_insn_group", "(", "insn", ")", ";", "if", "(", "next_list", ")", "window_list", "=", "dispatch_window_list", "->", "next", ";", "if", "(", "path", "==", "path_single", ")", "insn_num_uops", "=", "1", ";", "else", "if", "(", "path", "==", "path_double", ")", "insn_num_uops", "=", "2", ";", "else", "insn_num_uops", "=", "(", "int", ")", "path", ";", "num_insn", "=", "window_list", "->", "num_insn", ";", "num_uops", "=", "window_list", "->", "num_uops", ";", "window_num", "=", "window_list", "->", "window_num", ";", "insn_fits", "=", "fits_dispatch_window", "(", "insn", ")", ";", "if", "(", "num_insn", ">=", "MAX_INSN", "||", "num_uops", "+", "insn_num_uops", ">", "MAX_INSN", "||", "!", "(", "insn_fits", ")", ")", "{", "window_num", "=", "~", "window_num", "&", "1", ";", "window_list", "=", "allocate_next_window", "(", "window_num", ")", ";", "}", "if", "(", "window_num", "==", "0", ")", "{", "add_insn_window", "(", "insn", ",", "window_list", ",", "insn_num_uops", ")", ";", "if", "(", "window_list", "->", "num_insn", ">=", "MAX_INSN", "&&", "insn_group", "==", "disp_branch", ")", "{", "process_end_window", "(", ")", ";", "return", ";", "}", "}", "else", "if", "(", "window_num", "==", "1", ")", "{", "window0_list", "=", "window_list", "->", "prev", ";", "sum", "=", "window0_list", "->", "window_size", "+", "window_list", "->", "window_size", ";", "if", "(", "sum", "==", "32", "||", "(", "byte_len", "+", "sum", ")", ">=", "48", ")", "{", "process_end_window", "(", ")", ";", "window_list", "=", "dispatch_window_list", ";", "}", "add_insn_window", "(", "insn", ",", "window_list", ",", "insn_num_uops", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "is_end_basic_block", "(", "insn_group", ")", ")", "{", "process_end_window", "(", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Adds", "a", "scheduled", "instruction", ",", "INSN", ",", "to", "the", "current", "dispatch", "window", ".", "If", "the", "total", "bytes", "of", "instructions", "or", "the", "number", "of", "instructions", "in", "the", "window", "exceed", "allowable", ",", "it", "allocates", "a", "new", "window", "." ]

[ "i386", "0", "1", "2", "1", "0", "1", "32", "48" ]

[]

[ "<s>", "bool", "LanaiAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OW", "->", "write32", "(", "0x15000000", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "4", "0", "0", "4", "0x15000000" ]

[]

[ "<s>", "static", "void", "s390_register_info_stdarg_fpr", "(", ")", "{", "int", "i", ";", "int", "min_fpr", ";", "int", "max_fpr", ";", "if", "(", "!", "cfun", "->", "stdarg", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "cfun", "->", "va_list_fpr_size", "||", "crtl", "->", "args", ".", "info", ".", "fprs", ">=", "FP_ARG_NUM_REG", ")", "return", ";", "min_fpr", "=", "crtl", "->", "args", ".", "info", ".", "fprs", ";", "max_fpr", "=", "min_fpr", "+", "cfun", "->", "va_list_fpr_size", "-", "1", ";", "if", "(", "max_fpr", ">=", "FP_ARG_NUM_REG", ")", "max_fpr", "=", "FP_ARG_NUM_REG", "-", "1", ";", "min_fpr", "+=", "FPR0_REGNUM", ";", "max_fpr", "+=", "FPR0_REGNUM", ";", "for", "(", "i", "=", "min_fpr", ";", "i", "<=", "max_fpr", ";", "i", "++", ")", "cfun_set_fpr_save", "(", "i", ")", ";", "}", "</s>" ]

[ "Set", "the", "bits", "in", "fpr_bitmap", "for", "FPRs", "which", "need", "to", "be", "saved", "due", "to", "stdarg", ".", "This", "is", "a", "helper", "routine", "for", "s390_register_info", "." ]

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

[]

[ "<s>", "static", "const", "char", "*", "ptrreg_to_str", "(", "int", "regno", ")", "{", "switch", "(", "regno", ")", "{", "case", "REG_X", ":", "return", "\"X\"", ";", "case", "REG_Y", ":", "return", "\"Y\"", ";", "case", "REG_Z", ":", "return", "\"Z\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "a", "pointer", "register", "name", "as", "a", "string" ]

[ "avr", "\"X\"", "\"Y\"", "\"Z\"" ]

[]

[ "<s>", "static", "rtx", "cris_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "CRIS_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

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

[ "cris" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "X86TargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "TypeSplitVector", ";", "if", "(", "ExperimentalVectorWideningLegalization", "&&", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getVectorElementType", "(", ")", "!=", "MVT", "::", "i1", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "X86", "X86", "MVT::v32i1", "1", "MVT::i1" ]

[]

[ "<s>", "static", "bool", "tilegx_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "tilegx" ]

[]

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

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

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

[]

[ "<s>", "bool", "sh_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "SPECIAL_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPUL_REG", ")", "return", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", ";", "if", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "mode", "==", "SFmode", ")", "return", "true", ";", "if", "(", "mode", "==", "V2SFmode", ")", "{", "if", "(", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "2", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V4SFmode", ")", "{", "if", "(", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "4", "==", "0", ")", "||", "GENERAL_REGISTER_P", "(", "regno", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "mode", "==", "V16SFmode", ")", "{", "if", "(", "TARGET_SHMEDIA", ")", "{", "if", "(", "FP_REGISTER_P", "(", "regno", ")", "&&", "(", "regno", "-", "FIRST_FP_REG", ")", "%", "16", "==", "0", ")", "return", "true", ";", "else", "return", "false", ";", "}", "else", "return", "regno", "==", "FIRST_XD_REG", ";", "}", "if", "(", "FP_REGISTER_P", "(", "regno", ")", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SImode", "||", "(", "(", "TARGET_SH2E", "||", "TARGET_SHMEDIA", ")", "&&", "mode", "==", "SCmode", ")", "||", "(", "(", "(", "(", "TARGET_SH4", "||", "TARGET_SH2A_DOUBLE", ")", "&&", "mode", "==", "DFmode", ")", "||", "mode", "==", "DCmode", "||", "(", "TARGET_SHMEDIA", "&&", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", "||", "mode", "==", "V2SFmode", "||", "mode", "==", "TImode", ")", ")", ")", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "1", ")", "==", "0", ")", "||", "(", "(", "TARGET_SH4", "||", "TARGET_SHMEDIA", ")", "&&", "mode", "==", "TImode", "&&", "(", "(", "regno", "-", "FIRST_FP_REG", ")", "&", "3", ")", "==", "0", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "if", "(", "XD_REGISTER_P", "(", "regno", ")", ")", "return", "mode", "==", "DFmode", ";", "if", "(", "TARGET_REGISTER_P", "(", "regno", ")", ")", "return", "(", "mode", "==", "DImode", "||", "mode", "==", "SImode", "||", "mode", "==", "PDImode", ")", ";", "if", "(", "regno", "==", "PR_REG", ")", "return", "mode", "==", "SImode", ";", "if", "(", "regno", "==", "FPSCR_REG", ")", "return", "mode", "==", "SImode", ";", "if", "(", "!", "optimize", "&&", "TARGET_SHMEDIA32", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", ")", "{", "unsigned", "int", "n", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "8", ";", "if", "(", "regno", ">=", "FIRST_GENERAL_REG", "+", "10", "-", "n", "+", "1", "&&", "regno", "<=", "FIRST_GENERAL_REG", "+", "14", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", ".", "We", "can", "allow", "any", "mode", "in", "any", "general", "register", ".", "The", "special", "registers", "only", "allow", "SImode", ".", "Do", "n't", "allow", "any", "mode", "in", "the", "PR", ".", "We", "can", "not", "hold", "DCmode", "values", "in", "the", "XD", "registers", "because", "alter_reg", "handles", "subregs", "of", "them", "incorrectly", ".", "We", "could", "work", "around", "this", "by", "spacing", "the", "XD", "registers", "like", "the", "DR", "registers", ",", "but", "this", "would", "require", "additional", "memory", "in", "every", "compilation", "to", "hold", "larger", "register", "vectors", ".", "We", "could", "hold", "SFmode", "/", "SCmode", "values", "in", "XD", "registers", ",", "but", "that", "would", "require", "a", "tertiary", "reload", "when", "reloading", "from", "/", "to", "memory", ",", "and", "a", "secondary", "reload", "to", "reload", "from", "/", "to", "general", "regs", ";", "that", "seems", "to", "be", "a", "losing", "proposition", ".", "We", "want", "to", "allow", "TImode", "FP", "regs", "so", "that", "when", "V4SFmode", "is", "loaded", "as", "TImode", ",", "it", "wo", "n't", "be", "ferried", "through", "GP", "registers", "first", "." ]

[ "sh", "2", "0", "4", "0", "16", "0", "1", "0", "3", "0", "4", "8", "10", "1", "14" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "case", "ISD", "::", "READ_REGISTER", ":", "ExpandREAD_REGISTER", "(", "N", ",", "Results", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "SREM", ":", "case", "ISD", "::", "UREM", ":", "Res", "=", "LowerREM", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "Res", "=", "LowerDivRem", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "assert", "(", "Res", ".", "getNumOperands", "(", ")", "==", "2", "&&", "\"DivRem needs two values\"", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "SDIV", ":", "assert", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "\"can only expand DIV on Windows\"", ")", ";", "return", "ExpandDIV_Windows", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ",", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ",", "Results", ")", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "Results", ".", "push_back", "(", "Res", ")", ";", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "ARM", "ARM", "\"Don't know how to custom expand this!\"", "ISD::READ_REGISTER", "ISD::BITCAST", "ISD::SRL", "ISD::SRA", "ISD::SREM", "ISD::UREM", "ISD::SDIVREM", "ISD::UDIVREM", "0", "2", "\"DivRem needs two values\"", "0", "1", "ISD::READCYCLECOUNTER", "ISD::UDIV", "ISD::SDIV", "\"can only expand DIV on Windows\"", "0", "ISD::SDIV" ]

[]

[ "<s>", "static", "bool", "rs6000_secondary_reload_simple_move", "(", "enum", "rs6000_reg_type", "to_type", ",", "enum", "rs6000_reg_type", "from_type", ",", "machine_mode", "mode", ")", "{", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_DIRECT_MOVE", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "VSX_REG_TYPE", ")", "||", "(", "to_type", "==", "VSX_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "{", "if", "(", "TARGET_POWERPC64", ")", "{", "if", "(", "size", "==", "8", ")", "return", "true", ";", "if", "(", "size", "==", "16", "&&", "TARGET_P9_VECTOR", "&&", "mode", "!=", "TDmode", ")", "return", "true", ";", "}", "if", "(", "TARGET_VSX_SMALL_INTEGER", ")", "{", "if", "(", "mode", "==", "SImode", ")", "return", "true", ";", "if", "(", "TARGET_P9_VECTOR", "&&", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", ")", "return", "true", ";", "}", "if", "(", "mode", "==", "SDmode", ")", "return", "true", ";", "}", "else", "if", "(", "TARGET_MFPGPR", "&&", "TARGET_POWERPC64", "&&", "size", "==", "8", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "FPR_REG_TYPE", ")", "||", "(", "to_type", "==", "FPR_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "else", "if", "(", "(", "size", "==", "4", "||", "(", "TARGET_POWERPC64", "&&", "size", "==", "8", ")", ")", "&&", "(", "(", "to_type", "==", "GPR_REG_TYPE", "&&", "from_type", "==", "SPR_REG_TYPE", ")", "||", "(", "to_type", "==", "SPR_REG_TYPE", "&&", "from_type", "==", "GPR_REG_TYPE", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "for", "rs6000_secondary_reload", "to", "return", "true", "if", "a", "move", "to", "a", "different", "register", "classe", "is", "really", "a", "simple", "move", "." ]

[ "rs6000", "8", "16", "8", "4", "8" ]

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RCW", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "READ_CYCLE_WIDE", ",", "DL", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "MUL", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOpWithSExt", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", ")", "return", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "FPConv", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "RISCV", "RISCV", "\"Don't know how to custom type legalize this operation!\"", "ISD::READCYCLECOUNTER", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", "MVT::i32", "MVT::i32", "MVT::Other", "RISCVISD::READ_CYCLE_WIDE", "0", "1", "2", "ISD::ADD", "ISD::SUB", "ISD::MUL", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "1", "ISD::Constant", "ISD::SHL", "ISD::SRA", "ISD::SRL", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "1", "ISD::Constant", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "ISD::Constant", "1", "ISD::Constant", "ISD::BITCAST", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "RISCVISD::FMV_X_ANYEXTW_RV64", "MVT::i64", "ISD::TRUNCATE", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "isPairedLdSt", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "paired", "load/store", "." ]

[ "AArch64", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPDi", "AArch64::LDPQi", "AArch64::LDPWi", "AArch64::LDPXi", "AArch64::STPSi", "AArch64::STPDi", "AArch64::STPQi", "AArch64::STPWi", "AArch64::STPXi" ]

[]

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

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegisterClass", "Hexagon::STriw", "0", "Hexagon::DoubleRegsRegisterClass", "Hexagon::STrid", "0", "Hexagon::PredRegsRegisterClass", "Hexagon::STriw_pred", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "static", "bool", "aarch64_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "return", "(", "mode", "==", "HFmode", "?", "true", ":", "default_scalar_mode_supported_p", "(", "mode", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "-", "return", "TRUE", "if", "MODE", "is", "HFmode", ",", "and", "punt", "to", "the", "generic", "implementation", "otherwise", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "LoongArchDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "SDLoc", "DL", "(", "Node", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "static", "bool", "sparc_promote_prototypes", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "return", "TARGET_ARCH32", "?", "true", ":", "false", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_PROMOTE_PROTOTYPES", "target", "hook", ".", "When", "a", "prototype", "says", "`", "char", "'", "or", "`", "short", "'", ",", "really", "pass", "an", "`", "int", "'", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "bool", "i386_pe_determine_dllexport_p", "(", "tree", "decl", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", "&&", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_DECLARED_INLINE_P", "(", "decl", ")", "&&", "!", "flag_keep_inline_dllexport", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"dllexport\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "DECL", "should", "be", "a", "dllexport", "'d", "object", "." ]

[ "i386", "\"dllexport\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "AArch64", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_aarch64_pcrel_adr_imm21\"", ",", "0", ",", "32", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_pcrel_adrp_imm21\"", ",", "0", ",", "32", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_add_imm12\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldst_imm12_scale1\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldst_imm12_scale2\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldst_imm12_scale4\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldst_imm12_scale8\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldst_imm12_scale16\"", ",", "10", ",", "12", ",", "0", "}", ",", "{", "\"fixup_aarch64_ldr_pcrel_imm19\"", ",", "5", ",", "19", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_movw\"", ",", "5", ",", "16", ",", "0", "}", ",", "{", "\"fixup_aarch64_pcrel_branch14\"", ",", "5", ",", "14", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_pcrel_branch19\"", ",", "5", ",", "19", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_pcrel_branch26\"", ",", "0", ",", "26", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_pcrel_call26\"", ",", "0", ",", "26", ",", "PCRelFlagVal", "}", ",", "{", "\"fixup_aarch64_tlsdesc_call\"", ",", "0", ",", "0", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "AArch64", "AArch64::NumTargetFixupKinds", "\"fixup_aarch64_pcrel_adr_imm21\"", "0", "32", "\"fixup_aarch64_pcrel_adrp_imm21\"", "0", "32", "\"fixup_aarch64_add_imm12\"", "10", "12", "0", "\"fixup_aarch64_ldst_imm12_scale1\"", "10", "12", "0", "\"fixup_aarch64_ldst_imm12_scale2\"", "10", "12", "0", "\"fixup_aarch64_ldst_imm12_scale4\"", "10", "12", "0", "\"fixup_aarch64_ldst_imm12_scale8\"", "10", "12", "0", "\"fixup_aarch64_ldst_imm12_scale16\"", "10", "12", "0", "\"fixup_aarch64_ldr_pcrel_imm19\"", "5", "19", "\"fixup_aarch64_movw\"", "5", "16", "0", "\"fixup_aarch64_pcrel_branch14\"", "5", "14", "\"fixup_aarch64_pcrel_branch19\"", "5", "19", "\"fixup_aarch64_pcrel_branch26\"", "0", "26", "\"fixup_aarch64_pcrel_call26\"", "0", "26", "\"fixup_aarch64_tlsdesc_call\"", "0", "0", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "unsigned", "HexagonMCInst", "::", "getType", "(", ")", "const", "{", "const", "uint64_t", "F", "=", "MCID", "->", "TSFlags", ";", "return", "(", "(", "F", ">>", "HexagonII", "::", "TypePos", ")", "&", "HexagonII", "::", "TypeMask", ")", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Hexagon", "Hexagon", "HexagonII::TypePos", "HexagonII::TypeMask" ]

[]

[ "<s>", "virtual", "void", "*", "getAdjustedAnalysisPointer", "(", "const", "void", "*", "ID", ")", "override", "{", "if", "(", "ID", "==", "&", "TargetTransformInfo", "::", "ID", ")", "return", "(", "TargetTransformInfo", "*", ")", "this", ";", "return", "this", ";", "}", "</s>" ]

[ "getAdjustedAnalysisPointer", "-", "This", "method", "is", "used", "when", "a", "pass", "implements", "an", "analysis", "interface", "through", "multiple", "inheritance", "." ]

[ "R600" ]

[]

[ "<s>", "static", "void", "avr_asm_named_section", "(", "const", "char", "*", "name", ",", "unsigned", "int", "flags", ",", "tree", "decl", ")", "{", "if", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "{", "addr_space_t", "as", "=", "(", "flags", "&", "AVR_SECTION_PROGMEM", ")", "/", "SECTION_MACH_DEP", ";", "const", "char", "*", "old_prefix", "=", "\".rodata\"", ";", "const", "char", "*", "new_prefix", "=", "avr_addrspace", "[", "as", "]", ".", "section_name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "sname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "default_elf_asm_named_section", "(", "sname", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "default_elf_asm_named_section", "(", "new_prefix", ",", "flags", ",", "decl", ")", ";", "return", ";", "}", "if", "(", "!", "avr_need_copy_data_p", ")", "avr_need_copy_data_p", "=", "(", "STR_PREFIX_P", "(", "name", ",", "\".data\"", ")", "||", "STR_PREFIX_P", "(", "name", ",", "\".rodata\"", ")", "||", "STR_PREFIX_P", "(", "name", ",", "\".gnu.linkonce.d\"", ")", ")", ";", "if", "(", "!", "avr_need_clear_bss_p", ")", "avr_need_clear_bss_p", "=", "STR_PREFIX_P", "(", "name", ",", "\".bss\"", ")", ";", "default_elf_asm_named_section", "(", "name", ",", "flags", ",", "decl", ")", ";", "}", "</s>" ]

[ "Track", "need", "of", "__do_clear_bss", ",", "__do_copy_data", "for", "named", "sections", "." ]

[ "avr", "\".rodata\"", "\".data\"", "\".rodata\"", "\".gnu.linkonce.d\"", "\".bss\"" ]

[]

[ "<s>", "static", "void", "riscv_save_restore_reg", "(", "enum", "machine_mode", "mode", ",", "int", "regno", ",", "HOST_WIDE_INT", "offset", ",", "riscv_save_restore_fn", "fn", ")", "{", "rtx", "mem", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "fn", "(", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ",", "mem", ")", ";", "}", "</s>" ]

[ "Use", "FN", "to", "save", "or", "restore", "register", "REGNO", ".", "MODE", "is", "the", "register", "'s", "mode", "and", "OFFSET", "is", "the", "offset", "of", "its", "save", "slot", "from", "the", "current", "stack", "pointer", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "SystemZLDCleanup", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "F", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MF", "=", "&", "F", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "F", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "MFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "2", "0" ]

[]

[ "<s>", "void", "rs6000_emit_sCOND", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "condition_rtx", ";", "machine_mode", "op_mode", ";", "enum", "rtx_code", "cond_code", ";", "rtx", "result", "=", "operands", "[", "0", "]", ";", "condition_rtx", "=", "rs6000_generate_compare", "(", "operands", "[", "1", "]", ",", "mode", ")", ";", "cond_code", "=", "GET_CODE", "(", "condition_rtx", ")", ";", "if", "(", "cond_code", "==", "NE", "||", "cond_code", "==", "GE", "||", "cond_code", "==", "LE", "||", "cond_code", "==", "GEU", "||", "cond_code", "==", "LEU", "||", "cond_code", "==", "ORDERED", "||", "cond_code", "==", "UNGE", "||", "cond_code", "==", "UNLE", ")", "{", "rtx", "not_result", "=", "gen_reg_rtx", "(", "CCEQmode", ")", ";", "rtx", "not_op", ",", "rev_cond_rtx", ";", "machine_mode", "cc_mode", ";", "cc_mode", "=", "GET_MODE", "(", "XEXP", "(", "condition_rtx", ",", "0", ")", ")", ";", "rev_cond_rtx", "=", "gen_rtx_fmt_ee", "(", "rs6000_reverse_condition", "(", "cc_mode", ",", "cond_code", ")", ",", "SImode", ",", "XEXP", "(", "condition_rtx", ",", "0", ")", ",", "const0_rtx", ")", ";", "not_op", "=", "gen_rtx_COMPARE", "(", "CCEQmode", ",", "rev_cond_rtx", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "not_result", ",", "not_op", ")", ")", ";", "condition_rtx", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "not_result", ",", "const0_rtx", ")", ";", "}", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ")", ";", "if", "(", "op_mode", "==", "VOIDmode", ")", "op_mode", "=", "GET_MODE", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ")", ";", "if", "(", "TARGET_POWERPC64", "&&", "(", "op_mode", "==", "DImode", "||", "FLOAT_MODE_P", "(", "mode", ")", ")", ")", "{", "PUT_MODE", "(", "condition_rtx", ",", "DImode", ")", ";", "convert_move", "(", "result", ",", "condition_rtx", ",", "0", ")", ";", "}", "else", "{", "PUT_MODE", "(", "condition_rtx", ",", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "result", ",", "condition_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "RTL", "for", "an", "sCOND", "pattern", "." ]

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

[]

[ "<s>", "static", "bool", "or1k_frame_pointer_required", "(", ")", "{", "return", "(", "crtl", "->", "accesses_prior_frames", ")", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_FRAME_POINTER_REQUIRED", ".", "Returns", "true", "if", "the", "current", "function", "must", "use", "a", "frame", "pointer", "." ]

[ "or1k" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "emitFunctionStart", "(", "MF", ")", ";", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "O", "<<", "\"\\t\"", ";", "printMachineInstruction", "(", "II", ")", ";", "}", "O", "<<", "'\\n'", ";", "}", "emitFunctionEnd", "(", "MF", ")", ";", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\"\\t\"" ]

[]

[ "<s>", "unsigned", "CJGMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "return", "CTX", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Constant", ")", "{", "return", "cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", "->", "getValue", "(", ")", ";", "}", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", "&&", "\"unknown MCExpr kind\"", ")", ";", "CJG", "::", "Fixups", "FixupKind", "=", "CJG", "::", "Fixups", "(", "0", ")", ";", "switch", "(", "cast", "<", "MCSymbolRefExpr", ">", "(", "Expr", ")", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown fixup kind!\"", ")", ";", "case", "MCSymbolRefExpr", "::", "VK_None", ":", "FixupKind", "=", "CJG", "::", "fixup_CJG_32", ";", "break", ";", "}", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "FixupKind", ")", ")", ")", ";", "return", "0", ";", "}", "llvm_unreachable", "(", "\"Unhandled expression!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "CJG", "CJG", "\"unknown MCExpr kind\"", "CJG::Fixups", "CJG::Fixups", "0", "\"Unknown fixup kind!\"", "CJG::fixup_CJG_32", "0", "0", "\"Unhandled expression!\"", "0" ]

[]

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

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

[ "MSP430" ]

[]

[ "<s>", "static", "void", "mips_avoid_hazard", "(", "rtx_insn", "*", "after", ",", "rtx_insn", "*", "insn", ",", "int", "*", "hilo_delay", ",", "rtx", "*", "delayed_reg", ",", "rtx", "lo_reg", ",", "bool", "*", "fs_delay", ")", "{", "rtx", "pattern", ",", "set", ";", "int", "nops", ",", "ninsns", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pattern", ")", ">=", "0", ")", "cfun", "->", "machine", "->", "all_noreorder_p", "=", "false", ";", "ninsns", "=", "get_attr_length", "(", "insn", ")", "/", "4", ";", "if", "(", "ninsns", "==", "0", ")", "return", ";", "if", "(", "*", "hilo_delay", "<", "2", "&&", "reg_set_p", "(", "lo_reg", ",", "pattern", ")", ")", "nops", "=", "2", "-", "*", "hilo_delay", ";", "else", "if", "(", "*", "delayed_reg", "!=", "0", "&&", "reg_referenced_p", "(", "*", "delayed_reg", ",", "pattern", ")", ")", "nops", "=", "1", ";", "else", "if", "(", "*", "fs_delay", "&&", "get_attr_can_delay", "(", "insn", ")", "==", "CAN_DELAY_NO", "&&", "GET_CODE", "(", "PATTERN", "(", "after", ")", ")", "!=", "SEQUENCE", "&&", "GET_CODE", "(", "pattern", ")", "!=", "ASM_INPUT", "&&", "asm_noperands", "(", "pattern", ")", "<", "0", ")", "nops", "=", "1", ";", "else", "if", "(", "TUNE_P6600", "&&", "TARGET_CB_MAYBE", "&&", "!", "optimize_size", "&&", "(", "(", "mips_classify_branch_p6600", "(", "after", ")", "==", "UC_BALC", "&&", "mips_classify_branch_p6600", "(", "insn", ")", "==", "UC_OTHER", ")", "||", "(", "mips_classify_branch_p6600", "(", "insn", ")", "==", "UC_BALC", "&&", "mips_classify_branch_p6600", "(", "after", ")", "==", "UC_OTHER", ")", ")", ")", "nops", "=", "1", ";", "else", "nops", "=", "0", ";", "*", "hilo_delay", "+=", "nops", ";", "rtx_insn", "*", "real_after", "=", "after", ";", "if", "(", "real_after", "&&", "nops", "&&", "CALL_P", "(", "real_after", ")", ")", "while", "(", "real_after", "&&", "(", "NOTE_P", "(", "NEXT_INSN", "(", "real_after", ")", ")", "||", "BARRIER_P", "(", "NEXT_INSN", "(", "real_after", ")", ")", ")", ")", "real_after", "=", "NEXT_INSN", "(", "real_after", ")", ";", "while", "(", "nops", "--", ">", "0", ")", "emit_insn_after", "(", "gen_hazard_nop", "(", ")", ",", "real_after", ")", ";", "*", "hilo_delay", "+=", "ninsns", ";", "*", "delayed_reg", "=", "0", ";", "*", "fs_delay", "=", "false", ";", "if", "(", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "if", "(", "TUNE_P6600", "&&", "!", "optimize_size", "&&", "TARGET_CB_MAYBE", "&&", "mips_classify_branch_p6600", "(", "insn", ")", "==", "UC_OTHER", ")", "*", "fs_delay", "=", "true", ";", "break", ";", "case", "HAZARD_FORBIDDEN_SLOT", ":", "if", "(", "TARGET_CB_MAYBE", ")", "*", "fs_delay", "=", "true", ";", "break", ";", "case", "HAZARD_HILO", ":", "*", "hilo_delay", "=", "0", ";", "break", ";", "case", "HAZARD_DELAY", ":", "set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "*", "delayed_reg", "=", "SET_DEST", "(", "set", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Subroutine", "of", "mips_reorg", ".", "If", "there", "is", "a", "hazard", "between", "INSN", "and", "a", "previous", "instruction", ",", "avoid", "it", "by", "inserting", "nops", "after", "instruction", "AFTER", ".", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "describe", "the", "hazards", "that", "apply", "at", "this", "point", ".", "If", "*", "DELAYED_REG", "is", "non-null", ",", "INSN", "must", "wait", "a", "cycle", "before", "using", "the", "value", "of", "that", "register", ".", "*", "HILO_DELAY", "counts", "the", "number", "of", "instructions", "since", "the", "last", "hilo", "hazard", "(", "that", "is", ",", "the", "number", "of", "instructions", "since", "the", "last", "mflo", "or", "mfhi", ")", ".", "After", "inserting", "nops", "for", "INSN", ",", "update", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "for", "the", "next", "instruction", ".", "LO_REG", "is", "an", "rtx", "for", "the", "LO", "register", ",", "used", "in", "dependence", "checking", "." ]

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

[]

[ "<s>", "bool", "ProtectSpillSupportPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "const", "X86InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "X86InstrInfo", "*", ">", "(", "Func", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "modified", "=", "false", ";", "SmallVector", "<", "CJEItem", ",", "8", ">", "worklist", ";", "for", "(", "auto", "MBBI", "=", "Func", ".", "begin", "(", ")", ",", "MBBE", "=", "Func", ".", "end", "(", ")", ";", "MBBI", "!=", "MBBE", ";", "++", "MBBI", ")", "{", "for", "(", "auto", "MI", "=", "MBBI", "->", "begin", "(", ")", ",", "ME", "=", "MBBI", "->", "end", "(", ")", ";", "MI", "!=", "ME", ";", "++", "MI", ")", "{", "CJEItem", "item", ";", "if", "(", "isCJEOpcode", "(", "MI", "->", "getOpcode", "(", ")", ",", "item", ".", "NativeOpcode", ",", "item", ".", "isFrameSetup", ")", ")", "{", "item", ".", "MI", "=", "MI", ";", "item", ".", "isEFLAGSlive", "=", "TII", "->", "isRegLiveAtMI", "(", "X86", "::", "EFLAGS", ",", "MI", ")", ";", "item", ".", "isRAXlive", "=", "isRAXLiveAtMI", "(", "MI", ")", ";", "worklist", ".", "push_back", "(", "item", ")", ";", "}", "}", "}", "modified", "=", "!", "worklist", ".", "empty", "(", ")", ";", "while", "(", "!", "worklist", ".", "empty", "(", ")", ")", "{", "CJEItem", "item", "=", "worklist", ".", "pop_back_val", "(", ")", ";", "transformCJE", "(", "item", ".", "MI", ",", "item", ".", "NativeOpcode", ",", "item", ".", "isFrameSetup", ",", "item", ".", "isEFLAGSlive", ",", "item", ".", "isRAXlive", ")", ";", "}", "return", "modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "8", "X86::EFLAGS" ]

[]

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

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

[ "Mips", "\"Mips OptimizePICCall\"" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "StackAlignment", "(", "16", ")", ",", "DarwinDirective", "(", "PPC", "::", "DIR_NONE", ")", ",", "IsGigaProcessor", "(", "false", ")", ",", "Has64BitSupport", "(", "false", ")", ",", "Use64BitRegs", "(", "false", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "HasAltivec", "(", "false", ")", ",", "HasFSQRT", "(", "false", ")", ",", "HasSTFIWX", "(", "false", ")", ",", "HasLazyResolverStubs", "(", "false", ")", ",", "IsJITCodeModel", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic\"", ";", "if", "(", "CPUName", "==", "\"generic\"", ")", "CPUName", "=", "GetCurrentPowerPCCPU", "(", ")", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "is64Bit", ")", "{", "Has64BitSupport", "=", "true", ";", "Use64BitRegs", "=", "true", ";", "}", "if", "(", "use64BitRegs", "(", ")", "&&", "!", "has64BitSupport", "(", ")", ")", "Use64BitRegs", "=", "false", ";", "if", "(", "isDarwin", "(", ")", ")", "HasLazyResolverStubs", "=", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "16", "PPC::DIR_NONE", "PPC", "\"generic\"", "\"generic\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "ARMRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "ARM", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "GPRRegClassID", ":", "case", "GPRwithAPSRRegClassID", ":", "case", "GPRnopcRegClassID", ":", "case", "rGPRRegClassID", ":", "case", "GPRspRegClassID", ":", "case", "tGPR_and_tcGPRRegClassID", ":", "case", "tcGPRRegClassID", ":", "case", "tGPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "GPRRegBankID", ")", ";", "case", "HPRRegClassID", ":", "case", "SPR_8RegClassID", ":", "case", "SPRRegClassID", ":", "case", "DPR_8RegClassID", ":", "case", "DPRRegClassID", ":", "case", "QPRRegClassID", ":", "return", "getRegBank", "(", "ARM", "::", "FPRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported register kind\"", ")", ";", "}", "llvm_unreachable", "(", "\"Switch should handle all register classes\"", ")", ";", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "ARM", "ARM", "ARM", "ARM::GPRRegBankID", "ARM::FPRRegBankID", "\"Unsupported register kind\"", "\"Switch should handle all register classes\"" ]

[]

[ "<s>", "static", "void", "bpf_option_override", "(", "void", ")", "{", "init_machine_status", "=", "bpf_init_machine_status", ";", "if", "(", "TARGET_BPF_CORE", "&&", "!", "btf_debuginfo_p", "(", ")", ")", "error", "(", "\"BPF CO-RE requires BTF debugging information, use %<-gbtf%>\"", ")", ";", "if", "(", "TARGET_BPF_CORE", ")", "write_symbols", "|=", "BTF_WITH_CORE_DEBUG", ";", "if", "(", "flag_lto", "&&", "TARGET_BPF_CORE", ")", "sorry", "(", "\"BPF CO-RE does not support LTO\"", ")", ";", "if", "(", "btf_debuginfo_p", "(", ")", "&&", "!", "(", "target_flags_explicit", "&", "MASK_BPF_CORE", ")", ")", "{", "target_flags", "|=", "MASK_BPF_CORE", ";", "write_symbols", "|=", "BTF_WITH_CORE_DEBUG", ";", "}", "if", "(", "bpf_has_jmpext", "==", "-", "1", ")", "bpf_has_jmpext", "=", "(", "bpf_isa", ">=", "ISA_V2", ")", ";", "if", "(", "bpf_has_alu32", "==", "-", "1", ")", "bpf_has_alu32", "=", "(", "bpf_isa", ">=", "ISA_V3", ")", ";", "if", "(", "bpf_has_jmp32", "==", "-", "1", ")", "bpf_has_jmp32", "=", "(", "bpf_isa", ">=", "ISA_V3", ")", ";", "if", "(", "flag_stack_protect", ")", "{", "inform", "(", "input_location", ",", "\"%<-fstack-protector%> does not work \"", "\"on this architecture\"", ")", ";", "flag_stack_protect", "=", "0", ";", "}", "}", "</s>" ]

[ "Override", "options", "and", "do", "some", "other", "initialization", "." ]

[ "bpf", "\"BPF CO-RE requires BTF debugging information, use %<-gbtf%>\"", "\"BPF CO-RE does not support LTO\"", "1", "1", "1", "\"%<-fstack-protector%> does not work \"", "\"on this architecture\"", "0" ]

[]

[ "<s>", "bool", "ix86_expand_fp_movcc", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "tmp", ",", "compare_op", ";", "rtx", "op0", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "1", ")", ";", "if", "(", "SSE_FLOAT_MODE_SSEMATH_OR_HF_P", "(", "mode", ")", ")", "{", "machine_mode", "cmode", ";", "cmode", "=", "GET_MODE", "(", "op0", ")", ";", "if", "(", "cmode", "==", "VOIDmode", ")", "cmode", "=", "GET_MODE", "(", "op1", ")", ";", "if", "(", "cmode", "!=", "mode", ")", "return", "false", ";", "code", "=", "ix86_prepare_sse_fp_compare_args", "(", "operands", "[", "0", "]", ",", "code", ",", "&", "op0", ",", "&", "op1", ")", ";", "if", "(", "code", "==", "UNKNOWN", ")", "return", "false", ";", "if", "(", "ix86_expand_sse_fp_minmax", "(", "operands", "[", "0", "]", ",", "code", ",", "op0", ",", "op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", "return", "true", ";", "tmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "code", ",", "op0", ",", "op1", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "tmp", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "return", "true", ";", "}", "if", "(", "GET_MODE", "(", "op0", ")", "==", "TImode", "||", "(", "GET_MODE", "(", "op0", ")", "==", "DImode", "&&", "!", "TARGET_64BIT", ")", ")", "return", "false", ";", "compare_op", "=", "ix86_expand_compare", "(", "code", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "fcmov_comparison_operator", "(", "compare_op", ",", "VOIDmode", ")", ")", "{", "tmp", "=", "gen_reg_rtx", "(", "QImode", ")", ";", "ix86_expand_setcc", "(", "tmp", ",", "code", ",", "op0", ",", "op1", ")", ";", "compare_op", "=", "ix86_expand_compare", "(", "NE", ",", "tmp", ",", "const0_rtx", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IF_THEN_ELSE", "(", "mode", ",", "compare_op", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "conditional", "move", ".", "Return", "true", "if", "successful", "." ]

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

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "{", "PM", "->", "add", "(", "createHexagonFixupHwLoops", "(", ")", ")", ";", "}", "PM", "->", "add", "(", "createHexagonExpandPredSpillCode", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "PM", "->", "add", "(", "createHexagonSplitTFRCondSets", "(", "getHexagonTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "X86Operand", "*", "CreateMem", "(", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "X86Operand", "*", "Res", "=", "new", "X86Operand", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "return", "Res", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86", "X86" ]

[]