Datasets:

---

docz1105

/

ComBack

like 9

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

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

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

[]

[ "<s>", "static", "enum", "machine_mode", "ix86_mpx_bound_mode", "(", ")", "{", "if", "(", "!", "TARGET_MPX", ")", "{", "if", "(", "flag_check_pointer_bounds", ")", "warning", "(", "0", ",", "\"Pointer Checker requires MPX support on this target.\"", "\" Use -mmpx options to enable MPX.\"", ")", ";", "return", "VOIDmode", ";", "}", "return", "BNDmode", ";", "}", "</s>" ]

[ "Return", "mode", "to", "be", "used", "for", "bounds", "or", "VOIDmode", "if", "bounds", "are", "not", "supported", "." ]

[ "i386", "0", "\"Pointer Checker requires MPX support on this target.\"", "\" Use -mmpx options to enable MPX.\"" ]

[]

[ "<s>", "void", "aarch64_general_init_builtins", "(", "void", ")", "{", "aarch64_init_fpsr_fpcr_builtins", "(", ")", ";", "aarch64_init_fp16_types", "(", ")", ";", "aarch64_init_bf16_types", "(", ")", ";", "{", "aarch64_simd_switcher", "simd", ";", "aarch64_init_simd_builtins", "(", ")", ";", "}", "aarch64_init_crc32_builtins", "(", ")", ";", "aarch64_init_builtin_rsqrt", "(", ")", ";", "aarch64_init_rng_builtins", "(", ")", ";", "aarch64_init_data_intrinsics", "(", ")", ";", "tree", "ftype_jcvt", "=", "build_function_type_list", "(", "intSI_type_node", ",", "double_type_node", ",", "NULL", ")", ";", "aarch64_builtin_decls", "[", "AARCH64_JSCVT", "]", "=", "aarch64_general_add_builtin", "(", "\"__builtin_aarch64_jcvtzs\"", ",", "ftype_jcvt", ",", "AARCH64_JSCVT", ")", ";", "if", "(", "!", "TARGET_ILP32", ")", "aarch64_init_pauth_hint_builtins", "(", ")", ";", "if", "(", "TARGET_TME", ")", "aarch64_init_tme_builtins", "(", ")", ";", "if", "(", "TARGET_MEMTAG", ")", "aarch64_init_memtag_builtins", "(", ")", ";", "}", "</s>" ]

[ "Initialize", "all", "builtins", "in", "the", "AARCH64_BUILTIN_GENERAL", "group", "." ]

[ "aarch64", "\"__builtin_aarch64_jcvtzs\"" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "else", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "GetGBRO", ")", ",", "TempReg", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "PowerPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC", "PPC::GPRCRegClass", "PPC::GetGBRO", "PPC::UpdateGBR", "PPC", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "static", "bool", "tryAddingSymbolicOperand", "(", "int64_t", "Value", ",", "bool", "isBranch", ",", "uint64_t", "Address", ",", "uint64_t", "Offset", ",", "uint64_t", "Width", ",", "MCInst", "&", "MI", ",", "const", "MCDisassembler", "*", "Decoder", ")", "{", "return", "Decoder", "->", "tryAddingSymbolicOperand", "(", "MI", ",", "Value", ",", "Address", ",", "isBranch", ",", "Offset", ",", "Width", ")", ";", "}", "</s>" ]

[ "Try", "to", "add", "a", "symbolic", "operand", "instead", "of", "Value", "to", "the", "MCInst", "." ]

[ "Sparc" ]

[]

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

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "AArch64FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "int", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "Amount", "=", "RoundUpToAlignment", "(", "Amount", ",", "Align", ")", ";", "if", "(", "!", "IsDestroy", ")", "Amount", "=", "-", "Amount", ";", "if", "(", "CalleePopAmount", "==", "0", ")", "{", "assert", "(", "Amount", ">", "-", "0xffffff", "&&", "Amount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "Amount", ",", "TII", ")", ";", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "assert", "(", "CalleePopAmount", "<", "0xffffff", "&&", "\"call frame too large\"", ")", ";", "emitFrameOffset", "(", "MBB", ",", "I", ",", "DL", ",", "AArch64", "::", "SP", ",", "AArch64", "::", "SP", ",", "-", "CalleePopAmount", ",", "TII", ")", ";", "}", "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", ")", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "1", "0", "0", "0", "0xffffff", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP", "0", "0xffffff", "\"call frame too large\"", "AArch64::SP", "AArch64::SP" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'c'", ":", "case", "'P'", ":", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'Q'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isLittleEndian", "(", ")", ")", "break", ";", "case", "'R'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isBigEndian", "(", ")", ")", "break", ";", "case", "'H'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "ARM", "ARM", "0", "1", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "AArch64SpeculationHardening", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ")", "return", "false", ";", "MisspeculatingTaintReg", "=", "AArch64", "::", "X16", ";", "MisspeculatingTaintReg32Bit", "=", "AArch64", "::", "W16", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "RegsNeedingCSDBBeforeUse", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "RegsAlreadyMasked", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UseControlFlowSpeculationBarrier", "=", "functionUsesHardeningRegister", "(", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "if", "(", "HardenLoads", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64SpeculationHardening - automatic insertion of \"", "\"SpeculationSafeValue intrinsics *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "slhLoads", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64SpeculationHardening - track control flow *****\\n\"", ")", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "2", ">", "EntryBlocks", ";", "EntryBlocks", ".", "push_back", "(", "&", "MF", ".", "front", "(", ")", ")", ";", "for", "(", "const", "LandingPadInfo", "&", "LPI", ":", "MF", ".", "getLandingPads", "(", ")", ")", "EntryBlocks", ".", "push_back", "(", "LPI", ".", "LandingPadBlock", ")", ";", "for", "(", "auto", "Entry", ":", "EntryBlocks", ")", "insertSPToRegTaintPropagation", "(", "Entry", ",", "Entry", "->", "SkipPHIsLabelsAndDebug", "(", "Entry", "->", "begin", "(", ")", ")", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "instrumentControlFlow", "(", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64SpeculationHardening - Lowering \"", "\"SpeculationSafeValue Pseudos *****\\n\"", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "lowerSpeculationSafeValuePseudos", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64::X16", "AArch64::W16", "\"***** AArch64SpeculationHardening - automatic insertion of \"", "\"SpeculationSafeValue intrinsics *****\\n\"", "\"***** AArch64SpeculationHardening - track control flow *****\\n\"", "2", "\"***** AArch64SpeculationHardening - Lowering \"", "\"SpeculationSafeValue Pseudos *****\\n\"" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "SelectFrameIndex", "(", "N", ")", ";", "case", "ISD", "::", "BITCAST", ":", "return", "SelectBitcast", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "SelectIntrinsicWChain", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "if", "(", "HST", "->", "useHVXOps", "(", ")", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "SelectHvxShuffle", "(", "N", ")", ";", "case", "HexagonISD", "::", "VROR", ":", "return", "SelectHvxRor", "(", "N", ")", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "ISD::Constant", "ISD::ConstantFP", "ISD::FrameIndex", "ISD::BITCAST", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_W_CHAIN", "ISD::INTRINSIC_WO_CHAIN", "ISD::VECTOR_SHUFFLE", "HexagonISD::VROR" ]

[]

[ "<s>", "static", "const", "char", "*", "arm_invalid_binary_op", "(", "int", "op", "ATTRIBUTE_UNUSED", ",", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "if", "(", "element_mode", "(", "type1", ")", "==", "BFmode", "||", "element_mode", "(", "type2", ")", "==", "BFmode", ")", "return", "N_", "(", "\"operation not permitted on type %<bfloat16_t%>\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Return", "the", "diagnostic", "message", "string", "if", "the", "binary", "operation", "OP", "is", "not", "permitted", "on", "TYPE1", "and", "TYPE2", ",", "NULL", "otherwise", "." ]

[ "arm", "\"operation not permitted on type %<bfloat16_t%>\"" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "compute_current_alignment", "(", "unsigned", "HOST_WIDE_INT", "base_align", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "offset", "==", "0", ")", "return", "base_align", ";", "return", "min", "(", "base_align", ",", "offset", "&", "-", "offset", ")", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "of", "pointer+OFFSET", "where", "the", "original", "alignment", "of", "pointer", "was", "BASE_ALIGN", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getSqrtResultForDenormInput", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "Op", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "arc_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V2HImode", ":", "return", "TARGET_PLUS_DMPY", ";", "case", "E_V4HImode", ":", "case", "E_V2SImode", ":", "return", "TARGET_PLUS_QMACW", ";", "case", "E_V4SImode", ":", "case", "E_V8HImode", ":", "return", "TARGET_SIMD_SET", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

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

[ "arc" ]

[]

[ "<s>", "static", "bool", "sparc_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_ARCH32", ")", "return", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TFmode", "||", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "8", ")", ")", ";", "else", "return", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "int_size_in_bytes", "(", "type", ")", ">", "32", ")", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_RETURN_IN_MEMORY", "target", "hook", ".", "Specify", "whether", "to", "return", "the", "return", "value", "in", "memory", "." ]

[ "sparc", "8", "32" ]

[]

[ "<s>", "virtual", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectDFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", "&&", "!", "SelectAFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectXFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "case", "'o'", ":", "if", "(", "!", "SelectDFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", "&&", "!", "SelectAFormAddr", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "{", "Op0", "=", "Op", ";", "Op1", "=", "getSmallIPtrImm", "(", "0", ")", ";", "}", "break", ";", "case", "'v'", ":", "assert", "(", "0", "&&", "\"InlineAsmMemoryOperand 'v' constraint not handled.\"", ")", ";", "SelectAddrIdxOnly", "(", "Op", ",", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "0", "0", "\"InlineAsmMemoryOperand 'v' constraint not handled.\"" ]

[]

[ "<s>", "static", "bool", "c6x_scalar_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "ALL_FIXED_POINT_MODE_P", "(", "mode", ")", "&&", "GET_MODE_PRECISION", "(", "mode", ")", "<=", "2", "*", "BITS_PER_WORD", ")", "return", "true", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCALAR_MODE_SUPPORTED_P", "." ]

[ "c6x", "2" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitEndOfAsmFile", "(", "Module", "&", "M", ")", "{", "if", "(", "M", ".", "empty", "(", ")", "&&", "TOCDataGlobalVars", ".", "empty", "(", ")", ")", "return", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTOCBaseSection", "(", ")", ")", ";", "PPCTargetStreamer", "*", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "for", "(", "auto", "&", "I", ":", "TOC", ")", "{", "MCSectionXCOFF", "*", "TCEntry", ";", "if", "(", "I", ".", "first", ".", "second", "==", "MCSymbolRefExpr", "::", "VariantKind", "::", "VK_PPC_AIX_TLSGDM", ")", "{", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Prefix", "=", "\".\"", ";", "Name", "+=", "Prefix", ";", "Name", "+=", "I", ".", "first", ".", "first", "->", "getName", "(", ")", ";", "MCSymbol", "*", "S", "=", "OutContext", ".", "getOrCreateSymbol", "(", "Name", ")", ";", "TCEntry", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForTOCEntry", "(", "S", ",", "TM", ")", ")", ";", "}", "else", "{", "TCEntry", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "getObjFileLowering", "(", ")", ".", "getSectionForTOCEntry", "(", "I", ".", "first", ".", "first", ",", "TM", ")", ")", ";", "}", "OutStreamer", "->", "SwitchSection", "(", "TCEntry", ")", ";", "OutStreamer", "->", "emitLabel", "(", "I", ".", "second", ")", ";", "if", "(", "TS", "!=", "nullptr", ")", "TS", "->", "emitTCEntry", "(", "*", "I", ".", "first", ".", "first", ",", "I", ".", "first", ".", "second", ")", ";", "}", "for", "(", "const", "auto", "*", "GV", ":", "TOCDataGlobalVars", ")", "emitGlobalVariableHelper", "(", "GV", ")", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "end", "of", "their", "file", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "128", "\".\"" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "struct", "s390_address", "ad", ";", "memset", "(", "&", "ad", ",", "0", ",", "sizeof", "(", "s390_address", ")", ")", ";", "if", "(", "s390_loadrelative_operand_p", "(", "addr", ",", "NULL", ",", "NULL", ")", ")", "{", "if", "(", "!", "TARGET_Z10", ")", "{", "output_operand_lossage", "(", "\"symbolic memory references are \"", "\"only supported on z10 or later\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "addr", ")", ";", "return", ";", "}", "if", "(", "!", "s390_decompose_address", "(", "addr", ",", "&", "ad", ")", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "(", "ad", ".", "indx", "&&", "!", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "ad", ".", "indx", ")", ")", ")", ")", "output_operand_lossage", "(", "\"cannot decompose address\"", ")", ";", "if", "(", "ad", ".", "disp", ")", "output_addr_const", "(", "file", ",", "ad", ".", "disp", ")", ";", "else", "fprintf", "(", "file", ",", "\"0\"", ")", ";", "if", "(", "ad", ".", "base", "&&", "ad", ".", "indx", ")", "fprintf", "(", "file", ",", "\"(%s,%s)\"", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "indx", ")", "]", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "else", "if", "(", "ad", ".", "base", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "s390", "0", "\"symbolic memory references are \"", "\"only supported on z10 or later\"", "\"cannot decompose address\"", "\"0\"", "\"(%s,%s)\"", "\"(%s)\"" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", "||", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewOp0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_W_X_RV64", ",", "DL", ",", "MVT", "::", "f32", ",", "NewOp0", ")", ";", "return", "FPConv", ";", "}", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "assert", "(", "Subtarget", ".", "hasStdExtP", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "return", "lowerVectorExtract", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "assert", "(", "Subtarget", ".", "hasStdExtP", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "return", "lowerVectorInsert", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "assert", "(", "Subtarget", ".", "hasStdExtP", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "return", "lowerVectorBuild", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::GlobalTLSAddress", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::BITCAST", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i64", "RISCVISD::FMV_W_X_RV64", "MVT::f32", "ISD::EXTRACT_VECTOR_ELT", "\"Unexpected custom legalisation\"", "ISD::INSERT_VECTOR_ELT", "\"Unexpected custom legalisation\"", "ISD::BUILD_VECTOR", "\"Unexpected custom legalisation\"" ]

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "body", ",", "rtx_insn", "*", "insn", ")", "{", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_NONE_0HIT", ":", "if", "(", "cc_status", ".", "value1", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "cc_status", ".", "value1", ")", ")", "cc_status", ".", "value1", "=", "0", ";", "break", ";", "case", "CC_SET_ZN", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", "|", "CC_NO_CARRY", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_SET_ZNV", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_NO_CARRY", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_COMPARE", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "body", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

[ "v850", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "MachineInstr", "*", "RISCVInstrInfo", "::", "commuteInstructionImpl", "(", "MachineInstr", "&", "MI", ",", "bool", "NewMI", ",", "unsigned", "OpIdx1", ",", "unsigned", "OpIdx2", ")", "const", "{", "auto", "cloneIfNew", "=", "[", "NewMI", "]", "(", "MachineInstr", "&", "MI", ")", "->", "MachineInstr", "&", "{", "if", "(", "NewMI", ")", "return", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "MI", ")", ";", "return", "MI", ";", "}", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "CASE_VFMA_SPLATS", "(", "FMACC", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FMADD", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FMSAC", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FMSUB", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FNMACC", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FNMADD", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FNMSAC", ")", ":", "case", "CASE_VFMA_SPLATS", "(", "FNMSUB", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FMACC", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FMSAC", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FNMACC", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FNMSAC", ",", "VV", ")", ":", "{", "assert", "(", "(", "OpIdx1", "==", "1", "||", "OpIdx2", "==", "1", ")", "&&", "\"Unexpected opcode index\"", ")", ";", "assert", "(", "(", "OpIdx1", "==", "3", "||", "OpIdx2", "==", "3", ")", "&&", "\"Unexpected opcode index\"", ")", ";", "unsigned", "Opc", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode\"", ")", ";", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FMACC", ",", "FMADD", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FMADD", ",", "FMACC", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FMSAC", ",", "FMSUB", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FMSUB", ",", "FMSAC", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FNMACC", ",", "FNMADD", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FNMADD", ",", "FNMACC", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FNMSAC", ",", "FNMSUB", ")", "CASE_VFMA_CHANGE_OPCODE_SPLATS", "(", "FNMSUB", ",", "FNMSAC", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FMACC", ",", "FMADD", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FMSAC", ",", "FMSUB", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FNMACC", ",", "FNMADD", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FNMSAC", ",", "FNMSUB", ",", "VV", ")", "}", "auto", "&", "WorkingMI", "=", "cloneIfNew", "(", "MI", ")", ";", "WorkingMI", ".", "setDesc", "(", "get", "(", "Opc", ")", ")", ";", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "WorkingMI", ",", "false", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FMADD", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FMSUB", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FNMADD", ",", "VV", ")", ":", "case", "CASE_VFMA_OPCODE_LMULS", "(", "FNMSUB", ",", "VV", ")", ":", "{", "assert", "(", "(", "OpIdx1", "==", "1", "||", "OpIdx2", "==", "1", ")", "&&", "\"Unexpected opcode index\"", ")", ";", "if", "(", "OpIdx1", "==", "3", "||", "OpIdx2", "==", "3", ")", "{", "unsigned", "Opc", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode\"", ")", ";", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FMADD", ",", "FMACC", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FMSUB", ",", "FMSAC", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FNMADD", ",", "FNMACC", ",", "VV", ")", "CASE_VFMA_CHANGE_OPCODE_LMULS", "(", "FNMSUB", ",", "FNMSAC", ",", "VV", ")", "}", "auto", "&", "WorkingMI", "=", "cloneIfNew", "(", "MI", ")", ";", "WorkingMI", ".", "setDesc", "(", "get", "(", "Opc", ")", ")", ";", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "WorkingMI", ",", "false", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "break", ";", "}", "}", "return", "TargetInstrInfo", "::", "commuteInstructionImpl", "(", "MI", ",", "NewMI", ",", "OpIdx1", ",", "OpIdx2", ")", ";", "}", "</s>" ]

[ "Commutes", "the", "operands", "in", "the", "given", "instruction", "by", "changing", "the", "operands", "order", "and/or", "changing", "the", "instruction", "'s", "opcode", "and/or", "the", "immediate", "value", "operand", "." ]

[ "RISCV", "RISCV", "1", "1", "\"Unexpected opcode index\"", "3", "3", "\"Unexpected opcode index\"", "\"Unexpected opcode\"", "1", "1", "\"Unexpected opcode index\"", "3", "3", "\"Unexpected opcode\"" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "Available", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "HazardRec", "->", "dumpState", "(", ")", ";", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

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

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

[ "X86", "X86", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "X86", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "0", "1", "1", "0", "0", "X86::MOVSX16rr8", "X86::MOVZX16rr8", "X86::MOVSX32rr8", "X86::MOVZX32rr8", "X86::MOVSX64rr8", "X86::MOVZX64rr8", "X86::sub_8bit", "X86::MOVSX32rr16", "X86::MOVZX32rr16", "X86::MOVSX64rr16", "X86::MOVZX64rr16", "X86::sub_16bit", "X86::MOVSX64rr32", "X86::MOVZX64rr32", "X86::sub_32bit" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "areInlineCompatible", "(", "const", "Function", "*", "Caller", ",", "const", "Function", "*", "Callee", ")", "const", "{", "const", "TargetMachine", "&", "TM", "=", "getTLI", "(", ")", "->", "getTargetMachine", "(", ")", ";", "const", "GCNSubtarget", "*", "CallerST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Caller", ")", ")", ";", "const", "GCNSubtarget", "*", "CalleeST", "=", "static_cast", "<", "const", "GCNSubtarget", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", "*", "Callee", ")", ")", ";", "const", "FeatureBitset", "&", "CallerBits", "=", "CallerST", "->", "getFeatureBits", "(", ")", ";", "const", "FeatureBitset", "&", "CalleeBits", "=", "CalleeST", "->", "getFeatureBits", "(", ")", ";", "FeatureBitset", "RealCallerBits", "=", "CallerBits", "&", "~", "InlineFeatureIgnoreList", ";", "FeatureBitset", "RealCalleeBits", "=", "CalleeBits", "&", "~", "InlineFeatureIgnoreList", ";", "if", "(", "(", "RealCallerBits", "&", "RealCalleeBits", ")", "!=", "RealCalleeBits", ")", "return", "false", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CallerMode", "(", "*", "Caller", ")", ";", "AMDGPU", "::", "SIModeRegisterDefaults", "CalleeMode", "(", "*", "Callee", ")", ";", "if", "(", "!", "CallerMode", ".", "isInlineCompatible", "(", "CalleeMode", ")", ")", "return", "false", ";", "if", "(", "InlineMaxBB", "&&", "!", "Callee", "->", "hasFnAttribute", "(", "Attribute", "::", "InlineHint", ")", ")", "{", "size_t", "BBSize", "=", "Caller", "->", "size", "(", ")", "+", "Callee", "->", "size", "(", ")", "-", "1", ";", "return", "BBSize", "<=", "InlineMaxBB", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "callee", "with", "the", "given", "TLI", "can", "be", "inlined", "into", "caller", "with", "this", "TLI", ",", "based", "on", "'nobuiltin", "'", "attributes", "." ]

[ "AMDGPU", "AMDGPU::SIModeRegisterDefaults", "AMDGPU::SIModeRegisterDefaults", "1" ]

[]

[ "<s>", "static", "int", "cris_reg_saved_in_regsave_area", "(", "unsigned", "int", "regno", ")", "{", "return", "(", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", ")", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "regno", "!=", "CRIS_SRP_REGNUM", ")", "||", "(", "crtl", "->", "calls_eh_return", "&&", "(", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "0", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "1", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "2", ")", "||", "regno", "==", "EH_RETURN_DATA_REGNO", "(", "3", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REGNO", "is", "an", "ordinary", "register", "that", "*", "needs", "*", "to", "be", "saved", "together", "with", "other", "registers", ",", "possibly", "by", "a", "MOVEM", "instruction", ",", "or", "is", "saved", "for", "target-independent", "reasons", ".", "There", "may", "be", "target-dependent", "reasons", "to", "save", "the", "register", "anyway", ";", "this", "is", "just", "a", "wrapper", "for", "a", "complicated", "conditional", "." ]

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

[]

[ "<s>", "static", "bool", "fixed_reg_p", "(", "int", "reg", ")", "{", "if", "(", "reg", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", "&&", "(", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", ")", "||", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "||", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", ")", ")", "return", "false", ";", "return", "fixed_regs", "[", "reg", "]", ";", "}", "</s>" ]

[ "Return", "whether", "REG", "is", "a", "global", "user", "reg", "or", "has", "been", "specifed", "by", "-ffixed-REG", ".", "We", "should", "not", "restore", "these", ",", "and", "so", "can", "not", "use", "lmw", "or", "out-of-line", "restore", "functions", "if", "there", "are", "any", ".", "We", "also", "ca", "n't", "save", "them", "(", "well", ",", "emit", "frame", "notes", "for", "them", ")", ",", "because", "frame", "unwinding", "during", "exception", "handling", "will", "restore", "saved", "registers", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "unsigned", "PreferVectorWidthOverride", "=", "0", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"prefer-vector-width\"", ")", ")", "{", "StringRef", "Val", "=", "F", ".", "getFnAttribute", "(", "\"prefer-vector-width\"", ")", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\",prefer-vector-width=\"", ";", "Key", "+=", "Val", ";", "PreferVectorWidthOverride", "=", "Width", ";", "}", "}", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ",", "PreferVectorWidthOverride", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "512", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "0", "\"prefer-vector-width\"", "\"prefer-vector-width\"", "0", "\",prefer-vector-width=\"", "X86" ]

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "const", "MCObjectFileInfo", "::", "Environment", "Format", "=", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", "->", "getObjectFileType", "(", ")", ";", "bool", "IsMachO", "=", "Format", "==", "MCObjectFileInfo", "::", "IsMachO", ";", "bool", "IsCOFF", "=", "Format", "==", "MCObjectFileInfo", "::", "IsCOFF", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "SMLoc", "Loc", "=", "DirectiveID", ".", "getLoc", "(", ")", ";", "if", "(", "IDVal", "==", "\".hword\"", ")", "return", "parseDirectiveWord", "(", "2", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "parseDirectiveWord", "(", "4", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".xword\"", ")", "return", "parseDirectiveWord", "(", "8", ",", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".tlsdesccall\"", ")", "return", "parseDirectiveTLSDescCall", "(", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".ltorg\"", "||", "IDVal", "==", "\".pool\"", ")", "return", "parseDirectiveLtorg", "(", "Loc", ")", ";", "if", "(", "IDVal", "==", "\".unreq\"", ")", "return", "parseDirectiveUnreq", "(", "Loc", ")", ";", "if", "(", "!", "IsMachO", "&&", "!", "IsCOFF", ")", "{", "if", "(", "IDVal", "==", "\".inst\"", ")", "return", "parseDirectiveInst", "(", "Loc", ")", ";", "}", "return", "parseDirectiveLOH", "(", "IDVal", ",", "Loc", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\".hword\"", "2", "\".word\"", "4", "\".xword\"", "8", "\".tlsdesccall\"", "\".ltorg\"", "\".pool\"", "\".unreq\"", "\".inst\"" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_vec_ext_builtin", "(", "tree", "exp", ",", "rtx", "target", ")", "{", "machine_mode", "tmode", ",", "mode0", ";", "tree", "arg0", ",", "arg1", ";", "rtx", "op0", ";", "rtx", "op1", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "if", "(", "TREE_CODE", "(", "arg1", ")", "==", "INTEGER_CST", ")", "(", "void", ")", "get_element_number", "(", "TREE_TYPE", "(", "arg0", ")", ",", "arg1", ")", ";", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "mode0", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", ";", "op0", "=", "force_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "optimize", "||", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "rs6000_expand_vector_extract", "(", "target", ",", "op0", ",", "op1", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "vec_ext", "builtin", "." ]

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

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "mips_block_move_straight", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ")", "{", "HOST_WIDE_INT", "offset", ",", "delta", ";", "unsigned", "HOST_WIDE_INT", "bits", ";", "int", "i", ";", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "if", "(", "!", "ISA_HAS_LWL_LWR", ")", "bits", "=", "MIN", "(", "BITS_PER_WORD", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ")", ";", "else", "{", "if", "(", "MEM_ALIGN", "(", "src", ")", "==", "BITS_PER_WORD", "/", "2", "&&", "MEM_ALIGN", "(", "dest", ")", "==", "BITS_PER_WORD", "/", "2", ")", "bits", "=", "BITS_PER_WORD", "/", "2", ";", "else", "bits", "=", "BITS_PER_WORD", ";", "}", "mode", "=", "mode_for_size", "(", "bits", ",", "MODE_INT", ",", "0", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "XALLOCAVEC", "(", "rtx", ",", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "MEM_ALIGN", "(", "src", ")", ">=", "bits", ")", "mips_emit_move", "(", "regs", "[", "i", "]", ",", "adjust_address", "(", "src", ",", "mode", ",", "offset", ")", ")", ";", "else", "{", "rtx", "part", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "set_mem_size", "(", "part", ",", "delta", ")", ";", "if", "(", "!", "mips_expand_ext_as_unaligned_load", "(", "regs", "[", "i", "]", ",", "part", ",", "bits", ",", "0", ",", "0", ")", ")", "gcc_unreachable", "(", ")", ";", "}", "}", "for", "(", "offset", "=", "0", ",", "i", "=", "0", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "if", "(", "MEM_ALIGN", "(", "dest", ")", ">=", "bits", ")", "mips_emit_move", "(", "adjust_address", "(", "dest", ",", "mode", ",", "offset", ")", ",", "regs", "[", "i", "]", ")", ";", "else", "{", "rtx", "part", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "set_mem_size", "(", "part", ",", "delta", ")", ";", "if", "(", "!", "mips_expand_ins_as_unaligned_store", "(", "part", ",", "regs", "[", "i", "]", ",", "bits", ",", "0", ")", ")", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "offset", "<", "length", ")", "{", "src", "=", "adjust_address", "(", "src", ",", "BLKmode", ",", "offset", ")", ";", "dest", "=", "adjust_address", "(", "dest", ",", "BLKmode", ",", "offset", ")", ";", "move_by_pieces", "(", "dest", ",", "src", ",", "length", "-", "offset", ",", "MIN", "(", "MEM_ALIGN", "(", "src", ")", ",", "MEM_ALIGN", "(", "dest", ")", ")", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Emit", "straight-line", "code", "to", "move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", ".", "Assume", "that", "the", "areas", "do", "not", "overlap", "." ]

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

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "OR_pp", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "if", "(", "SrcReg", "==", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "Hexagon", "::", "CRRegsRegClass", ".", "contains", "(", "DestReg", ")", "&&", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFCR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::TFR", "Hexagon::DoubleRegsRegClass", "Hexagon::TFR64", "Hexagon::PredRegsRegClass", "Hexagon::OR_pp", "Hexagon::DoubleRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::TFR", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::CRRegsRegClass", "Hexagon::IntRegsRegClass", "Hexagon::TFCR", "\"Unimplemented\"" ]

[]

[ "<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", "::", "BITCAST", ":", "Res", "=", "ExpandBITCAST", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "Res", "=", "ExpandVectorExtension", "(", "N", ",", "DAG", ")", ";", "break", ";", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "Res", "=", "Expand64BitShift", "(", "N", ",", "DAG", ",", "Subtarget", ")", ";", "break", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "ReplaceREADCYCLECOUNTER", "(", "N", ",", "Results", ",", "DAG", ",", "Subtarget", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "case", "ISD", "::", "ATOMIC_LOAD", ":", "case", "ISD", "::", "ATOMIC_LOAD_ADD", ":", "case", "ISD", "::", "ATOMIC_LOAD_AND", ":", "case", "ISD", "::", "ATOMIC_LOAD_NAND", ":", "case", "ISD", "::", "ATOMIC_LOAD_OR", ":", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "case", "ISD", "::", "ATOMIC_LOAD_XOR", ":", "case", "ISD", "::", "ATOMIC_SWAP", ":", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "case", "ISD", "::", "ATOMIC_LOAD_MIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMIN", ":", "case", "ISD", "::", "ATOMIC_LOAD_MAX", ":", "case", "ISD", "::", "ATOMIC_LOAD_UMAX", ":", "ReplaceATOMIC_OP_64", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "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::BITCAST", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::SRL", "ISD::SRA", "ISD::READCYCLECOUNTER", "ISD::ATOMIC_STORE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_LOAD_ADD", "ISD::ATOMIC_LOAD_AND", "ISD::ATOMIC_LOAD_NAND", "ISD::ATOMIC_LOAD_OR", "ISD::ATOMIC_LOAD_SUB", "ISD::ATOMIC_LOAD_XOR", "ISD::ATOMIC_SWAP", "ISD::ATOMIC_CMP_SWAP", "ISD::ATOMIC_LOAD_MIN", "ISD::ATOMIC_LOAD_UMIN", "ISD::ATOMIC_LOAD_MAX", "ISD::ATOMIC_LOAD_UMAX" ]

[]

[ "<s>", "bool", "isNoopAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "between", "SrcAS", "and", "DestAS", "is", "a", "noop", "." ]

[ "ARM64" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "SDNode", "*", "N", ")", "{", "return", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "MSCATTER", ";", "}", "</s>" ]

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

[ "X86", "X86ISD::MSCATTER" ]

[]

[ "<s>", "bool", "SIWholeQuadMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Instructions", ".", "clear", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "LiveMaskQueries", ".", "clear", "(", ")", ";", "LowerToCopyInstrs", ".", "clear", "(", ")", ";", "CallingConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "char", "GlobalFlags", "=", "analyzeFunction", "(", "MF", ")", ";", "unsigned", "LiveMaskReg", "=", "0", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWQM", ")", ")", "{", "lowerLiveMaskQueries", "(", "AMDGPU", "::", "EXEC", ")", ";", "if", "(", "!", "(", "GlobalFlags", "&", "StateWWM", ")", ")", "return", "!", "LiveMaskQueries", ".", "empty", "(", ")", ";", "}", "else", "{", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "EntryMI", "=", "Entry", ".", "getFirstNonPHI", "(", ")", ";", "if", "(", "GlobalFlags", "&", "StateExact", "||", "!", "LiveMaskQueries", ".", "empty", "(", ")", ")", "{", "LiveMaskReg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "LiveMaskReg", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "lowerLiveMaskQueries", "(", "LiveMaskReg", ")", ";", "if", "(", "GlobalFlags", "==", "StateWQM", ")", "{", "BuildMI", "(", "Entry", ",", "EntryMI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "lowerCopyInstrs", "(", ")", ";", "return", "true", ";", "}", "}", "DEBUG", "(", "printInfo", "(", ")", ")", ";", "lowerCopyInstrs", "(", ")", ";", "for", "(", "auto", "BII", ":", "Blocks", ")", "processBlock", "(", "*", "BII", ".", "first", ",", "LiveMaskReg", ",", "BII", ".", "first", "==", "&", "*", "MF", ".", "begin", "(", ")", ")", ";", "LIS", "->", "removeRegUnit", "(", "*", "MCRegUnitIterator", "(", "AMDGPU", "::", "SCC", ",", "TRI", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "0", "AMDGPU::EXEC", "AMDGPU::SReg_64RegClass", "AMDGPU::COPY", "AMDGPU::EXEC", "AMDGPU::S_WQM_B64", "AMDGPU::EXEC", "AMDGPU::EXEC", "AMDGPU::SCC" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "AMDGPUFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "0" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "getBasePointerSaveOffset", "(", ")", "const", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "report_fatal_error", "(", "\"BasePointer is not implemented on AIX yet.\"", ")", ";", "return", "BasePointerSaveOffset", ";", "}", "</s>" ]

[ "getBasePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "base", "pointer", "." ]

[ "PowerPC", "PPC", "\"BasePointer is not implemented on AIX yet.\"" ]

[]

[ "<s>", "static", "tree", "mips_merge_decl_attributes", "(", "tree", "olddecl", ",", "tree", "newdecl", ")", "{", "unsigned", "int", "diff", ";", "diff", "=", "(", "mips_get_compress_on_flags", "(", "DECL_ATTRIBUTES", "(", "olddecl", ")", ")", "^", "mips_get_compress_on_flags", "(", "DECL_ATTRIBUTES", "(", "newdecl", ")", ")", ")", ";", "if", "(", "diff", ")", "error", "(", "\"%qE redeclared with conflicting %qs attributes\"", ",", "DECL_NAME", "(", "newdecl", ")", ",", "mips_get_compress_on_name", "(", "diff", ")", ")", ";", "diff", "=", "(", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "olddecl", ")", ")", "^", "mips_get_compress_off_flags", "(", "DECL_ATTRIBUTES", "(", "newdecl", ")", ")", ")", ";", "if", "(", "diff", ")", "error", "(", "\"%qE redeclared with conflicting %qs attributes\"", ",", "DECL_NAME", "(", "newdecl", ")", ",", "mips_get_compress_off_name", "(", "diff", ")", ")", ";", "return", "merge_attributes", "(", "DECL_ATTRIBUTES", "(", "olddecl", ")", ",", "DECL_ATTRIBUTES", "(", "newdecl", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MERGE_DECL_ATTRIBUTES", "." ]

[ "mips", "\"%qE redeclared with conflicting %qs attributes\"", "\"%qE redeclared with conflicting %qs attributes\"" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "if", "(", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isAAPCS_ABI", "(", ")", ")", "{", "StaticCtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".init_array\"", ",", "MCSectionELF", "::", "SHT_INIT_ARRAY", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "StaticDtorSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".fini_array\"", ",", "MCSectionELF", "::", "SHT_FINI_ARRAY", ",", "MCSectionELF", "::", "SHF_WRITE", "|", "MCSectionELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "ARM", "ARM", "ARM", "\".init_array\"", "\".fini_array\"" ]

[]

[ "<s>", "bool", "ARMBlockPlacement", "::", "fixBackwardsWLS", "(", "MachineLoop", "*", "ML", ")", "{", "MachineInstr", "*", "WlsInstr", "=", "findWLS", "(", "ML", ")", ";", "if", "(", "!", "WlsInstr", ")", "return", "false", ";", "MachineBasicBlock", "*", "Predecessor", "=", "WlsInstr", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "LoopExit", "=", "getWhileLoopStartTargetBB", "(", "*", "WlsInstr", ")", ";", "if", "(", "!", "LoopExit", "->", "getPrevNode", "(", ")", ")", "return", "false", ";", "if", "(", "blockIsBefore", "(", "Predecessor", ",", "LoopExit", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Found a backwards WLS from \"", "<<", "Predecessor", "->", "getFullName", "(", ")", "<<", "\" to \"", "<<", "LoopExit", "->", "getFullName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "auto", "It", "=", "++", "LoopExit", "->", "getIterator", "(", ")", ";", "It", "!=", "Predecessor", "->", "getIterator", "(", ")", ";", "++", "It", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "&", "*", "It", ";", "for", "(", "auto", "&", "Terminator", ":", "MBB", "->", "terminators", "(", ")", ")", "{", "if", "(", "!", "isWhileLoopStart", "(", "Terminator", ")", ")", "continue", ";", "MachineBasicBlock", "*", "WLSTarget", "=", "getWhileLoopStartTargetBB", "(", "Terminator", ")", ";", "if", "(", "WLSTarget", "==", "Predecessor", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_PREFIX", "<<", "\"Can't move Predecessor\"", "\"block as it would convert a WLS from forward to a \"", "\"backwards branching WLS\\n\"", ")", ";", "return", "revertWhileToDo", "(", "WlsInstr", ",", "ML", ")", ";", "}", "}", "}", "moveBasicBlock", "(", "Predecessor", ",", "LoopExit", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "if", "loop", "has", "a", "backwards", "branching", "WLS", ",", "and", "if", "possible", ",", "fixes", "it", "." ]

[ "ARM", "ARM", "\"Found a backwards WLS from \"", "\" to \"", "\"\\n\"", "\"Can't move Predecessor\"", "\"block as it would convert a WLS from forward to a \"", "\"backwards branching WLS\\n\"" ]

[]

[ "<s>", "SDValue", "X86SelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "Align", "Alignment", ",", "bool", "isVolatile", ",", "bool", "AlwaysInline", ",", "MachinePointerInfo", "DstPtrInfo", ",", "MachinePointerInfo", "SrcPtrInfo", ")", "const", "{", "if", "(", "DstPtrInfo", ".", "getAddrSpace", "(", ")", ">=", "256", "||", "SrcPtrInfo", ".", "getAddrSpace", "(", ")", ">=", "256", ")", "return", "SDValue", "(", ")", ";", "const", "MCPhysReg", "ClobberSet", "[", "]", "=", "{", "X86", "::", "RCX", ",", "X86", "::", "RSI", ",", "X86", "::", "RDI", ",", "X86", "::", "ECX", ",", "X86", "::", "ESI", ",", "X86", "::", "EDI", "}", ";", "if", "(", "isBaseRegConflictPossible", "(", "DAG", ",", "ClobberSet", ")", ")", "return", "SDValue", "(", ")", ";", "const", "X86Subtarget", "&", "Subtarget", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ")", "return", "emitConstantSizeRepmov", "(", "DAG", ",", "Subtarget", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "ConstantSize", "->", "getZExtValue", "(", ")", ",", "Size", ".", "getValueType", "(", ")", ",", "Alignment", ".", "value", "(", ")", ",", "isVolatile", ",", "AlwaysInline", ",", "DstPtrInfo", ",", "SrcPtrInfo", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "256", "256", "X86::RCX", "X86::RSI", "X86::RDI", "X86::ECX", "X86::ESI", "X86::EDI", "X86", "X86" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "getRetCCAssignFn", "(", "CallConv", ")", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RVLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "I", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "I", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "ISD::InputArg", "16", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MRI", ".", "getTargetRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "&", "RC", "=", "*", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Cond array\"", ")", ";", "unsigned", "Opc", "=", "X86", "::", "getCMovOpcode", "(", "TRI", ".", "getRegSizeInBits", "(", "RC", ")", "/", "8", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "X86", "X86", "1", "\"Invalid Cond array\"", "X86::getCMovOpcode", "8", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "bool", "ClobbersEFLAGS", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Orig", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "{", "ClobbersEFLAGS", "=", "true", ";", "break", ";", "}", "}", "if", "(", "ClobbersEFLAGS", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "int", "Value", ";", "switch", "(", "Orig", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "Value", "=", "0", ";", "break", ";", "case", "X86", "::", "MOV32r1", ":", "Value", "=", "1", ";", "break", ";", "case", "X86", "::", "MOV32r_1", ":", "Value", "=", "-", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "}", "const", "DebugLoc", "&", "DL", "=", "Orig", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "add", "(", "Orig", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "MachineInstr", "&", "NewMI", "=", "*", "std", "::", "prev", "(", "I", ")", ";", "NewMI", ".", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::MOV32r0", "0", "X86::MOV32r1", "1", "X86::MOV32r_1", "1", "\"Unexpected instruction!\"", "X86::MOV32ri", "0", "0" ]

[]

[ "<s>", "EVT", "RISCVTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", "&&", "(", "VT", ".", "isScalableVector", "(", ")", "||", "Subtarget", ".", "useRVVForFixedLengthVectors", "(", ")", ")", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "MVT::i1" ]

[]

[ "<s>", "StringRef", "X86TargetLowering", "::", "getStackProbeSymbolName", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "hasInlineStackProbe", "(", "MF", ")", ")", "return", "\"\"", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"probe-stack\"", ")", ")", "return", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "\"probe-stack\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isOSWindows", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"no-stack-arg-probe\"", ")", ")", "return", "\"\"", ";", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"___chkstk_ms\"", ":", "\"__chkstk\"", ";", "return", "Subtarget", ".", "isTargetCygMing", "(", ")", "?", "\"_alloca\"", ":", "\"_chkstk\"", ";", "}", "</s>" ]

[ "Returns", "the", "name", "of", "the", "symbol", "used", "to", "emit", "stack", "probes", "or", "the", "empty", "string", "if", "not", "applicable", "." ]

[ "X86", "X86", "\"\"", "\"probe-stack\"", "\"probe-stack\"", "\"no-stack-arg-probe\"", "\"\"", "\"___chkstk_ms\"", "\"__chkstk\"", "\"_alloca\"", "\"_chkstk\"" ]

[]

[ "<s>", "bool", "MipsHazardSchedule", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "MipsSubtarget", "*", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", "->", "hasMips32r6", "(", ")", "||", "STI", "->", "inMicroMipsMode", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "const", "MipsInstrInfo", "*", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "MF", ".", "begin", "(", ")", ";", "FI", "!=", "MF", ".", "end", "(", ")", ";", "++", "FI", ")", "{", "for", "(", "Iter", "I", "=", "FI", "->", "begin", "(", ")", ";", "I", "!=", "FI", "->", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "TII", "->", "HasForbiddenSlot", "(", "*", "I", ")", ")", "continue", ";", "bool", "InsertNop", "=", "false", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "FI", "->", "end", "(", ")", "&&", "!", "TII", "->", "SafeInForbiddenSlot", "(", "*", "getNextMachineInstr", "(", "std", "::", "next", "(", "I", ")", ")", ")", ")", "{", "InsertNop", "=", "true", ";", "}", "else", "{", "for", "(", "auto", "*", "Succ", ":", "FI", "->", "successors", "(", ")", ")", "{", "if", "(", "FI", "->", "isLayoutSuccessor", "(", "Succ", ")", "&&", "getNextMachineInstr", "(", "Succ", "->", "begin", "(", ")", ")", "!=", "Succ", "->", "end", "(", ")", "&&", "!", "TII", "->", "SafeInForbiddenSlot", "(", "*", "getNextMachineInstr", "(", "Succ", "->", "begin", "(", ")", ")", ")", ")", "{", "InsertNop", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "InsertNop", ")", "{", "Changed", "=", "true", ";", "MIBundleBuilder", "(", "&", "*", "I", ")", ".", "append", "(", "BuildMI", "(", "MF", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "Mips", "::", "NOP", ")", ")", ")", ";", "NumInsertedNops", "++", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::NOP" ]

[]

[ "<s>", "iterator", "end", "(", ")", "{", "return", "(", "Packet", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "2", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"SystemZ branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SystemZ", "::", "J", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "unsigned", "CCValid", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SystemZ", "::", "BRC", ")", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ".", "addMBB", "(", "TBB", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "SystemZ", "::", "J", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"insertBranch must not be told to insert a fallthrough\"", "2", "0", "\"SystemZ branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "SystemZ::J", "1", "0", "0", "1", "SystemZ::BRC", "SystemZ::J" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "RootScope", "=", "getAnalysis", "<", "PatmosSPBundling", ">", "(", ")", ".", "getRootScope", "(", ")", ";", "PMFI", "=", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "bool", "changed", "=", "false", ";", "if", "(", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", "->", "isSinglePath", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"[Single-Path] Reducing \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "doReduceFunction", "(", "MF", ")", ";", "changed", "|=", "true", ";", "}", "return", "changed", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "Patmos", "\"[Single-Path] Reducing \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "const", "MipsSubtarget", "&", "ST", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "FixGlobalBaseReg", ")", "return", "GlobalBaseReg", "=", "ST", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "const", "TargetRegisterClass", "*", "RC", ";", "RC", "=", "ST", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "CPU64RegsRegisterClass", ":", "Mips", "::", "CPURegsRegisterClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::GP_64", "Mips::GP", "Mips::CPU64RegsRegisterClass", "Mips::CPURegsRegisterClass" ]

[]

[ "<s>", "void", "aarch64_register_fma_steering", "(", ")", "{", "opt_pass", "*", "pass_fma_steering", "=", "make_pass_fma_steering", "(", "g", ")", ";", "struct", "register_pass_info", "fma_steering_info", "=", "{", "pass_fma_steering", ",", "\"rnreg\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "fma_steering_info", ")", ";", "}", "</s>" ]

[ "Register", "the", "FMA", "steering", "pass", "to", "the", "pass", "manager", "." ]

[ "aarch64", "\"rnreg\"", "1" ]

[]

[ "<s>", "void", "sparc_profile_hook", "(", "int", "labelno", ")", "{", "char", "buf", "[", "32", "]", ";", "rtx", "lab", ",", "fun", ";", "fun", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "MCOUNT_FUNCTION", ")", ";", "if", "(", "NO_PROFILE_COUNTERS", ")", "{", "emit_library_call", "(", "fun", ",", "LCT_NORMAL", ",", "VOIDmode", ")", ";", "}", "else", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LP\"", ",", "labelno", ")", ";", "lab", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "buf", ")", ")", ";", "emit_library_call", "(", "fun", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "lab", ",", "Pmode", ")", ";", "}", "}", "</s>" ]

[ "Output", "rtl", "to", "increment", "the", "profiler", "label", "LABELNO", "for", "profiling", "a", "function", "entry", "." ]

[ "sparc", "32", "\"LP\"" ]

[]

[ "<s>", "static", "void", "mn10300_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "chain_value", ")", "{", "rtx", "mem", ",", "disp", ",", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "disp", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "fnaddr", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ",", "11", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "0", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0xddfc0028", ",", "SImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "4", ")", ";", "emit_move_insn", "(", "mem", ",", "chain_value", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "8", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_int_mode", "(", "0xdc00edf8", ",", "SImode", ")", ")", ";", "mem", "=", "adjust_address", "(", "m_tramp", ",", "SImode", ",", "12", ")", ";", "emit_move_insn", "(", "mem", ",", "disp", ")", ";", "}", "</s>" ]

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

[ "mn10300", "0", "0", "11", "1", "0", "0xddfc0028", "4", "8", "0xdc00edf8", "12" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_parm_offset", "(", "void", ")", "{", "return", "(", "DEFAULT_ABI", "==", "ABI_V4", "?", "2", ":", "DEFAULT_ABI", "==", "ABI_ELFv2", "?", "4", ":", "6", ")", ";", "}", "</s>" ]

[ "The", "offset", "in", "words", "to", "the", "start", "of", "the", "parameter", "save", "area", "." ]

[ "rs6000", "2", "4", "6" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "SrcVTy", "->", "getVectorNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "static", "int", "neon_endian_lane_map", "(", "machine_mode", "mode", ",", "int", "lane", ")", "{", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "int", "nelems", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "lane", "=", "(", "nelems", "-", "1", "-", "lane", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", ")", "lane", "=", "lane", "^", "(", "nelems", "/", "2", ")", ";", "}", "return", "lane", ";", "}", "</s>" ]

[ "Map", "lane", "ordering", "between", "architectural", "lane", "order", ",", "and", "GCC", "lane", "order", ",", "taking", "into", "account", "ABI", ".", "See", "comment", "above", "output_move_neon", "for", "details", "." ]

[ "arm", "1", "16", "2" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "if", "(", "!", "WasmDisableExplicitLocals", ")", "addPass", "(", "createWebAssemblyDebugFixup", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "avr_function_value", "(", "tree", "type", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "int", "offs", ";", "if", "(", "TYPE_MODE", "(", "type", ")", "!=", "BLKmode", ")", "return", "avr_libcall_value", "(", "TYPE_MODE", "(", "type", ")", ")", ";", "offs", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "offs", "<", "2", ")", "offs", "=", "2", ";", "if", "(", "offs", ">", "2", "&&", "offs", "<", "GET_MODE_SIZE", "(", "SImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "SImode", ")", ";", "else", "if", "(", "offs", ">", "GET_MODE_SIZE", "(", "SImode", ")", "&&", "offs", "<", "GET_MODE_SIZE", "(", "DImode", ")", ")", "offs", "=", "GET_MODE_SIZE", "(", "DImode", ")", ";", "return", "gen_rtx_REG", "(", "BLKmode", ",", "RET_REGISTER", "+", "2", "-", "offs", ")", ";", "}", "</s>" ]

[ "Create", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "a", "value", "of", "data", "type", "VALTYPE", "." ]

[ "avr", "2", "2", "2", "2" ]

[]

[ "<s>", "void", "pa_output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "p", ",", "int", "size", ")", "{", "int", "i", ";", "int", "chars_output", ";", "unsigned", "char", "partial_output", "[", "16", "]", ";", "fputs", "(", "\"\\t.STRING \\\"\"", ",", "file", ")", ";", "chars_output", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+=", "4", ")", "{", "int", "co", "=", "0", ";", "int", "io", "=", "0", ";", "for", "(", "io", "=", "0", ",", "co", "=", "0", ";", "io", "<", "MIN", "(", "4", ",", "size", "-", "i", ")", ";", "io", "++", ")", "{", "unsigned", "int", "c", "=", "(", "unsigned", "char", ")", "p", "[", "i", "+", "io", "]", ";", "if", "(", "c", "==", "'\\\"'", "||", "c", "==", "'\\\\'", ")", "partial_output", "[", "co", "++", "]", "=", "'\\\\'", ";", "if", "(", "c", ">=", "' '", "&&", "c", "<", "0177", ")", "partial_output", "[", "co", "++", "]", "=", "c", ";", "else", "{", "unsigned", "int", "hexd", ";", "partial_output", "[", "co", "++", "]", "=", "'\\\\'", ";", "partial_output", "[", "co", "++", "]", "=", "'x'", ";", "hexd", "=", "c", "/", "16", "-", "0", "+", "'0'", ";", "if", "(", "hexd", ">", "'9'", ")", "hexd", "-=", "'9'", "-", "'a'", "+", "1", ";", "partial_output", "[", "co", "++", "]", "=", "hexd", ";", "hexd", "=", "c", "%", "16", "-", "0", "+", "'0'", ";", "if", "(", "hexd", ">", "'9'", ")", "hexd", "-=", "'9'", "-", "'a'", "+", "1", ";", "partial_output", "[", "co", "++", "]", "=", "hexd", ";", "}", "}", "if", "(", "chars_output", "+", "co", ">", "243", ")", "{", "fputs", "(", "\"\\\"\\n\\t.STRING \\\"\"", ",", "file", ")", ";", "chars_output", "=", "0", ";", "}", "fwrite", "(", "partial_output", ",", "1", ",", "(", "size_t", ")", "co", ",", "file", ")", ";", "chars_output", "+=", "co", ";", "co", "=", "0", ";", "}", "fputs", "(", "\"\\\"\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "an", "ascii", "string", "." ]

[ "pa", "16", "\"\\t.STRING \\\"\"", "0", "0", "4", "0", "0", "0", "0", "4", "0177", "16", "0", "1", "16", "0", "1", "243", "\"\\\"\\n\\t.STRING \\\"\"", "0", "1", "0", "\"\\\"\\n\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldUseStrictFP_TO_INT", "(", "EVT", "FpVT", ",", "EVT", "IntVT", ",", "bool", "IsSigned", ")", "const", "{", "return", "!", "IsSigned", "&&", "FpVT", "==", "MVT", "::", "f80", "&&", "Subtarget", ".", "hasCMov", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "more", "correct/profitable", "to", "use", "strict", "FP_TO_INT", "conversion", "operations", "-", "canonicalizing", "the", "FP", "source", "value", "instead", "of", "converting", "all", "cases", "and", "then", "selecting", "based", "on", "value", "." ]

[ "X86", "X86", "MVT::f80" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_shared_bcast", "(", "rtx", "reg", ",", "propagate_mask", "pm", ",", "unsigned", "rep", ",", "broadcast_data_t", "*", "data", ",", "bool", "vector", ")", "{", "rtx", "res", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_BImode", ":", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "pm", "&", "PM_read", ")", "emit_insn", "(", "gen_sel_truesi", "(", "tmp", ",", "reg", ",", "GEN_INT", "(", "1", ")", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "nvptx_gen_shared_bcast", "(", "tmp", ",", "pm", ",", "rep", ",", "data", ",", "vector", ")", ")", ";", "if", "(", "pm", "&", "PM_write", ")", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "gen_rtx_NE", "(", "BImode", ",", "tmp", ",", "const0_rtx", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "break", ";", "default", ":", "{", "rtx", "addr", "=", "data", "->", "ptr", ";", "if", "(", "!", "addr", ")", "{", "unsigned", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", "/", "BITS_PER_UNIT", ";", "oacc_bcast_align", "=", "MAX", "(", "oacc_bcast_align", ",", "align", ")", ";", "data", "->", "offset", "=", "ROUND_UP", "(", "data", "->", "offset", ",", "align", ")", ";", "addr", "=", "data", "->", "base", ";", "gcc_assert", "(", "data", "->", "base", "!=", "NULL", ")", ";", "if", "(", "data", "->", "offset", ")", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "data", "->", "offset", ")", ")", ";", "}", "addr", "=", "gen_rtx_MEM", "(", "mode", ",", "addr", ")", ";", "if", "(", "pm", "==", "PM_read", ")", "res", "=", "gen_rtx_SET", "(", "addr", ",", "reg", ")", ";", "else", "if", "(", "pm", "==", "PM_write", ")", "res", "=", "gen_rtx_SET", "(", "reg", ",", "addr", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "data", "->", "ptr", ")", "{", "start_sequence", "(", ")", ";", "emit_insn", "(", "res", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "data", "->", "ptr", ",", "data", "->", "ptr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "else", "rep", "=", "1", ";", "data", "->", "offset", "+=", "rep", "*", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "break", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "instruction", "(", "s", ")", "to", "spill", "or", "fill", "register", "REG", "to/from", "the", "worker", "broadcast", "array", ".", "PM", "indicates", "what", "is", "to", "be", "done", ",", "REP", "how", "many", "loop", "iterations", "will", "be", "executed", "(", "0", "for", "not", "a", "loop", ")", "." ]

[ "nvptx", "1", "1" ]

[]

[ "<s>", "bool", "ARM64AddressTypePromotion", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableAddressTypePromotion", "||", "F", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "Func", "=", "&", "F", ";", "ConsideredSExtType", "=", "Type", "::", "getInt64Ty", "(", "Func", "->", "getContext", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "Func", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Instructions", "SExtInsts", ";", "analyzeSExtension", "(", "SExtInsts", ")", ";", "return", "propagateSignExtension", "(", "SExtInsts", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"*** \"", "\": \"" ]

[]

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

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

[ "SPIRV", "SPIRV" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'A'", ":", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "O", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "ARMInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "ARM", "ARM", "0", "1", "0", "0", "ARM", "\"unexpected inline asm memory operand\"", "\"[\"", "ARM", "\"]\"" ]

[]

[ "<s>", "bool", "nds32_n10_mm_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "def_reg", ";", "switch", "(", "get_attr_type", "(", "producer", ")", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "case", "TYPE_DALU64", ":", "case", "TYPE_DMUL", ":", "case", "TYPE_DMAC", ":", "case", "TYPE_DALUROUND", ":", "case", "TYPE_DBPICK", ":", "case", "TYPE_DWEXT", ":", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "divmod_p", "(", "producer", ")", ")", "{", "rtx", "def_reg1", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "0", ")", ")", ";", "rtx", "def_reg2", "=", "SET_DEST", "(", "parallel_element", "(", "producer", ",", "1", ")", ")", ";", "return", "(", "n10_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg1", ")", "||", "n10_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg2", ")", ")", ";", "}", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "n10_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "MM", "to", "EX", "." ]

[ "nds32", "0", "1" ]

[]

[ "<s>", "bool", "n8_consumed_by_ex_p", "(", "rtx_insn", "*", "consumer", ",", "rtx", "def_reg", ")", "{", "rtx", "use_rtx", ";", "switch", "(", "get_attr_type", "(", "consumer", ")", ")", "{", "case", "TYPE_ALU", ":", "if", "(", "movd44_even_dep_p", "(", "consumer", ",", "def_reg", ")", ")", "return", "true", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_MAC", ":", "use_rtx", "=", "extract_mac_non_acc_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_DIV", ":", "if", "(", "INSN_CODE", "(", "consumer", ")", "==", "CODE_FOR_divmodsi4", "||", "INSN_CODE", "(", "consumer", ")", "==", "CODE_FOR_udivmodsi4", ")", "use_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "consumer", ",", "0", ")", ")", ";", "else", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_BRANCH", ":", "use_rtx", "=", "extract_branch_condition_rtx", "(", "consumer", ")", ";", "break", ";", "case", "TYPE_STORE", ":", "if", "(", "!", "post_update_insn_p", "(", "consumer", ")", "&&", "!", "immed_offset_p", "(", "extract_mem_rtx", "(", "consumer", ")", ")", ")", "return", "false", ";", "use_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "consumer", ")", ")", ";", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "use_rtx", "=", "extract_nth_access_rtx", "(", "consumer", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "reg_overlap_p", "(", "def_reg", ",", "use_rtx", ")", ";", "}", "</s>" ]

[ "Check", "the", "dependency", "between", "the", "producer", "defining", "DEF_REG", "and", "CONSUMER", "requiring", "input", "operand", "at", "EX", "." ]

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Immed", ")", "const", "{", "if", "(", "Immed", "==", "std", "::", "numeric_limits", "<", "int64_t", ">", "::", "min", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Illegal add imm \"", "<<", "Immed", "<<", "\": avoid UB for INT64_MIN\\n\"", ")", ";", "return", "false", ";", "}", "Immed", "=", "std", "::", "abs", "(", "Immed", ")", ";", "bool", "IsLegal", "=", "(", "(", "Immed", ">>", "12", ")", "==", "0", "||", "(", "(", "Immed", "&", "0xfff", ")", "==", "0", "&&", "Immed", ">>", "24", "==", "0", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Is \"", "<<", "Immed", "<<", "\" legal add imm: \"", "<<", "(", "IsLegal", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\"\\n\"", ")", ";", "return", "IsLegal", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Illegal add imm \"", "\": avoid UB for INT64_MIN\\n\"", "12", "0", "0xfff", "0", "24", "0", "\"Is \"", "\" legal add imm: \"", "\"yes\"", "\"no\"", "\"\\n\"" ]

[]

[ "<s>", "Optional", "<", "DestSourcePair", ">", "ARMBaseInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isMoveReg", "(", ")", "||", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "VORRq", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ")", "return", "None", ";", "return", "DestSourcePair", "{", "MI", ".", "getOperand", "(", "0", ")", ",", "MI", ".", "getOperand", "(", "1", ")", "}", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::VORRq", "1", "2", "0", "1" ]

[]

[ "<s>", "bool", "canHaveNonUndefGlobalInitializerInAddressSpace", "(", "unsigned", "AS", ")", "const", "{", "return", "AS", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", "&&", "AS", "!=", "AMDGPUAS", "::", "REGION_ADDRESS", "&&", "AS", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "}", "</s>" ]

[ "Return", "true", "if", "globals", "in", "this", "address", "space", "can", "have", "initializers", "other", "than", "undef", "." ]

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

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "unsigned", "FPDiff", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "X86", "::", "GR32RegClassID", ":", "return", "4", "-", "FPDiff", ";", "case", "X86", "::", "GR64RegClassID", ":", "return", "12", "-", "FPDiff", ";", "case", "X86", "::", "VR128RegClassID", ":", "return", "Subtarget", ".", "is64Bit", "(", ")", "?", "10", ":", "4", ";", "case", "X86", "::", "VR64RegClassID", ":", "return", "4", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "1", "0", "0", "X86::GR32RegClassID", "4", "X86::GR64RegClassID", "12", "X86::VR128RegClassID", "10", "4", "X86::VR64RegClassID", "4" ]

[]

[ "<s>", "void", "MBlazeInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MBlaze", "::", "NOP", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "MBlaze", "MBlaze", "MBlaze::NOP" ]

[]

[ "<s>", "SDValue", "F2003fTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeArguments", "(", "Ins", ",", "CC_F2003f", ")", ";", "unsigned", "NumBytes", "=", "CCInfo", ".", "getNextStackOffset", "(", ")", "+", "4", ";", "if", "(", "isVarArg", ")", "{", "llvm_unreachable", "(", "\"Vararg is unsupported\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "switch", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"LowerFormalArguments Unhandled argument type: \"", "<<", "RegVT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "case", "MVT", "::", "i32", ":", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "F2003f", "::", "RegRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "SDValue", "InVal", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "unsigned", "offset", "=", "NumBytes", "-", "VA", ".", "getLocMemOffset", "(", ")", "-", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Flags", ".", "getByValSize", "(", ")", ",", "offset", ",", "true", ")", ";", "InVal", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "}", "else", "{", "unsigned", "ObjSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "ObjSize", ",", "offset", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "InVal", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getLocVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "FI", ")", ")", ";", "}", "InVals", ".", "push_back", "(", "InVal", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "ISD::InputArg", "16", "F2003f", "4", "\"Vararg is unsupported\"", "0", "\"LowerFormalArguments Unhandled argument type: \"", "\"\\n\"", "MVT::i32", "F2003f::RegRegClass", "ISD::ArgFlagsTy", "8", "8", "MVT::i32" ]

[]

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

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

[ "WebAssembly" ]

[]

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

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

[ "FISC", "FISC" ]

[]

[ "<s>", "static", "inline", "void", "desc_epilogue", "(", "unw_word", "t", ",", "unw_word", "ecount", ",", "struct", "unw_state_record", "*", "sr", ")", "{", "sr", "->", "epilogue_start", "=", "sr", "->", "region_start", "+", "sr", "->", "region_len", "-", "1", "-", "t", ";", "sr", "->", "epilogue_count", "=", "ecount", "+", "1", ";", "}", "</s>" ]

[ "Body", "descriptors", "." ]

[ "ia64", "1", "1" ]

[]

[ "<s>", "static", "int", "spu_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "rtx", "set", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_blockage", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_blockage", ")", "return", "0", ";", "if", "(", "(", "INSN_P", "(", "insn", ")", "&&", "get_attr_length", "(", "insn", ")", "==", "0", ")", "||", "(", "INSN_P", "(", "dep_insn", ")", "&&", "get_attr_length", "(", "dep_insn", ")", "==", "0", ")", ")", "return", "0", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "&&", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "8", ";", "if", "(", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_hbr", ")", "&&", "(", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_hbr", ")", ")", "return", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "0", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "target", "=", "get_branch_target", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "!=", "REG", "||", "!", "set_of", "(", "target", ",", "insn", ")", ")", "return", "cost", "-", "2", ";", "return", "cost", ";", "}", "if", "(", "CALL_P", "(", "dep_insn", ")", ")", "return", "cost", "-", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR__return", "&&", "(", "set", "=", "single_set", "(", "dep_insn", ")", ")", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "REG", "&&", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", "==", "LINK_REGISTER_REGNUM", ")", "return", "20", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "dep_type", "==", "REG_DEP_ANTI", ")", "return", "insn_cost", "(", "dep_insn", ")", "-", "3", ";", "return", "cost", ";", "}", "</s>" ]

[ "INSN", "is", "dependent", "on", "DEP_INSN", "." ]

[ "spu", "0", "0", "0", "0", "8", "2", "0", "2", "2", "20", "3" ]

[]

[ "<s>", "bool", "GBZ80InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", ",", "Reg", ",", "Imm", ",", "FPReg", ",", "Idx", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "}", "unsigned", "Lo", ",", "Hi", ";", "Lo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "GBZ80", "::", "subreg_lo", ")", ";", "Hi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "GBZ80", "::", "subreg_hi", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "GBZ80", "GB", "GBZ80::subreg_lo", "GBZ80::subreg_hi" ]

[]

[ "<s>", "void", "mt_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "'#'", ":", "if", "(", "dbr_sequence_length", "(", ")", "==", "0", ")", "fputs", "(", "\"\\n\\tnop\"", ",", "file", ")", ";", "return", ";", "case", "'H'", ":", "fprintf", "(", "file", ",", "\"#%%hi16(\"", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "return", ";", "case", "'L'", ":", "fprintf", "(", "file", ",", "\"#%%lo16(\"", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "return", ";", "case", "'N'", ":", "fprintf", "(", "file", ",", "\"#%ld\"", ",", "~", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "'z'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "x", ")", "==", "0", ")", "{", "fputs", "(", "reg_names", "[", "GPR_R0", "]", ",", "file", ")", ";", "return", ";", "}", "case", "0", ":", "break", ";", "default", ":", "fprintf", "(", "file", ",", "\"unknown code\"", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "case", "CONST", ":", "case", "CONST_INT", ":", "fprintf", "(", "file", ",", "\"#%ld\"", ",", "INTVAL", "(", "x", ")", ")", ";", "break", ";", "case", "MEM", ":", "mt_print_operand_address", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "default", ":", "fprintf", "(", "file", ",", "\"Uknown code: %d\"", ",", "GET_CODE", "(", "x", ")", ")", ";", "break", ";", "}", "return", ";", "}", "</s>" ]

[ "Implement", "PRINT_OPERAND", "." ]

[ "mt", "0", "\"\\n\\tnop\"", "\"#%%hi16(\"", "\")\"", "\"#%%lo16(\"", "\")\"", "\"#%ld\"", "0", "0", "\"unknown code\"", "\"#%ld\"", "0", "\"Uknown code: %d\"" ]

[]

[ "<s>", "int", "extra_constraint_Q", "(", "rtx", "x", ")", "{", "int", "ok", "=", "0", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "<=", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "x", ")", ")", ")", ")", "{", "rtx", "xx", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "int", "regno", "=", "REGNO", "(", "xx", ")", ";", "ok", "=", "(", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "REG_Z", "||", "regno", "==", "REG_Y", "||", "xx", "==", "frame_pointer_rtx", "||", "xx", "==", "arg_pointer_rtx", ")", ";", "if", "(", "avr_log", ".", "constraints", ")", "avr_edump", "(", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"", ",", "ok", ",", "reload_completed", ",", "reload_in_progress", ",", "x", ")", ";", "}", "return", "ok", ";", "}", "</s>" ]

[ "Test", "for", "extra", "memory", "constraint", "'", "Q", "'", ".", "It", "'s", "a", "memory", "address", "based", "on", "Y", "or", "Z", "pointer", "with", "valid", "displacement", "." ]

[ "avr", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "\"\\n%?=%d reload_completed=%d reload_in_progress=%d\\n %r\\n\"" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "(", "Cond", ".", "size", "(", ")", "&&", "Cond", ".", "size", "(", ")", "<=", "3", ")", "&&", "\"Invalid Mips branch condition!\"", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "getOppositeBranchOpc", "(", "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", "." ]

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

[]

[ "<s>", "static", "tree", "rs6000_handle_longcall_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_TYPE", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "FIELD_DECL", "&&", "TREE_CODE", "(", "*", "node", ")", "!=", "TYPE_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qs attribute only applies to functions\"", ",", "IDENTIFIER_POINTER", "(", "name", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "a", "``", "longcall", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "rs6000", "\"%qs attribute only applies to functions\"" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

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

[]

[ "<s>", "void", "X86WinAllocaExpander", "::", "lower", "(", "MachineInstr", "*", "MI", ",", "Lowering", "L", ")", "{", "const", "DebugLoc", "&", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "int64_t", "Amount", "=", "getWinAllocaAmount", "(", "MI", ",", "MRI", ")", ";", "if", "(", "Amount", "==", "0", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "return", ";", "}", "bool", "Is64Bit", "=", "STI", "->", "is64Bit", "(", ")", ";", "bool", "Is64BitAlloca", "=", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "WIN_ALLOCA_64", ";", "assert", "(", "SlotSize", "==", "4", "||", "SlotSize", "==", "8", ")", ";", "switch", "(", "L", ")", "{", "case", "TouchAndSub", ":", "{", "assert", "(", "Amount", ">=", "SlotSize", ")", ";", "unsigned", "RegA", "=", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "RegA", ",", "RegState", "::", "Undef", ")", ";", "Amount", "-=", "SlotSize", ";", "if", "(", "!", "Amount", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "}", "case", "Sub", ":", "assert", "(", "Amount", ">", "0", ")", ";", "if", "(", "Amount", "==", "SlotSize", ")", "{", "unsigned", "RegA", "=", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ")", ".", "addReg", "(", "RegA", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "getSubOpcode", "(", "Is64BitAlloca", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "break", ";", "case", "Probe", ":", "if", "(", "!", "NoStackArgProbe", ")", "{", "unsigned", "RegA", "=", "Is64BitAlloca", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "RegA", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "STI", "->", "getFrameLowering", "(", ")", "->", "emitStackProbe", "(", "*", "MBB", "->", "getParent", "(", ")", ",", "*", "MBB", ",", "MI", ",", "DL", ",", "false", ")", ";", "}", "else", "{", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Is64BitAlloca", "?", "X86", "::", "SUB64rr", ":", "X86", "::", "SUB32rr", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "}", "break", ";", "}", "Register", "AmountReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "MRI", "->", "use_empty", "(", "AmountReg", ")", ")", "if", "(", "MachineInstr", "*", "AmountDef", "=", "MRI", "->", "getUniqueVRegDef", "(", "AmountReg", ")", ")", "AmountDef", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "X86::WIN_ALLOCA_64", "4", "8", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "0", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::RAX", "X86::EAX", "0", "X86::SUB64rr", "X86::SUB32rr", "0", "0" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "EXEC", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "static", "void", "s390_register_info_gprtofpr", "(", ")", "{", "int", "save_reg_slot", "=", "FPR0_REGNUM", ";", "int", "i", ",", "j", ";", "if", "(", "TARGET_TPF", "||", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", ";", "for", "(", "i", "=", "15", ";", "i", ">=", "6", ";", "i", "--", ")", "{", "if", "(", "cfun_gpr_save_slot", "(", "i", ")", "==", "SAVE_SLOT_NONE", ")", "continue", ";", "while", "(", "(", "!", "call_used_regs", "[", "save_reg_slot", "]", "||", "df_regs_ever_live_p", "(", "save_reg_slot", ")", "||", "cfun_fpr_save_p", "(", "save_reg_slot", ")", ")", "&&", "FP_REGNO_P", "(", "save_reg_slot", ")", ")", "save_reg_slot", "++", ";", "if", "(", "!", "FP_REGNO_P", "(", "save_reg_slot", ")", ")", "{", "for", "(", "j", "=", "6", ";", "j", "<=", "15", ";", "j", "++", ")", "if", "(", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "j", ")", ")", ")", "cfun_gpr_save_slot", "(", "j", ")", "=", "SAVE_SLOT_STACK", ";", "break", ";", "}", "cfun_gpr_save_slot", "(", "i", ")", "=", "save_reg_slot", "++", ";", "}", "}", "</s>" ]

[ "Update", "gpr_save_slots", "in", "the", "frame", "layout", "trying", "to", "make", "use", "of", "FPRs", "as", "GPR", "save", "slots", ".", "This", "is", "a", "helper", "routine", "of", "s390_register_info", "." ]

[ "s390", "15", "6", "6", "15" ]

[]

[ "<s>", "static", "void", "fixup_errata", "(", ")", "{", "rtx", "insn", ";", "if", "(", "!", "TARGET_B_STEP", ")", "return", ";", "group_idx", "=", "0", ";", "memset", "(", "last_group", ",", "0", ",", "sizeof", "last_group", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "ia64_safe_type", "(", "insn", ")", "==", "TYPE_S", ")", "{", "group_idx", "^=", "1", ";", "memset", "(", "last_group", "+", "group_idx", ",", "0", ",", "sizeof", "last_group", "[", "group_idx", "]", ")", ";", "}", "else", "errata_emit_nops", "(", "insn", ")", ";", "}", "}", "</s>" ]

[ "Emit", "extra", "nops", "if", "they", "are", "required", "to", "work", "around", "hardware", "errata", "." ]

[ "ia64", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "void", "mips_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this_rtx", ",", "temp1", ",", "temp2", ",", "fnaddr", ";", "rtx_insn", "*", "insn", ";", "bool", "use_sibcall_p", ";", "reload_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "use_sibcall_p", "=", "(", "mips_function_ok_for_sibcall", "(", "function", ",", "NULL", ")", "&&", "const_call_insn_operand", "(", "fnaddr", ",", "Pmode", ")", ")", ";", "if", "(", "!", "use_sibcall_p", "&&", "(", "mips_got_symbol_type_p", "(", "mips_classify_symbol", "(", "fnaddr", ",", "SYMBOL_CONTEXT_LEA", ")", ")", ")", ")", "{", "cfun", "->", "machine", "->", "global_pointer", "=", "TARGET_CALL_SAVED_GP", "?", "15", ":", "GLOBAL_POINTER_REGNUM", ";", "cfun", "->", "machine", "->", "must_initialize_gp_p", "=", "true", ";", "SET_REGNO", "(", "pic_offset_table_rtx", ",", "cfun", "->", "machine", "->", "global_pointer", ")", ";", "mips_emit_loadgp", "(", ")", ";", "}", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "temp2", "=", "gen_rtx_REG", "(", "Pmode", ",", "3", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", "+", "1", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "delta", "!=", "0", ")", "{", "rtx", "offset", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "delta", ")", ")", "{", "mips_emit_move", "(", "temp1", ",", "offset", ")", ";", "offset", "=", "temp1", ";", "}", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "offset", ")", ")", ";", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "rtx", "addr", ";", "mips_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "addr", "=", "mips_add_offset", "(", "temp2", ",", "temp1", ",", "vcall_offset", ")", ";", "mips_emit_move", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this_rtx", ",", "this_rtx", ",", "temp1", ")", ")", ";", "}", "if", "(", "use_sibcall_p", ")", "{", "insn", "=", "emit_call_insn", "(", "gen_sibcall_internal", "(", "fnaddr", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "}", "else", "{", "if", "(", "TARGET_USE_PIC_FN_ADDR_REG", "&&", "!", "TARGET_MIPS16", "&&", "!", "mips_dangerous_for_la25_p", "(", "fnaddr", ")", ")", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "mips_load_call_address", "(", "MIPS_CALL_SIBCALL", ",", "temp1", ",", "fnaddr", ")", ";", "if", "(", "TARGET_USE_PIC_FN_ADDR_REG", "&&", "REGNO", "(", "temp1", ")", "!=", "PIC_FUNCTION_ADDR_REGNUM", ")", "mips_emit_move", "(", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ",", "temp1", ")", ";", "emit_jump_insn", "(", "gen_indirect_jump", "(", "temp1", ")", ")", ";", "}", "insn", "=", "get_insns", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "mips16_lay_out_constants", "(", "true", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Generate", "rtl", "rather", "than", "asm", "text", "in", "order", "to", "avoid", "duplicating", "too", "much", "logic", "from", "elsewhere", "." ]

[ "mips", "1", "0", "15", "2", "3", "1", "0", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "rtx", "iq2000_add_large_offset_to_sp", "(", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "IQ2000_TEMP2_REGNUM", ")", ";", "rtx", "offset_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "emit_move_insn", "(", "reg", ",", "offset_rtx", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "stack_pointer_rtx", ")", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Emit", "instructions", "to", "load", "the", "value", "(", "SP", "+", "OFFSET", ")", "into", "IQ2000_TEMP2_REGNUM", "and", "return", "an", "rtl", "expression", "for", "the", "register", ".", "Write", "the", "assembly", "instructions", "directly", "to", "FILE", "if", "it", "is", "not", "null", ",", "otherwise", "emit", "them", "as", "rtl", ".", "This", "function", "is", "a", "subroutine", "of", "save_restore_insns", ".", "It", "is", "used", "when", "OFFSET", "is", "too", "large", "to", "add", "in", "a", "single", "instruction", "." ]

[ "iq2000" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "AGC" ]

[]

[ "<s>", "int", "memory_ok_for_ldd", "(", "rtx", "op", ")", "{", "if", "(", "!", "mem_min_alignment", "(", "op", ",", "8", ")", ")", "return", "0", ";", "if", "(", "(", "reload_in_progress", "||", "reload_completed", ")", "&&", "!", "strict_memory_address_p", "(", "Pmode", ",", "XEXP", "(", "op", ",", "0", ")", ")", ")", "return", "0", ";", "if", "(", "lra_in_progress", "&&", "!", "memory_address_p", "(", "Pmode", ",", "XEXP", "(", "op", ",", "0", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", ",", "a", "MEM", ",", "has", "an", "address", "which", "is", "known", "to", "be", "aligned", "to", "an", "8-byte", "boundary", "." ]

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

[]

[ "<s>", "bool", "R600AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "ensureAlignment", "(", "Align", "(", "256", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ConfigSection", ")", ";", "EmitProgramInfoR600", "(", "MF", ")", ";", "emitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "CommentSection", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "CFStackSize", ")", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "256", "\".AMDGPU.config\"", "0", "R600", "\".AMDGPU.csdata\"", "0", "R600", "R600", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "override", "{", "if", "(", "RC", "==", "&", "M68k", "::", "CCRCRegClass", ")", "return", "&", "M68k", "::", "DR32RegClass", ";", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "M68k", "M68k::CCRCRegClass", "M68k::DR32RegClass" ]

[]

[ "<s>", "static", "bool", "ix86_frame_pointer_required", "(", "void", ")", "{", "if", "(", "cfun", "->", "machine", "->", "accesses_prev_frame", ")", "return", "true", ";", "if", "(", "SUBTARGET_FRAME_POINTER_REQUIRED", ")", "return", "true", ";", "if", "(", "TARGET_32BIT_MS_ABI", "&&", "cfun", "->", "calls_setjmp", ")", "return", "true", ";", "if", "(", "TARGET_64BIT_MS_ABI", "&&", "get_frame_size", "(", ")", ">", "SEH_MAX_FRAME_SIZE", ")", "return", "true", ";", "if", "(", "TARGET_OMIT_LEAF_FRAME_POINTER", "&&", "(", "!", "crtl", "->", "is_leaf", "||", "ix86_current_function_calls_tls_descriptor", ")", ")", "return", "true", ";", "if", "(", "crtl", "->", "profile", "&&", "!", "flag_fentry", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Value", "should", "be", "nonzero", "if", "functions", "must", "have", "frame", "pointers", ".", "Zero", "means", "the", "frame", "pointer", "need", "not", "be", "set", "up", "(", "and", "parms", "may", "be", "accessed", "via", "the", "stack", "pointer", ")", "in", "functions", "that", "seem", "suitable", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", "->", "getStackSize", "(", ")", "&&", "needsFP", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "void", "ix86_split_stlf_stall_load", "(", ")", "{", "rtx_insn", "*", "insn", ",", "*", "start", "=", "get_insns", "(", ")", ";", "unsigned", "window", "=", "0", ";", "for", "(", "insn", "=", "start", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "window", "++", ";", "if", "(", "window", ">", "(", "unsigned", ")", "x86_stlf_window_ninsns", ")", "return", ";", "if", "(", "any_uncondjump_p", "(", "insn", ")", "||", "ANY_RETURN_P", "(", "PATTERN", "(", "insn", ")", ")", "||", "CALL_P", "(", "insn", ")", ")", "return", ";", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "continue", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "!", "MEM_P", "(", "src", ")", "||", "GET_MODE", "(", "src", ")", "!=", "E_V2DFmode", "||", "!", "MEM_EXPR", "(", "src", ")", "||", "TREE_CODE", "(", "get_base_address", "(", "MEM_EXPR", "(", "src", ")", ")", ")", "!=", "PARM_DECL", ")", "continue", ";", "rtx", "zero", "=", "CONST0_RTX", "(", "V2DFmode", ")", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "m", "=", "adjust_address", "(", "src", ",", "DFmode", ",", "0", ")", ";", "rtx", "loadlpd", "=", "gen_sse2_loadlpd", "(", "dest", ",", "zero", ",", "m", ")", ";", "emit_insn_before", "(", "loadlpd", ",", "insn", ")", ";", "m", "=", "adjust_address", "(", "src", ",", "DFmode", ",", "8", ")", ";", "rtx", "loadhpd", "=", "gen_sse2_loadhpd", "(", "dest", ",", "dest", ",", "m", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "fputs", "(", "\"Due to potential STLF stall, split instruction:\\n\"", ",", "dump_file", ")", ";", "print_rtl_single", "(", "dump_file", ",", "insn", ")", ";", "fputs", "(", "\"To:\\n\"", ",", "dump_file", ")", ";", "print_rtl_single", "(", "dump_file", ",", "loadlpd", ")", ";", "print_rtl_single", "(", "dump_file", ",", "loadhpd", ")", ";", "}", "PATTERN", "(", "insn", ")", "=", "loadhpd", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "gcc_assert", "(", "recog_memoized", "(", "insn", ")", "!=", "-", "1", ")", ";", "}", "}", "</s>" ]

[ "Split", "vector", "load", "from", "parm_decl", "to", "elemental", "loads", "to", "avoid", "STLF", "stalls", "." ]

[ "i386", "0", "0", "8", "\"Due to potential STLF stall, split instruction:\\n\"", "\"To:\\n\"", "1", "1" ]

[]