Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "UPT", "0" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ",", "CodeGenCoverage", "&", "CoverageInfo", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "Opcode", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "return", "false", ";", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "MRI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "if", "(", "selectImpl", "(", "I", ",", "CoverageInfo", ")", ")", "return", "true", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" C++ instruction selection: \"", ";", "I", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "switch", "(", "I", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TargetOpcode", "::", "G_STORE", ":", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "selectLoadStoreOp", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_GEP", ":", "case", "TargetOpcode", "::", "G_FRAME_INDEX", ":", "return", "selectFrameIndexOrGep", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "selectGlobalValue", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_CONSTANT", ":", "return", "selectConstant", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "return", "materializeFP", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_PTRTOINT", ":", "case", "TargetOpcode", "::", "G_TRUNC", ":", "return", "selectTruncOrPtrToInt", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_INTTOPTR", ":", "return", "selectCopy", "(", "I", ",", "MRI", ")", ";", "case", "TargetOpcode", "::", "G_ZEXT", ":", "return", "selectZext", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "return", "selectAnyext", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_ICMP", ":", "return", "selectCmp", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_UADDE", ":", "return", "selectUadde", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_UNMERGE_VALUES", ":", "return", "selectUnmergeValues", "(", "I", ",", "MRI", ",", "MF", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_MERGE_VALUES", ":", "return", "selectMergeValues", "(", "I", ",", "MRI", ",", "MF", ",", "CoverageInfo", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT", ":", "return", "selectExtract", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_INSERT", ":", "return", "selectInsert", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_BRCOND", ":", "return", "selectCondBranch", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "G_PHI", ":", "return", "selectImplicitDefOrPHI", "(", "I", ",", "MRI", ")", ";", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "return", "selectShift", "(", "I", ",", "MRI", ",", "MF", ")", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "return", "selectSDiv", "(", "I", ",", "MRI", ",", "MF", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"", "\" C++ instruction selection: \"" ]

[]

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

[ "Enable", "the", "use", "of", "the", "early", "if", "conversion", "pass", "." ]

[ "PowerPC" ]

[]

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

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

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

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "bool", "Is64Bit", "=", "Subtarget", "->", "is64Bit", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_X86", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "EVT", "CopyVT", "=", "VA", ".", "getValVT", "(", ")", ";", "if", "(", "(", "CopyVT", "==", "MVT", "::", "f32", "||", "CopyVT", "==", "MVT", "::", "f64", ")", "&&", "(", "(", "Is64Bit", "||", "Ins", "[", "i", "]", ".", "Flags", ".", "isInReg", "(", ")", ")", "&&", "!", "Subtarget", "->", "hasSSE1", "(", ")", ")", ")", "{", "report_fatal_error", "(", "\"SSE register return with SSE disabled\"", ")", ";", "}", "if", "(", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "ST1", ")", "&&", "isScalarFPTypeInSSEReg", "(", "VA", ".", "getValVT", "(", ")", ")", ")", "{", "CopyVT", "=", "MVT", "::", "f80", ";", "}", "SDValue", "Val", ";", "if", "(", "Is64Bit", "&&", "CopyVT", ".", "isVector", "(", ")", "&&", "CopyVT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "{", "if", "(", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "XMM0", "||", "VA", ".", "getLocReg", "(", ")", "==", "X86", "::", "XMM1", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "v2i64", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "MVT", "::", "i64", ",", "Val", ",", "DAG", ".", "getConstant", "(", "0", ",", "MVT", "::", "i64", ")", ")", ";", "}", "else", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i64", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "}", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BIT_CONVERT", ",", "dl", ",", "CopyVT", ",", "Val", ")", ";", "}", "else", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "CopyVT", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "Val", "=", "Chain", ".", "getValue", "(", "0", ")", ";", "}", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "if", "(", "CopyVT", "!=", "VA", ".", "getValVT", "(", ")", ")", "{", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FP_ROUND", ",", "dl", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ",", "DAG", ".", "getIntPtrConstant", "(", "1", ")", ")", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::InputArg", "16", "X86", "0", "MVT::f32", "MVT::f64", "\"SSE register return with SSE disabled\"", "X86::ST0", "X86::ST1", "MVT::f80", "64", "X86::XMM0", "X86::XMM1", "MVT::v2i64", "1", "0", "ISD::EXTRACT_VECTOR_ELT", "MVT::i64", "0", "MVT::i64", "MVT::i64", "1", "0", "ISD::BIT_CONVERT", "1", "0", "2", "ISD::FP_ROUND", "1" ]

[]

[ "<s>", "bool", "nds32_gw_last_load_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "last_def_reg", "=", "extract_nth_access_reg", "(", "producer", ",", "-", "1", ")", ";", "return", "gw_consumed_by_ex_dep_p", "(", "consumer", ",", "last_def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "LMW", "(", "N", ",", "N", ")", "to", "EX", "." ]

[ "nds32", "1" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "SCS", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "ShadowCallStack", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "SCS", "?", "CSR_AArch64_NoRegs_SCS_RegMask", ":", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "SCS", "?", "CSR_AArch64_AllRegs_SCS_RegMask", ":", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "SCS", ")", "report_fatal_error", "(", "\"ShadowCallStack attribute not supported on Darwin.\"", ")", ";", "return", "getDarwinCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "SCS", "?", "CSR_AArch64_AAVPCS_SCS_RegMask", ":", "CSR_AArch64_AAVPCS_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "SCS", "?", "CSR_AArch64_SVE_AAPCS_SCS_RegMask", ":", "CSR_AArch64_SVE_AAPCS_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "SCS", "?", "CSR_AArch64_AAPCS_SwiftError_SCS_RegMask", ":", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "SCS", "?", "CSR_AArch64_RT_MostRegs_SCS_RegMask", ":", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "SCS", "?", "CSR_AArch64_AAPCS_SCS_RegMask", ":", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"ShadowCallStack attribute not supported on Darwin.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "PULPFixupHwLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "{", "return", "false", ";", "}", "bool", "fixedPreHd", "=", "fixupLoopPreheader", "(", "MF", ")", ";", "bool", "fixedLatch", "=", "fixupLoopLatch", "(", "MF", ")", ";", "bool", "fixedInstr", "=", "fixupLoopInstrs", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "unsigned", "instrs", "=", "0", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "instrs", "++", ";", "if", "(", "isHardwareLoop", "(", "MI", ")", "&&", "instrs", ">", "1", ")", "{", "MachineBasicBlock", "*", "New", "=", "splitMBBAt", "(", "&", "MBB", ",", "MI", ")", ";", "if", "(", "New", "==", "&", "MBB", ")", "{", "continue", ";", "}", "New", "->", "setAlignment", "(", "Align", "(", "4", ")", ")", ";", "break", ";", "}", "}", "}", "return", "fixedPreHd", "||", "fixedLatch", "||", "fixedInstr", ";", "}", "</s>" ]

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

[ "RI5CY", "0", "1", "4" ]

[]

[ "<s>", "static", "void", "aarch64_parse_tune_string", "(", "const", "char", "*", "tune_string", ",", "struct", "tune_params", "*", "tune", ")", "{", "tune", "->", "extra_tuning_flags", "=", "aarch64_parse_boolean_options", "(", "tune_string", ",", "aarch64_tuning_flags", ",", "tune", "->", "extra_tuning_flags", ",", "\"tune=\"", ")", ";", "}", "</s>" ]

[ "Support", "for", "overriding", "other", "tuning", "flags", "." ]

[ "aarch64", "\"tune=\"" ]

[]

[ "<s>", "static", "bool", "cbranch_predicted_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "x", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "x", ")", "{", "int", "pred_val", "=", "XINT", "(", "x", ",", "0", ")", ";", "return", "pred_val", ">=", "REG_BR_PROB_BASE", "/", "2", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "annotated", "with", "a", "REG_BR_PROB", "note", "that", "indicates", "it", "'s", "a", "branch", "that", "'s", "predicted", "taken", "." ]

[ "tilepro", "0", "0", "2" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon constant-extender optimization\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon constant-extender optimization\"" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FPW", "MSP430::MOV16rr", "MSP430::FPW", "MSP430::SPW", "MSP430::FPW", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Local Dynamic TLS Access Clean-up\"", ";", "}", "</s>" ]

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

[ "X86", "\"Local Dynamic TLS Access Clean-up\"" ]

[]

[ "<s>", "static", "void", "emit_unlikely_jump", "(", "rtx", "insn", ")", "{", "int", "very_unlikely", "=", "REG_BR_PROB_BASE", "/", "100", "-", "1", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn", "(", "insn", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "very_unlikely", ")", ";", "}", "</s>" ]

[ "Mark", "the", "previous", "jump", "instruction", "as", "unlikely", "." ]

[ "arc", "100", "1" ]

[]

[ "<s>", "bool", "shouldNormalizeToSelectSequence", "(", "LLVMContext", "&", ",", "EVT", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "we", "should", "normalize", "select", "(", "N0", "&", "N1", ",", "X", ",", "Y", ")", "=", ">", "select", "(", "N0", ",", "select", "(", "N1", ",", "X", ",", "Y", ")", ",", "Y", ")", "and", "select", "(", "N0|N1", ",", "X", ",", "Y", ")", "=", ">", "select", "(", "N0", ",", "select", "(", "N1", ",", "X", ",", "Y", ",", "Y", ")", ")", "if", "it", "is", "likely", "that", "it", "saves", "us", "from", "materializing", "N0", "and", "N1", "in", "an", "integer", "register", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "isUnspillableTerminatorImpl", "(", "const", "MachineInstr", "*", "MI", ")", "const", "override", "{", "return", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopEndDec", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2DoLoopStartTP", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2WhileLoopStartLR", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "terminator", "MI", "is", "not", "expected", "to", "spill", "." ]

[ "ARM", "ARM::t2LoopEndDec", "ARM::t2DoLoopStartTP", "ARM::t2WhileLoopStartLR" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "getDataLayout", "(", ")", ".", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "for", "(", "const", "Function", "*", "Personality", ":", "MMI", "->", "getPersonalities", "(", ")", ")", "{", "if", "(", "Personality", ")", "{", "MCSymbol", "*", "NLPSym", "=", "getSymbolWithGlobalValueBase", "(", "Personality", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "Personality", ")", ",", "true", ")", ";", "}", "}", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", "->", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "else", "OutStreamer", "->", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "PPC", "8", "4" ]

[]

[ "<s>", "bool", "CJGInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", "&&", "\"Invalid Xbranch condition!\"", ")", ";", "CJGCC", "::", "CondCodes", "CC", "=", "static_cast", "<", "CJGCC", "::", "CondCodes", ">", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid branch condition!\"", ")", ";", "case", "CJGCC", "::", "COND_C", ":", "CC", "=", "CJGCC", "::", "COND_NC", ";", "break", ";", "case", "CJGCC", "::", "COND_N", ":", "CC", "=", "CJGCC", "::", "COND_NN", ";", "break", ";", "case", "CJGCC", "::", "COND_V", ":", "CC", "=", "CJGCC", "::", "COND_NV", ";", "break", ";", "case", "CJGCC", "::", "COND_Z", ":", "CC", "=", "CJGCC", "::", "COND_NZ", ";", "break", ";", "case", "CJGCC", "::", "COND_GE", ":", "CC", "=", "CJGCC", "::", "COND_L", ";", "break", ";", "case", "CJGCC", "::", "COND_NC", ":", "CC", "=", "CJGCC", "::", "COND_C", ";", "break", ";", "case", "CJGCC", "::", "COND_NN", ":", "CC", "=", "CJGCC", "::", "COND_N", ";", "break", ";", "case", "CJGCC", "::", "COND_NV", ":", "CC", "=", "CJGCC", "::", "COND_V", ";", "break", ";", "case", "CJGCC", "::", "COND_NZ", ":", "CC", "=", "CJGCC", "::", "COND_Z", ";", "break", ";", "case", "CJGCC", "::", "COND_L", ":", "CC", "=", "CJGCC", "::", "COND_GE", ";", "break", ";", "}", "Cond", "[", "0", "]", ".", "setImm", "(", "CC", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "1", "\"Invalid Xbranch condition!\"", "CJGCC::CondCodes", "CJGCC::CondCodes", "0", "\"Invalid branch condition!\"", "CJGCC::COND_C", "CJGCC::COND_NC", "CJGCC::COND_N", "CJGCC::COND_NN", "CJGCC::COND_V", "CJGCC::COND_NV", "CJGCC::COND_Z", "CJGCC::COND_NZ", "CJGCC::COND_GE", "CJGCC::COND_L", "CJGCC::COND_NC", "CJGCC::COND_C", "CJGCC::COND_NN", "CJGCC::COND_N", "CJGCC::COND_NV", "CJGCC::COND_V", "CJGCC::COND_NZ", "CJGCC::COND_Z", "CJGCC::COND_L", "CJGCC::COND_GE", "0" ]

[]

[ "<s>", "static", "bool", "rx_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", ")", "{", "return", "REGNO_REG_CLASS", "(", "regno", ")", "==", "GR_REGS", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "rx" ]

[]

[ "<s>", "bool", "TOYRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "static", "bool", "aarch64_vfp_is_call_or_return_candidate", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "machine_mode", "*", "base_mode", ",", "int", "*", "count", ",", "bool", "*", "is_ha", ",", "bool", "silent_p", ")", "{", "if", "(", "is_ha", "!=", "NULL", ")", "*", "is_ha", "=", "false", ";", "machine_mode", "new_mode", "=", "VOIDmode", ";", "bool", "composite_p", "=", "aarch64_composite_type_p", "(", "type", ",", "mode", ")", ";", "if", "(", "(", "!", "composite_p", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "||", "aarch64_short_vector_p", "(", "type", ",", "mode", ")", ")", "{", "*", "count", "=", "1", ";", "new_mode", "=", "mode", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "{", "if", "(", "is_ha", "!=", "NULL", ")", "*", "is_ha", "=", "true", ";", "*", "count", "=", "2", ";", "new_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "}", "else", "if", "(", "type", "&&", "composite_p", ")", "{", "unsigned", "int", "warn_psabi_flags", "=", "0", ";", "int", "ag_count", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new_mode", ",", "&", "warn_psabi_flags", ")", ";", "if", "(", "ag_count", ">", "0", "&&", "ag_count", "<=", "HA_MAX_NUM_FLDS", ")", "{", "static", "unsigned", "last_reported_type_uid", ";", "unsigned", "uid", "=", "TYPE_UID", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "int", "alt", ";", "if", "(", "!", "silent_p", "&&", "warn_psabi", "&&", "warn_psabi_flags", "&&", "uid", "!=", "last_reported_type_uid", "&&", "(", "(", "alt", "=", "aapcs_vfp_sub_candidate", "(", "type", ",", "&", "new_mode", ",", "NULL", ")", ")", "!=", "ag_count", ")", ")", "{", "const", "char", "*", "url", "=", "CHANGES_ROOT_URL", "\"gcc-10/changes.html#empty_base\"", ";", "gcc_assert", "(", "alt", "==", "-", "1", ")", ";", "last_reported_type_uid", "=", "uid", ";", "if", "(", "warn_psabi_flags", "&", "WARN_PSABI_NO_UNIQUE_ADDRESS", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT with %<[[no_unique_address]]%> members \"", "\"changed %{in GCC 10.1%}\"", ",", "TYPE_MAIN_VARIANT", "(", "type", ")", ",", "url", ")", ";", "else", "if", "(", "warn_psabi_flags", "&", "WARN_PSABI_EMPTY_CXX17_BASE", ")", "inform", "(", "input_location", ",", "\"parameter passing for argument of \"", "\"type %qT when C++17 is enabled changed to match \"", "\"C++14 %{in GCC 10.1%}\"", ",", "TYPE_MAIN_VARIANT", "(", "type", ")", ",", "url", ")", ";", "}", "if", "(", "is_ha", "!=", "NULL", ")", "*", "is_ha", "=", "true", ";", "*", "count", "=", "ag_count", ";", "}", "else", "return", "false", ";", "}", "else", "return", "false", ";", "gcc_assert", "(", "!", "aarch64_sve_mode_p", "(", "new_mode", ")", ")", ";", "*", "base_mode", "=", "new_mode", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "an", "argument", ",", "whose", "type", "is", "described", "by", "TYPE", "and", "MODE", ",", "shall", "be", "passed", "or", "returned", "in", "simd/fp", "register", "(", "s", ")", "(", "providing", "these", "parameter", "passing", "registers", "are", "available", ")", ".", "Upon", "successful", "return", ",", "*", "COUNT", "returns", "the", "number", "of", "needed", "registers", ",", "*", "BASE_MODE", "returns", "the", "mode", "of", "the", "individual", "register", "and", "when", "IS_HAF", "is", "not", "NULL", ",", "*", "IS_HA", "indicates", "whether", "or", "not", "the", "argument", "is", "a", "homogeneous", "floating-point", "aggregate", "or", "a", "homogeneous", "short-vector", "aggregate", "." ]

[ "aarch64", "1", "2", "0", "0", "\"gcc-10/changes.html#empty_base\"", "1", "\"parameter passing for argument of \"", "\"type %qT with %<[[no_unique_address]]%> members \"", "\"changed %{in GCC 10.1%}\"", "\"parameter passing for argument of \"", "\"type %qT when C++17 is enabled changed to match \"", "\"C++14 %{in GCC 10.1%}\"" ]

[]

[ "<s>", "void", "arm_options_perform_arch_sanity_checks", "(", "void", ")", "{", "if", "(", "TARGET_INTERWORK", ")", "arm_cpp_interwork", "=", "1", ";", "if", "(", "arm_arch5t", ")", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "if", "(", "TARGET_IWMMXT", "&&", "!", "ARM_DOUBLEWORD_ALIGN", ")", "error", "(", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", ")", ";", "if", "(", "TARGET_IWMMXT_ABI", "&&", "!", "TARGET_IWMMXT", ")", "error", "(", "\"iwmmxt abi requires an iwmmxt capable cpu\"", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "TARGET_BPABI", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support interworking\"", ")", ";", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "arm_fpu_attr", "=", "FPU_NONE", ";", "else", "arm_fpu_attr", "=", "FPU_VFP", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "TARGET_CALLER_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", ")", ";", "else", "if", "(", "TARGET_CALLEE_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", ")", ";", "}", "if", "(", "!", "arm_arch4", "&&", "arm_fp16_format", "!=", "ARM_FP16_FORMAT_NONE", ")", "sorry", "(", "\"__fp16 and no ldrh\"", ")", ";", "if", "(", "use_cmse", "&&", "!", "arm_arch_cmse", ")", "error", "(", "\"target CPU does not support ARMv8-M Security Extensions\"", ")", ";", "if", "(", "use_cmse", "&&", "LAST_VFP_REGNUM", ">", "LAST_LO_VFP_REGNUM", ")", "error", "(", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", ")", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "arm_abi", "==", "ARM_ABI_IWMMXT", ")", "arm_pcs_default", "=", "ARM_PCS_AAPCS_IWMMXT", ";", "else", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "arm_pcs_default", "=", "ARM_PCS_AAPCS_VFP", ";", "if", "(", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_vfpv2", ")", ")", "error", "(", "\"%<-mfloat-abi=hard%>: selected processor lacks an FPU\"", ")", ";", "}", "else", "arm_pcs_default", "=", "ARM_PCS_AAPCS", ";", "}", "else", "{", "if", "(", "arm_float_abi", "==", "ARM_FLOAT_ABI_HARD", ")", "sorry", "(", "\"%<-mfloat-abi=hard%> and VFP\"", ")", ";", "if", "(", "arm_abi", "==", "ARM_ABI_APCS", ")", "arm_pcs_default", "=", "ARM_PCS_APCS", ";", "else", "arm_pcs_default", "=", "ARM_PCS_ATPCS", ";", "}", "}", "</s>" ]

[ "Perform", "some", "validation", "between", "the", "desired", "architecture", "and", "the", "rest", "of", "the", "options", "." ]

[ "arm", "1", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", "\"iwmmxt abi requires an iwmmxt capable cpu\"", "0", "\"target CPU does not support interworking\"", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", "\"__fp16 and no ldrh\"", "\"target CPU does not support ARMv8-M Security Extensions\"", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", "\"%<-mfloat-abi=hard%>: selected processor lacks an FPU\"", "\"%<-mfloat-abi=hard%> and VFP\"" ]

[]

[ "<s>", "bool", "AArch64StorePairSuppress", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "SchedModel", ".", "init", "(", "ST", ".", "getSchedModel", "(", ")", ",", "&", "ST", ",", "TII", ")", ";", "Traces", "=", "&", "getAnalysis", "<", "MachineTraceMetrics", ">", "(", ")", ";", "MinInstr", "=", "nullptr", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Skipping pass: no machine model present.\\n\"", ")", ";", "return", "false", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "bool", "SuppressSTP", "=", "false", ";", "unsigned", "PrevBaseReg", "=", "0", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "isNarrowFPStore", "(", "MI", ")", ")", "continue", ";", "unsigned", "BaseReg", ";", "int64_t", "Offset", ";", "if", "(", "TII", "->", "getMemOpBaseRegImmOfs", "(", "&", "MI", ",", "BaseReg", ",", "Offset", ",", "TRI", ")", ")", "{", "if", "(", "PrevBaseReg", "==", "BaseReg", ")", "{", "if", "(", "!", "SuppressSTP", "&&", "shouldAddSTPToBlock", "(", "MI", ".", "getParent", "(", ")", ")", ")", "break", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unpairing store \"", "<<", "MI", "<<", "\"\\n\"", ")", ";", "SuppressSTP", "=", "true", ";", "TII", "->", "suppressLdStPair", "(", "&", "MI", ")", ";", "}", "PrevBaseReg", "=", "BaseReg", ";", "}", "else", "PrevBaseReg", "=", "0", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"*** \"", "\": \"", "\" Skipping pass: no machine model present.\\n\"", "0", "\"Unpairing store \"", "\"\\n\"", "0" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getMaxSupportedInterleaveFactor", "(", ")", "const", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "4", ";", "return", "TargetLoweringBase", "::", "getMaxSupportedInterleaveFactor", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "maximum", "supported", "factor", "for", "interleaved", "memory", "accesses", "." ]

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

[]

[ "<s>", "bool", "X86Subtarget", "::", "isLegalToCallImmediateAddr", "(", ")", "const", "{", "if", "(", "In64BitMode", "||", "isTargetWin32", "(", ")", ")", "return", "false", ";", "return", "isTargetELF", "(", ")", "||", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "subtarget", "allows", "calls", "to", "immediate", "address", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "rtx", "mn10300_builtin_saveregs", "(", ")", "{", "rtx", "offset", ",", "mem", ";", "tree", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "int", "argadj", "=", "(", "(", "!", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ")", "?", "UNITS_PER_WORD", ":", "0", ")", ";", "int", "set", "=", "get_varargs_alias_set", "(", ")", ";", "if", "(", "argadj", ")", "offset", "=", "plus_constant", "(", "current_function_arg_offset_rtx", ",", "argadj", ")", ";", "else", "offset", "=", "current_function_arg_offset_rtx", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "current_function_internal_arg_pointer", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "0", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "current_function_internal_arg_pointer", ",", "4", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ")", ";", "return", "copy_to_reg", "(", "expand_binop", "(", "Pmode", ",", "add_optab", ",", "current_function_internal_arg_pointer", ",", "offset", ",", "0", ",", "0", ",", "OPTAB_LIB_WIDEN", ")", ")", ";", "}", "</s>" ]

[ "Flush", "the", "argument", "registers", "to", "the", "stack", "for", "a", "stdarg", "function", ";", "return", "the", "new", "argument", "pointer", "." ]

[ "mn10300", "0", "0", "0", "4", "1", "0", "0" ]

[]

[ "<s>", "static", "tree", "gcn_reduction_update", "(", "location_t", "loc", ",", "gimple_stmt_iterator", "*", "gsi", ",", "tree", "ptr", ",", "tree", "var", ",", "tree_code", "op", ")", "{", "tree", "type", "=", "TREE_TYPE", "(", "var", ")", ";", "tree", "size", "=", "TYPE_SIZE", "(", "type", ")", ";", "if", "(", "size", "==", "TYPE_SIZE", "(", "unsigned_type_node", ")", "||", "size", "==", "TYPE_SIZE", "(", "long_long_unsigned_type_node", ")", ")", "return", "gcn_lockless_update", "(", "loc", ",", "gsi", ",", "ptr", ",", "var", ",", "op", ")", ";", "else", "return", "gcn_lockfull_update", "(", "loc", ",", "gsi", ",", "ptr", ",", "var", ",", "op", ")", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "to", "update", "a", "reduction", "accumulator", "at", "*", "PTR", "with", "the", "value", "held", "in", "VAR", "using", "operator", "OP", ".", "Return", "the", "updated", "value", ".", "TODO", ":", "optimize", "for", "atomic", "ops", "and", "independent", "complex", "ops", "." ]

[ "gcn" ]

[]

[ "<s>", "bool", "PPCLoopPreIncPrep", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "I", "=", "LI", "->", "begin", "(", ")", ",", "IE", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "*", "I", ")", ",", "LE", "=", "df_end", "(", "*", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "MadeChange", "|=", "runOnLoop", "(", "*", "L", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

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

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "TGSI" ]

[]

[ "<s>", "static", "void", "process_epilogue", "(", ")", "{", "if", "(", "block_num", "!=", "n_basic_blocks", "-", "1", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.label_state 1\\n\"", ")", ";", "need_copy_state", "=", "1", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\t.restore sp\\n\"", ")", ";", "}", "</s>" ]

[ "The", "function", "emits", "unwind", "directives", "for", "the", "start", "of", "an", "epilogue", "." ]

[ "ia64", "1", "\"\\t.label_state 1\\n\"", "1", "\"\\t.restore sp\\n\"" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Register Stackify\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "CMPPDrri", ":", "case", "X86", "::", "CMPPSrri", ":", "case", "X86", "::", "VCMPPDrri", ":", "case", "X86", "::", "VCMPPSrri", ":", "case", "X86", "::", "VCMPPDYrri", ":", "case", "X86", "::", "VCMPPSYrri", ":", "{", "unsigned", "Imm", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "&", "0x7", ";", "switch", "(", "Imm", ")", "{", "case", "0x00", ":", "case", "0x03", ":", "case", "0x04", ":", "case", "0x07", ":", "return", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "1", ",", "2", ")", ";", "}", "return", "false", ";", "}", "default", ":", "if", "(", "isFMA3", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "return", "findFMA3CommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "X86", "X86", "X86::CMPPDrri", "X86::CMPPSrri", "X86::VCMPPDrri", "X86::VCMPPSrri", "X86::VCMPPDYrri", "X86::VCMPPSYrri", "3", "0x7", "0x00", "0x03", "0x04", "0x07", "1", "2" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass" ]

[]

[ "<s>", "int", "fmpyaddoperands", "(", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "if", "(", "mode", "!=", "SFmode", "&&", "mode", "!=", "DFmode", ")", "return", "0", ";", "if", "(", "!", "(", "mode", "==", "GET_MODE", "(", "operands", "[", "1", "]", ")", "&&", "mode", "==", "GET_MODE", "(", "operands", "[", "2", "]", ")", "&&", "mode", "==", "GET_MODE", "(", "operands", "[", "3", "]", ")", "&&", "mode", "==", "GET_MODE", "(", "operands", "[", "4", "]", ")", "&&", "mode", "==", "GET_MODE", "(", "operands", "[", "5", "]", ")", ")", ")", "return", "0", ";", "if", "(", "!", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "3", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "4", "]", ")", "==", "REG", "&&", "GET_CODE", "(", "operands", "[", "5", "]", ")", "==", "REG", ")", ")", "return", "0", ";", "if", "(", "!", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "operands", "[", "4", "]", ")", "&&", "!", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "operands", "[", "5", "]", ")", ")", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "operands", "[", "0", "]", ")", "||", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "operands", "[", "1", "]", ")", "||", "rtx_equal_p", "(", "operands", "[", "3", "]", ",", "operands", "[", "2", "]", ")", ")", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "operands", "[", "4", "]", ",", "operands", "[", "0", "]", ")", "||", "rtx_equal_p", "(", "operands", "[", "5", "]", ",", "operands", "[", "0", "]", ")", ")", "return", "0", ";", "if", "(", "mode", "==", "SFmode", "&&", "(", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "0", "]", ")", ")", "!=", "FPUPPER_REGS", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "!=", "FPUPPER_REGS", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "2", "]", ")", ")", "!=", "FPUPPER_REGS", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "3", "]", ")", ")", "!=", "FPUPPER_REGS", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "4", "]", ")", ")", "!=", "FPUPPER_REGS", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "operands", "[", "5", "]", ")", ")", "!=", "FPUPPER_REGS", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Returns", "1", "if", "the", "6", "operands", "specified", "in", "OPERANDS", "are", "suitable", "for", "use", "in", "fmpyadd", "instructions", "." ]

[ "pa", "0", "0", "1", "2", "3", "4", "5", "0", "1", "2", "3", "4", "5", "0", "3", "4", "3", "5", "0", "3", "0", "3", "1", "3", "2", "0", "4", "0", "5", "0", "0", "0", "1", "2", "3", "4", "5", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Load Value Injection (LVI) Load Hardening\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Load Value Injection (LVI) Load Hardening\"" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreRegAlloc", "(", "PassManagerBase", "&", "PM", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "Subtarget", ".", "isCortexA9", "(", ")", ")", "PM", ".", "add", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "AArch64FI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "STI", "=", "static_cast", "<", "const", "AArch64Subtarget", "*", ">", "(", "&", "MF", ".", "getSubtarget", "(", ")", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "STI", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Internal", "=", "MF", ".", "getFunction", "(", ")", ".", "hasInternalLinkage", "(", ")", ";", "COFF", "::", "SymbolStorageClass", "Scl", "=", "Internal", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ";", "int", "Type", "=", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Scl", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "Type", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "NyuziTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineBlockFrequencyInfo", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "WebAssembly" ]

[]

[ "<s>", "int", "X86FrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "else", "if", "(", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ")", "FrameReg", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "else", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "getFrameIndexOffset", "(", "MF", ",", "FI", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "int", "ia64_spec_check_src_p", "(", "rtx", "src", ")", "{", "if", "(", "GET_CODE", "(", "src", ")", "==", "IF_THEN_ELSE", ")", "{", "rtx", "t", ";", "t", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "t", ")", "==", "NE", ")", "{", "t", "=", "XEXP", "(", "t", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "t", ")", "==", "UNSPEC", ")", "{", "int", "code", ";", "code", "=", "XINT", "(", "t", ",", "1", ")", ";", "if", "(", "code", "==", "UNSPEC_LDCCLR", "||", "code", "==", "UNSPEC_LDCNC", "||", "code", "==", "UNSPEC_CHKACLR", "||", "code", "==", "UNSPEC_CHKANC", "||", "code", "==", "UNSPEC_CHKS", ")", "{", "gcc_assert", "(", "code", "!=", "0", ")", ";", "return", "code", ";", "}", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", ",", "if", "SRC", "belongs", "to", "recovery", "check", "." ]

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

[]

[ "<s>", "static", "int", "pdp11_addr_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", ")", "{", "int", "cost", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "REG", ")", "{", "if", "(", "!", "simple_memory_operand", "(", "addr", ",", "mode", ")", ")", "cost", "=", "2", ";", "if", "(", "speed", "&&", "!", "CONSTANT_P", "(", "addr", ")", ")", "cost", "+=", "(", "mode", "==", "QImode", ")", "?", "2", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "accessing", "the", "supplied", "operand", ".", "Registers", "are", "free", ".", "Anything", "else", "starts", "with", "a", "cost", "of", "two", ".", "Add", "to", "that", "for", "memory", "references", "the", "memory", "accesses", "of", "the", "addressing", "mode", "(", "if", "any", ")", "plus", "the", "data", "reference", ";", "for", "other", "operands", "just", "the", "memory", "access", "(", "if", "any", ")", "for", "the", "mode", "." ]

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

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "unsigned", "MaxNumSGPRs", "=", "getMaxNumSGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumSGPRs", ";", "i", "<", "TotalNumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "unsigned", "MaxNumVGPRs", "=", "getMaxNumVGPRs", "(", "MF", ")", ";", "unsigned", "TotalNumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxNumVGPRs", ";", "i", "<", "TotalNumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister" ]

[]

[ "<s>", "static", "const", "char", "*", "mips16_call_stub_mode_suffix", "(", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "return", "\"sf\"", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "return", "\"df\"", ";", "else", "if", "(", "mode", "==", "SCmode", ")", "return", "\"sc\"", ";", "else", "if", "(", "mode", "==", "DCmode", ")", "return", "\"dc\"", ";", "else", "if", "(", "mode", "==", "V2SFmode", ")", "{", "gcc_assert", "(", "TARGET_PAIRED_SINGLE_FLOAT", ")", ";", "return", "\"df\"", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "two-character", "string", "that", "identifies", "floating-point", "return", "mode", "MODE", "in", "the", "name", "of", "a", "MIPS16", "function", "stub", "." ]

[ "mips", "\"sf\"", "\"df\"", "\"sc\"", "\"dc\"", "\"df\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "iq2000_starting_frame_offset", "(", "void", ")", "{", "return", "crtl", "->", "outgoing_args_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", "." ]

[ "iq2000" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "releaseSucc", "(", "SUnit", "*", "SU", ",", "SDep", "*", "SuccEdge", ")", "{", "SUnit", "*", "SuccSU", "=", "SuccEdge", "->", "getSUnit", "(", ")", ";", "if", "(", "SuccEdge", "->", "isWeak", "(", ")", ")", "{", "--", "SuccSU", "->", "WeakPredsLeft", ";", "return", ";", "}", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", ")", "{", "dbgs", "(", ")", "<<", "\"*** Scheduling failed! ***\\n\"", ";", "SuccSU", "->", "dump", "(", "this", ")", ";", "dbgs", "(", ")", "<<", "\" has been released too many times!\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "--", "SuccSU", "->", "NumPredsLeft", ";", "if", "(", "SuccSU", "->", "NumPredsLeft", "==", "0", "&&", "SuccSU", "!=", "&", "ExitSU", ")", "SchedImpl", "->", "releaseTopNode", "(", "SuccSU", ")", ";", "}", "</s>" ]

[ "ReleaseSucc", "-", "Decrement", "the", "NumPredsLeft", "count", "of", "a", "successor", "." ]

[ "Patmos", "0", "\"*** Scheduling failed! ***\\n\"", "\" has been released too many times!\\n\"", "0", "0" ]

[]

[ "<s>", "const", "X86InstrInfo", "*", "getInstrInfo", "(", ")", "{", "return", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "AVRFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "AVR", "::", "R29", ")", ";", "SavedRegs", ".", "set", "(", "AVR", "::", "R28", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "AVR", "AVR", "AVR::R29", "AVR::R28" ]

[]

[ "<s>", "static", "bool", "optimizeCall", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "&", "MRI", ",", "MachineDominatorTree", "&", "MDT", ",", "LiveIntervals", "&", "LIS", ",", "const", "WebAssemblyTargetLowering", "&", "TLI", ",", "const", "TargetLibraryInfo", "&", "LibInfo", ")", "{", "MachineOperand", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "Op1", ".", "isSymbol", "(", ")", ")", "return", "false", ";", "StringRef", "Name", "(", "Op1", ".", "getSymbolName", "(", ")", ")", ";", "bool", "callReturnsInput", "=", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMCPY", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMMOVE", ")", "||", "Name", "==", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ";", "if", "(", "!", "callReturnsInput", ")", "return", "false", ";", "LibFunc", "::", "Func", "Func", ";", "if", "(", "!", "LibInfo", ".", "getLibFunc", "(", "Name", ",", "Func", ")", ")", "return", "false", ";", "unsigned", "FromReg", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "unsigned", "ToReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MRI", ".", "getRegClass", "(", "FromReg", ")", "!=", "MRI", ".", "getRegClass", "(", "ToReg", ")", ")", "report_fatal_error", "(", "\"Store results: call to builtin function with wrong \"", "\"signature, from/to mismatch\"", ")", ";", "return", "ReplaceDominatedUses", "(", "MBB", ",", "MI", ",", "FromReg", ",", "ToReg", ",", "MRI", ",", "MDT", ",", "LIS", ")", ";", "}", "</s>" ]

[ "optimizeCall", "-", "Take", "the", "given", "call", "instruction", "and", "return", "a", "more", "optimal", "value", "to", "replace", "the", "instruction", "with", "or", "0", "if", "a", "more", "optimal", "form", "ca", "n't", "be", "found", "." ]

[ "WebAssembly", "WebAssembly", "1", "2", "0", "\"Store results: call to builtin function with wrong \"", "\"signature, from/to mismatch\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "ix86_simd_clone_usable", "(", "struct", "cgraph_node", "*", "node", ")", "{", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "-", "1", ";", "if", "(", "!", "TARGET_AVX", ")", "return", "0", ";", "return", "TARGET_AVX2", "?", "2", ":", "1", ";", "case", "'c'", ":", "if", "(", "!", "TARGET_AVX", ")", "return", "-", "1", ";", "return", "TARGET_AVX2", "?", "1", ":", "0", ";", "break", ";", "case", "'d'", ":", "if", "(", "!", "TARGET_AVX2", ")", "return", "-", "1", ";", "return", "0", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "If", "SIMD", "clone", "NODE", "ca", "n't", "be", "used", "in", "a", "vectorized", "loop", "in", "current", "function", ",", "return", "-1", ",", "otherwise", "return", "a", "badness", "of", "using", "it", "(", "0", "if", "it", "is", "most", "desirable", "from", "vecsize_mangle", "point", "of", "view", ",", "1", "slightly", "less", "desirable", ",", "etc", ".", ")", "." ]

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

[]

[ "<s>", "static", "uint64_t", "getSymbolOffset", "(", "const", "MCSymbolRefExpr", "*", "SymRefExpr", ",", "const", "MCAsmLayout", "&", "Layout", ")", "{", "if", "(", "!", "SymRefExpr", ")", "{", "return", "0", ";", "}", "const", "MCSymbol", "&", "Sym", "=", "SymRefExpr", "->", "getSymbol", "(", ")", ";", "return", "Sym", ".", "isDefined", "(", ")", "?", "Layout", ".", "getSymbolOffset", "(", "Sym", ")", ":", "0", ";", "}", "</s>" ]

[ "Variant", "that", "reports", "a", "fatal", "error", "if", "the", "offset", "is", "not", "computable", "." ]

[ "MOS", "0", "0" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "OptForMinSize", "=", "MF", "->", "getFunction", "(", ")", "->", "optForMinSize", "(", ")", ";", "assert", "(", "(", "!", "OptForMinSize", "||", "OptForSize", ")", "&&", "\"OptForMinSize implies OptForSize\"", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "&", "*", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "!", "Subtarget", "->", "useRetpoline", "(", ")", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "!", "getTargetMachine", "(", ")", ".", "isPositionIndependent", "(", ")", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "moveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getSimpleValueType", "(", ")", ";", "MVT", "DstVT", "=", "N", "->", "getSimpleValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "const", "X86TargetLowering", "*", "X86Lowering", "=", "static_cast", "<", "const", "X86TargetLowering", "*", ">", "(", "TLI", ")", ";", "bool", "SrcIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", "->", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "MVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "X86", "X86", "\"OptForMinSize implies OptForSize\"", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "ISD::EXTLOAD", "0" ]

[]

[ "<s>", "void", "BlackfinRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FrameSize", "%", "4", ")", "{", "FrameSize", "=", "(", "FrameSize", "+", "3", ")", "&", "~", "3", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "assert", "(", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "\"FP elimination on a non-leaf function is not supported\"", ")", ";", "adjustRegister", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "SP", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "return", ";", "}", "if", "(", "FrameSize", "<=", "0x3ffff", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "LINK", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "RETS", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "PUSH", ")", ")", ".", "addReg", "(", "BF", "::", "FP", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "MOVE", ")", ",", "BF", "::", "FP", ")", ".", "addReg", "(", "BF", "::", "SP", ")", ";", "loadConstant", "(", "MBB", ",", "MBBI", ",", "dl", ",", "BF", "::", "P1", ",", "-", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "BF", "::", "ADDpp", ")", ",", "BF", "::", "SP", ")", ".", "addReg", "(", "BF", "::", "SP", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "BF", "::", "P1", ",", "RegState", "::", "Kill", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "4", "3", "3", "\"FP elimination on a non-leaf function is not supported\"", "BF::SP", "BF::P1", "0x3ffff", "BF::LINK", "BF::PUSH", "BF::RETS", "BF::PUSH", "BF::FP", "BF::MOVE", "BF::FP", "BF::SP", "BF::P1", "BF::ADDpp", "BF::SP", "BF::SP", "BF::P1" ]

[]

[ "<s>", "bool", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "CAHP" ]

[]

[ "<s>", "static", "tree", "ix86_veclibabi_svml", "(", "combined_fn", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "char", "name", "[", "20", "]", ";", "tree", "fntype", ",", "new_fndecl", ",", "args", ";", "unsigned", "arity", ";", "const", "char", "*", "bname", ";", "machine_mode", "el_mode", ",", "in_mode", ";", "int", "n", ",", "in_n", ";", "if", "(", "!", "flag_unsafe_math_optimizations", ")", "return", "NULL_TREE", ";", "el_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "if", "(", "el_mode", "!=", "in_mode", "||", "n", "!=", "in_n", ")", "return", "NULL_TREE", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_EXP", ":", "CASE_CFN_LOG", ":", "CASE_CFN_LOG10", ":", "CASE_CFN_POW", ":", "CASE_CFN_TANH", ":", "CASE_CFN_TAN", ":", "CASE_CFN_ATAN", ":", "CASE_CFN_ATAN2", ":", "CASE_CFN_ATANH", ":", "CASE_CFN_CBRT", ":", "CASE_CFN_SINH", ":", "CASE_CFN_SIN", ":", "CASE_CFN_ASINH", ":", "CASE_CFN_ASIN", ":", "CASE_CFN_COSH", ":", "CASE_CFN_COS", ":", "CASE_CFN_ACOSH", ":", "CASE_CFN_ACOS", ":", "if", "(", "(", "el_mode", "!=", "DFmode", "||", "n", "!=", "2", ")", "&&", "(", "el_mode", "!=", "SFmode", "||", "n", "!=", "4", ")", ")", "return", "NULL_TREE", ";", "break", ";", "default", ":", "return", "NULL_TREE", ";", "}", "tree", "fndecl", "=", "mathfn_built_in", "(", "TREE_TYPE", "(", "type_in", ")", ",", "fn", ")", ";", "bname", "=", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ";", "if", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", "==", "BUILT_IN_LOGF", ")", "strcpy", "(", "name", ",", "\"vmlsLn4\"", ")", ";", "else", "if", "(", "DECL_FUNCTION_CODE", "(", "fndecl", ")", "==", "BUILT_IN_LOG", ")", "strcpy", "(", "name", ",", "\"vmldLn2\"", ")", ";", "else", "if", "(", "n", "==", "4", ")", "{", "sprintf", "(", "name", ",", "\"vmls%s\"", ",", "bname", "+", "10", ")", ";", "name", "[", "strlen", "(", "name", ")", "-", "1", "]", "=", "'4'", ";", "}", "else", "sprintf", "(", "name", ",", "\"vmld%s2\"", ",", "bname", "+", "10", ")", ";", "name", "[", "4", "]", "&=", "~", "0x20", ";", "arity", "=", "0", ";", "for", "(", "args", "=", "DECL_ARGUMENTS", "(", "fndecl", ")", ";", "args", ";", "args", "=", "TREE_CHAIN", "(", "args", ")", ")", "arity", "++", ";", "if", "(", "arity", "==", "1", ")", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "NULL", ")", ";", "else", "fntype", "=", "build_function_type_list", "(", "type_out", ",", "type_in", ",", "type_in", ",", "NULL", ")", ";", "new_fndecl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "fntype", ")", ";", "TREE_PUBLIC", "(", "new_fndecl", ")", "=", "1", ";", "DECL_EXTERNAL", "(", "new_fndecl", ")", "=", "1", ";", "DECL_IS_NOVOPS", "(", "new_fndecl", ")", "=", "1", ";", "TREE_READONLY", "(", "new_fndecl", ")", "=", "1", ";", "return", "new_fndecl", ";", "}", "</s>" ]

[ "Handler", "for", "an", "SVML-style", "interface", "to", "a", "library", "with", "vectorized", "intrinsics", "." ]

[ "i386", "20", "2", "4", "\"vmlsLn4\"", "\"vmldLn2\"", "4", "\"vmls%s\"", "10", "1", "\"vmld%s2\"", "10", "4", "0x20", "0", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetOperandInfo", "TOI", "(", "*", "HII", ")", ";", "RegisterAliasInfo", "RAI", "(", "TRI", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "*", "HII", ",", "TRI", ",", "*", "MDT", ",", "MDF", ",", "RAI", ",", "TOI", ")", ";", "G", ".", "build", "(", ")", ";", "DFG", "=", "&", "G", ";", "Liveness", "L", "(", "MRI", ",", "*", "DFG", ")", ";", "L", ".", "computePhiInfo", "(", ")", ";", "LV", "=", "&", "L", ";", "constructDefMap", "(", "&", "DFG", "->", "getMF", "(", ")", ".", "front", "(", ")", ")", ";", "Deleted", ".", "clear", "(", ")", ";", "NodeAddr", "<", "FuncNode", "*", ">", "FA", "=", "DFG", "->", "getFunc", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"==== [RefMap#]=====:\\n \"", "<<", "Print", "<", "NodeAddr", "<", "FuncNode", "*", ">>", "(", "FA", ",", "*", "DFG", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "FA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "Changed", "|=", "processBlock", "(", "BA", ")", ";", "for", "(", "auto", "MI", ":", "Deleted", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "Changed", ")", "{", "G", ".", "build", "(", ")", ";", "L", ".", "computeLiveIns", "(", ")", ";", "L", ".", "resetLiveIns", "(", ")", ";", "L", ".", "resetKills", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"==== [RefMap#]=====:\\n \"", "\"\\n\"" ]

[]

[ "<s>", "int", "symbol_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "return", "0", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "symbol_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "symbol_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "SYMBOL_REF", "." ]

[ "microblaze", "1", "0", "1", "0", "1", "0", "1", "1", "0" ]

[]

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

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

[ "Teak", "\"Teak Assembly Printer\"" ]

[]

[ "<s>", "virtual", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "return", "createR600MachineScheduler", "(", "C", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "(", "Fn", ".", "getRegInfo", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "*", "MI", "=", "MII", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "MI", ")", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", "->", "dump", "(", ")", ";", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "AMDGPU::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "getAllocatedStackSize", "(", "MF", ")", ";", "if", "(", "ZFI", "->", "getLowSavedGPR", "(", ")", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

[ "<s>", "static", "rtx_insn", "*", "pru_insert_loop_label_last", "(", "rtx_insn", "*", "last_insn", ",", "rtx_code_label", "*", "label", ",", "bool", "shared", ")", "{", "rtx_insn", "*", "next", ",", "*", "prev", ";", "int", "count", "=", "0", ",", "code", ",", "icode", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"considering end of repeat loop at insn %d\\n\"", ",", "INSN_UID", "(", "last_insn", ")", ")", ";", "prev", "=", "PREV_INSN", "(", "last_insn", ")", ";", "next", "=", "last_insn", ";", "if", "(", "!", "shared", ")", "while", "(", "prev", "!=", "0", ")", "{", "code", "=", "GET_CODE", "(", "prev", ")", ";", "if", "(", "code", "==", "CALL_INSN", "||", "code", "==", "CODE_LABEL", "||", "code", "==", "BARRIER", ")", "break", ";", "if", "(", "INSN_P", "(", "prev", ")", ")", "{", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "SEQUENCE", ")", "prev", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "XVECEXP", "(", "PATTERN", "(", "prev", ")", ",", "0", ",", "1", ")", ")", ";", "icode", "=", "recog_memoized", "(", "prev", ")", ";", "if", "(", "icode", "<", "0", "||", "icode", "==", "CODE_FOR_pruloophi", "||", "icode", "==", "CODE_FOR_pruloopsi", ")", "break", ";", "count", "++", ";", "next", "=", "prev", ";", "if", "(", "dump_file", ")", "print_rtl_single", "(", "dump_file", ",", "next", ")", ";", "if", "(", "count", "==", "2", ")", "break", ";", "}", "prev", "=", "PREV_INSN", "(", "prev", ")", ";", "}", "if", "(", "dump_file", "&&", "count", "<", "2", ")", "fprintf", "(", "dump_file", ",", "\"Adding %d nop%s inside loop\\n\\n\"", ",", "2", "-", "count", ",", "count", "==", "1", "?", "\"\"", ":", "\"s\"", ")", ";", "for", "(", ";", "count", "<", "2", ";", "count", "++", ")", "emit_insn_before", "(", "gen_nop", "(", ")", ",", "last_insn", ")", ";", "emit_label_before", "(", "label", ",", "last_insn", ")", ";", "return", "last_insn", ";", "}", "</s>" ]

[ "Figure", "out", "where", "to", "put", "LABEL", ",", "which", "is", "the", "label", "for", "a", "repeat", "loop", ".", "The", "loop", "ends", "just", "before", "LAST_INSN", ".", "If", "SHARED", ",", "insns", "other", "than", "the", "``", "repeat", "''", "might", "use", "LABEL", "to", "jump", "to", "the", "loop", "'s", "continuation", "point", ".", "Return", "the", "last", "instruction", "in", "the", "adjusted", "loop", "." ]

[ "pru", "0", "\"considering end of repeat loop at insn %d\\n\"", "0", "0", "1", "0", "2", "2", "\"Adding %d nop%s inside loop\\n\\n\"", "2", "1", "\"\"", "\"s\"", "2" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MipsInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "StackSize", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "RestoreRaF16", ")", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "16", "Mips::RestoreRaF16" ]

[]

[ "<s>", "static", "bool", "frv_pack_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "frv_packet", ".", "num_insns", "==", "frv_packet", ".", "issue_rate", ")", "return", "false", ";", "if", "(", "frv_packet", ".", "num_insns", ">", "0", "&&", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_MODE", "(", "insn", ")", "==", "TImode", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "COND_EXEC", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SETLO", ")", "if", "(", "frv_registers_conflict_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "return", "false", ";", "return", "state_transition", "(", "frv_packet", ".", "dfa_state", ",", "insn", ")", "<", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "can", "be", "added", "to", "the", "current", "packet", ".", "Update", "the", "DFA", "state", "on", "success", "." ]

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

[]

[ "<s>", "bool", "s390_logical_operator_ok_p", "(", "rtx", "*", "operands", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "return", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", "||", "(", "!", "reload_completed", "&&", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "OPERANDS", "are", "OK", "for", "a", "logical", "operation", "(", "AND", ",", "IOR", ",", "XOR", ")", "." ]

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

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "M68kInstrInfo", "::", "getSerializableDirectMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "M68kII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_ABSOLUTE_ADDRESS", ",", "\"m68k-absolute\"", "}", ",", "{", "MO_PC_RELATIVE_ADDRESS", ",", "\"m68k-pcrel\"", "}", ",", "{", "MO_GOT", ",", "\"m68k-got\"", "}", ",", "{", "MO_GOTOFF", ",", "\"m68k-gotoff\"", "}", ",", "{", "MO_GOTPCREL", ",", "\"m68k-gotpcrel\"", "}", ",", "{", "MO_PLT", ",", "\"m68k-plt\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "direct", "target", "flag", "values", "and", "their", "names", "." ]

[ "M68k", "M68k", "M68k", "\"m68k-absolute\"", "\"m68k-pcrel\"", "\"m68k-got\"", "\"m68k-gotoff\"", "\"m68k-gotpcrel\"", "\"m68k-plt\"" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "X86TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isTargetGlibc", "(", ")", ")", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isLegalRegOperand", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MCOperandInfo", "&", "OpInfo", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "false", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "return", "RI", ".", "getCommonSubClass", "(", "RC", ",", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ")", "==", "RC", ";", "}", "</s>" ]

[ "Check", "if", "MO", "(", "a", "register", "operand", ")", "is", "a", "legal", "register", "for", "the", "given", "operand", "description", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Checking if value is in small-data, -G\"", "<<", "SmallDataThreshold", "<<", "\": \\\"\"", "<<", "GO", "->", "getName", "(", ")", "<<", "\"\\\": \"", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GO", ")", ";", "if", "(", "!", "GVar", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, not a global variable\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "GVar", "->", "hasSection", "(", ")", ")", "{", "bool", "IsSmall", "=", "isSmallDataSection", "(", "GVar", "->", "getSection", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "(", "IsSmall", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\", has section: \"", "<<", "GVar", "->", "getSection", "(", ")", "<<", "'\\n'", ")", ";", "return", "IsSmall", ";", "}", "if", "(", "GVar", "->", "isConstant", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is a constant\\n\"", ")", ";", "return", "false", ";", "}", "bool", "IsLocal", "=", "GVar", "->", "hasLocalLinkage", "(", ")", ";", "if", "(", "!", "StaticsInSData", "&&", "IsLocal", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is static\\n\"", ")", ";", "return", "false", ";", "}", "Type", "*", "GType", "=", "GVar", "->", "getType", "(", ")", ";", "if", "(", "PointerType", "*", "PT", "=", "dyn_cast", "<", "PointerType", ">", "(", "GType", ")", ")", "GType", "=", "PT", "->", "getElementType", "(", ")", ";", "if", "(", "isa", "<", "ArrayType", ">", "(", "GType", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is an array\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "StructType", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "GType", ")", ")", "{", "if", "(", "ST", "->", "isOpaque", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has opaque type\\n\"", ")", ";", "return", "false", ";", "}", "}", "unsigned", "Size", "=", "GVar", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GType", ")", ";", "if", "(", "Size", "==", "0", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has size 0\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "Size", ">", "SmallDataThreshold", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, size exceeds sdata threshold: \"", "<<", "Size", "<<", "'\\n'", ")", ";", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"yes\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "Hexagon", "Hexagon", "\"Checking if value is in small-data, -G\"", "\": \\\"\"", "\"\\\": \"", "\"no, not a global variable\\n\"", "\"yes\"", "\"no\"", "\", has section: \"", "\"no, is a constant\\n\"", "\"no, is static\\n\"", "\"no, is an array\\n\"", "\"no, has opaque type\\n\"", "0", "\"no, has size 0\\n\"", "\"no, size exceeds sdata threshold: \"", "\"yes\\n\"" ]

[]

[ "<s>", "void", "R600AsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "const", "R600Subtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "R600MCInstLower", "MCInstLowering", "(", "OutContext", ",", "STI", ",", "*", "this", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "STI", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "*", "MI", ",", "Err", ")", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"Illegal instruction detected: \"", "+", "Err", ")", ";", "MI", "->", "print", "(", "errs", "(", ")", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "++", "MI", "->", "getIterator", "(", ")", ";", "while", "(", "I", "!=", "MBB", "->", "instr_end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "emitInstruction", "(", "&", "*", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "AMDGPU", "R600", "R600", "R600", "R600", "\"Illegal instruction detected: \"" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCInstFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "ARM", "::", "fixup_arm_thumb_br", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "2046", "||", "Offset", "<", "-", "2048", ";", "}", "case", "ARM", "::", "fixup_arm_thumb_bcc", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "254", "||", "Offset", "<", "-", "256", ";", "}", "case", "ARM", "::", "fixup_thumb_adr_pcrel_10", ":", "case", "ARM", "::", "fixup_arm_thumb_cp", ":", "{", "int64_t", "Offset", "=", "int64_t", "(", "Value", ")", "-", "4", ";", "return", "Offset", ">", "1020", "||", "Offset", "<", "0", "||", "Offset", "&", "3", ";", "}", "}", "llvm_unreachable", "(", "\"Unexpected fixup kind in fixupNeedsRelaxation()!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::fixup_arm_thumb_br", "4", "2046", "2048", "ARM::fixup_arm_thumb_bcc", "4", "254", "256", "ARM::fixup_thumb_adr_pcrel_10", "ARM::fixup_arm_thumb_cp", "4", "1020", "0", "3", "\"Unexpected fixup kind in fixupNeedsRelaxation()!\"" ]

[]

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", "MachineFunction", "&", "Fn", ")", "{", "assert", "(", "BBOffsets", ".", "size", "(", ")", "==", "BBSizes", ".", "size", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "BBOffsets", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "assert", "(", "BBOffsets", "[", "i", "-", "1", "]", "+", "BBSizes", "[", "i", "-", "1", "]", "==", "BBOffsets", "[", "i", "]", ")", ";", "if", "(", "isThumb", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "if", "(", "!", "MBB", "->", "empty", "(", ")", "&&", "MBB", "->", "begin", "(", ")", "->", "getOpcode", "(", ")", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "assert", "(", "(", "BBOffsets", "[", "MBB", "->", "getNumber", "(", ")", "]", "%", "4", "==", "0", "&&", "BBSizes", "[", "MBB", "->", "getNumber", "(", ")", "]", "%", "4", "==", "0", ")", "||", "(", "BBOffsets", "[", "MBB", "->", "getNumber", "(", ")", "]", "%", "4", "!=", "0", "&&", "BBSizes", "[", "MBB", "->", "getNumber", "(", ")", "]", "%", "4", "!=", "0", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "1", "1", "1", "ARM::CONSTPOOL_ENTRY", "4", "0", "4", "0", "4", "0", "4", "0" ]

[]

[ "<s>", "static", "DItype", "local_fixunsdfdi", "(", "DFtype", "a", ")", "{", "USItype", "hi", ",", "lo", ";", "hi", "=", "a", "/", "(", "(", "(", "UDItype", ")", "1", ")", "<<", "(", "sizeof", "(", "SItype", ")", "*", "8", ")", ")", ";", "lo", "=", "(", "a", "-", "(", "(", "DFtype", ")", "hi", ")", "*", "(", "(", "(", "UDItype", ")", "1", ")", "<<", "(", "sizeof", "(", "SItype", ")", "*", "8", ")", ")", ")", ";", "return", "(", "(", "UDItype", ")", "hi", "<<", "(", "sizeof", "(", "SItype", ")", "*", "8", ")", ")", "|", "lo", ";", "}", "</s>" ]

[ "This", "version", "is", "needed", "to", "prevent", "recursion", ";", "fixunsdfdi", "in", "libgcc", "calls", "fixdfdi", ",", "which", "in", "turn", "calls", "calls", "fixunsdfdi", "." ]

[ "rs6000", "1", "8", "1", "8", "8" ]

[]

[ "<s>", "int", "bfin_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", "!=", "SUBROUTINE", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

[ "bfin", "0", "1" ]

[]

[ "<s>", "MVT", "AMDGPUTargetLowering", "::", "getVectorIdxTy", "(", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Returns", "the", "type", "to", "be", "used", "for", "the", "index", "operand", "of", ":", "ISD", ":", ":INSERT_VECTOR_ELT", ",", "ISD", ":", ":EXTRACT_VECTOR_ELT", ",", "ISD", ":", ":INSERT_SUBVECTOR", ",", "and", "ISD", ":", ":EXTRACT_SUBVECTOR", "." ]

[ "R600", "MVT::i32" ]

[]

[ "<s>", "bool", "SPUAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "printMemRegReg", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_worker_addr", "(", "tree", "exp", ",", "rtx", "target", ",", "machine_mode", "ARG_UNUSED", "(", "mode", ")", ",", "int", "ignore", ")", "{", "if", "(", "ignore", ")", "return", "target", ";", "unsigned", "align", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "if", "(", "align", ">", "worker_red_align", ")", "worker_red_align", "=", "align", ";", "unsigned", "offset", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "unsigned", "size", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "size", "+", "offset", ">", "worker_red_size", ")", "worker_red_size", "=", "size", "+", "offset", ";", "rtx", "addr", "=", "worker_red_sym", ";", "if", "(", "offset", ")", "{", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "offset", ")", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr", ")", ";", "}", "emit_move_insn", "(", "target", ",", "addr", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Worker", "reduction", "address", "expander", "." ]

[ "nvptx", "2", "0", "1" ]

[]

[ "<s>", "void", "applyFixup", "(", "MCFixup", "const", "&", ",", "char", "*", ",", "unsigned", ",", "uint64_t", ",", "bool", ")", "const", "override", "{", "return", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "CSKYAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".csky_attribute\"", ")", "return", "parseDirectiveAttribute", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "\".csky_attribute\"" ]

[]

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

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

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

[]

[ "<s>", "const", "uint32_t", "*", "NyuziRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "NyuziCSR_RegMask", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "LastOpcodeType", "=", "OTHER", ";", "LastInstWritesM0", "=", "false", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", ")", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "else", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "MBB", ",", "I", ")", ";", "handleSendMsg", "(", "MBB", ",", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "}", "return", "Changes", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "0", "0", "AMDGPU::S_BARRIER" ]

[]

[ "<s>", "static", "bool", "riscv_compressed_reg_p", "(", "int", "regno", ")", "{", "return", "(", "TARGET_RVC", "&&", "(", "IN_RANGE", "(", "regno", ",", "GP_REG_FIRST", "+", "8", ",", "GP_REG_FIRST", "+", "15", ")", "||", "IN_RANGE", "(", "regno", ",", "FP_REG_FIRST", "+", "8", ",", "FP_REG_FIRST", "+", "15", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "hard", "reg", "REGNO", "can", "be", "used", "in", "compressed", "instructions", "." ]

[ "riscv", "8", "15", "8", "15" ]

[]

[ "<s>", "static", "void", "ix86_expand_ashl_const", "(", "rtx", "operand", ",", "int", "count", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "count", "==", "1", ")", "{", "emit_insn", "(", "(", "mode", "==", "DImode", "?", "gen_addsi3", ":", "gen_adddi3", ")", "(", "operand", ",", "operand", ",", "operand", ")", ")", ";", "}", "else", "if", "(", "!", "optimize_size", "&&", "count", "*", "ix86_cost", "->", "add", "<=", "ix86_cost", "->", "shift_const", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "emit_insn", "(", "(", "mode", "==", "DImode", "?", "gen_addsi3", ":", "gen_adddi3", ")", "(", "operand", ",", "operand", ",", "operand", ")", ")", ";", "}", "}", "else", "emit_insn", "(", "(", "mode", "==", "DImode", "?", "gen_ashlsi3", ":", "gen_ashldi3", ")", "(", "operand", ",", "operand", ",", "GEN_INT", "(", "count", ")", ")", ")", ";", "}", "</s>" ]

[ "Helper", "function", "of", "ix86_split_ashl", "used", "to", "generate", "an", "SImode/DImode", "left", "shift", "by", "a", "constant", ",", "either", "using", "a", "single", "shift", "or", "a", "sequence", "of", "add", "instructions", "." ]

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

[]

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

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

[ "TVM", "\"TVM Register Numbering\"" ]

[]

[ "<s>", "static", "void", "avr_asm_init_sections", "(", "void", ")", "{", "readonly_data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "data_section", "->", "unnamed", ".", "callback", "=", "avr_output_data_section_asm_op", ";", "bss_section", "->", "unnamed", ".", "callback", "=", "avr_output_bss_section_asm_op", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_INIT_SECTIONS", "'", "." ]

[ "avr" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_ri", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "uint64_t", "Imm", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "a", "register", "operand", ",", "an", "immediate", ",", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

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

[]

[ "<s>", "static", "int", "vfp_emit_fstmd", "(", "int", "base_reg", ",", "int", "count", ")", "{", "rtx", "par", ";", "rtx", "dwarf", ";", "rtx", "tmp", ",", "reg", ";", "int", "i", ";", "if", "(", "count", "==", "2", "&&", "!", "arm_arch6", ")", "{", "if", "(", "base_reg", "==", "LAST_VFP_REGNUM", "-", "3", ")", "base_reg", "-=", "2", ";", "count", "++", ";", "}", "if", "(", "count", ">", "16", ")", "{", "int", "saved", ";", "saved", "=", "vfp_emit_fstmd", "(", "base_reg", "+", "32", ",", "count", "-", "16", ")", ";", "saved", "+=", "vfp_emit_fstmd", "(", "base_reg", ",", "16", ")", ";", "return", "saved", ";", "}", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "1", ")", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "BLKmode", ",", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "8", ")", ")", ")", ")", ",", "gen_rtx_UNSPEC", "(", "BLKmode", ",", "gen_rtvec", "(", "1", ",", "reg", ")", ",", "UNSPEC_PUSH_MULT", ")", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "(", "count", "*", "8", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "tmp", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "DFmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", "=", "tmp", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", ";", "i", "++", ")", "{", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "base_reg", ")", ";", "base_reg", "+=", "2", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "reg", ")", ";", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_frame_mem", "(", "DFmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "i", "*", "8", ")", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "i", "+", "1", ")", "=", "tmp", ";", "}", "par", "=", "emit_insn", "(", "par", ")", ";", "add_reg_note", "(", "par", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "par", ")", "=", "1", ";", "return", "count", "*", "8", ";", "}", "</s>" ]

[ "Emit", "RTL", "to", "save", "block", "of", "VFP", "register", "pairs", "to", "the", "stack", ".", "Returns", "the", "number", "of", "bytes", "pushed", "." ]

[ "arm", "2", "3", "2", "16", "32", "16", "16", "1", "2", "0", "0", "8", "1", "8", "1", "0", "0", "1", "0", "1", "1", "2", "0", "8", "1", "0", "1", "1", "8" ]

[]

[ "<s>", "if", "(", "!", "TII", "->", "fitsConstReadLimitations", "(", "CurrentPacketMIs", ")", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Couldn't pack :\\n\"", ";", "MI", ".", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"with the following packets :\\n\"", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CurrentPacketMIs", ".", "size", "(", ")", "-", "1", ";", "i", "<", "e", ";", "i", "++", ")", "{", "CurrentPacketMIs", "[", "i", "]", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "dbgs", "(", ")", "<<", "\"because of Consts read limitations\\n\"", ";", "}", "</s>" ]

[ "Same", "but", "using", "const", "index", "set", "instead", "of", "MI", "set", "." ]

[ "AMDGPU", "\"Couldn't pack :\\n\"", "\"with the following packets :\\n\"", "0", "1", "\"\\n\"", "\"because of Consts read limitations\\n\"" ]

[]

[ "<s>", "static", "void", "ix86_avx256_split_vector_move_misalign", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "m", ";", "rtx", "(", "*", "extract", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "load_unaligned", ")", "(", "rtx", ",", "rtx", ")", ";", "rtx", "(", "*", "store_unaligned", ")", "(", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "switch", "(", "GET_MODE", "(", "op0", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "V32QImode", ":", "extract", "=", "gen_avx_vextractf128v32qi", ";", "load_unaligned", "=", "gen_avx_loaddquv32qi", ";", "store_unaligned", "=", "gen_avx_storedquv32qi", ";", "mode", "=", "V16QImode", ";", "break", ";", "case", "V8SFmode", ":", "extract", "=", "gen_avx_vextractf128v8sf", ";", "load_unaligned", "=", "gen_avx_loadups256", ";", "store_unaligned", "=", "gen_avx_storeups256", ";", "mode", "=", "V4SFmode", ";", "break", ";", "case", "V4DFmode", ":", "extract", "=", "gen_avx_vextractf128v4df", ";", "load_unaligned", "=", "gen_avx_loadupd256", ";", "store_unaligned", "=", "gen_avx_storeupd256", ";", "mode", "=", "V2DFmode", ";", "break", ";", "}", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "if", "(", "TARGET_AVX256_SPLIT_UNALIGNED_LOAD", "&&", "optimize_insn_for_speed_p", "(", ")", ")", "{", "rtx", "r", "=", "gen_reg_rtx", "(", "mode", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "0", ")", ";", "emit_move_insn", "(", "r", ",", "m", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "mode", ",", "16", ")", ";", "r", "=", "gen_rtx_VEC_CONCAT", "(", "GET_MODE", "(", "op0", ")", ",", "r", ",", "m", ")", ";", "emit_move_insn", "(", "op0", ",", "r", ")", ";", "}", "else", "if", "(", "misaligned_operand", "(", "op1", ",", "GET_MODE", "(", "op1", ")", ")", ")", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "else", "emit_insn", "(", "load_unaligned", "(", "op0", ",", "op1", ")", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "if", "(", "TARGET_AVX256_SPLIT_UNALIGNED_STORE", "&&", "optimize_insn_for_speed_p", "(", ")", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "0", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const0_rtx", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "mode", ",", "16", ")", ";", "emit_insn", "(", "extract", "(", "m", ",", "op1", ",", "const1_rtx", ")", ")", ";", "}", "else", "emit_insn", "(", "store_unaligned", "(", "op0", ",", "op1", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Split", "32-byte", "AVX", "unaligned", "load", "and", "store", "if", "needed", "." ]

[ "i386", "0", "16", "0", "16" ]

[]

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

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

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

[]

[ "<s>", "void", "BPFTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ")", "{", "PB", ".", "registerPipelineStartEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ",", "OptimizationLevel", ")", "{", "FunctionPassManager", "FPM", ";", "FPM", ".", "addPass", "(", "BPFAbstractMemberAccessPass", "(", "this", ")", ")", ";", "FPM", ".", "addPass", "(", "BPFPreserveDITypePass", "(", ")", ")", ";", "FPM", ".", "addPass", "(", "BPFIRPeepholePass", "(", ")", ")", ";", "MPM", ".", "addPass", "(", "createModuleToFunctionPassAdaptor", "(", "std", "::", "move", "(", "FPM", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPeepholeEPCallback", "(", "[", "=", "]", "(", "FunctionPassManager", "&", "FPM", ",", "OptimizationLevel", "Level", ")", "{", "FPM", ".", "addPass", "(", "SimplifyCFGPass", "(", "SimplifyCFGOptions", "(", ")", ".", "hoistCommonInsts", "(", "true", ")", ")", ")", ";", "}", ")", ";", "PB", ".", "registerPipelineEarlySimplificationEPCallback", "(", "[", "=", "]", "(", "ModulePassManager", "&", "MPM", ",", "OptimizationLevel", ")", "{", "MPM", ".", "addPass", "(", "BPFAdjustOptPass", "(", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Invoke", "the", "PassBuilder", "callback", "registration", "." ]

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

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "L2_loadri_io", ":", "case", "Hexagon", "::", "L2_loadrd_io", ":", "case", "Hexagon", "::", "V6_vL32b_ai", ":", "case", "Hexagon", "::", "V6_vL32b_nt_ai", ":", "case", "Hexagon", "::", "V6_vL32Ub_ai", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "case", "Hexagon", "::", "LDriw_ctr", ":", "case", "Hexagon", "::", "PS_vloadrq_ai", ":", "case", "Hexagon", "::", "PS_vloadrw_ai", ":", "case", "Hexagon", "::", "PS_vloadrw_nt_ai", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "case", "Hexagon", "::", "L2_ploadrit_io", ":", "case", "Hexagon", "::", "L2_ploadrif_io", ":", "case", "Hexagon", "::", "L2_ploadrdt_io", ":", "case", "Hexagon", "::", "L2_ploadrdf_io", ":", "{", "const", "MachineOperand", "OpFI", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "if", "(", "!", "OpFI", ".", "isFI", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "OpOff", "=", "MI", ".", "getOperand", "(", "3", ")", ";", "if", "(", "!", "OpOff", ".", "isImm", "(", ")", "||", "OpOff", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "FrameIndex", "=", "OpFI", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Hexagon", "Hexagon", "Hexagon::L2_loadri_io", "Hexagon::L2_loadrd_io", "Hexagon::V6_vL32b_ai", "Hexagon::V6_vL32b_nt_ai", "Hexagon::V6_vL32Ub_ai", "Hexagon::LDriw_pred", "Hexagon::LDriw_ctr", "Hexagon::PS_vloadrq_ai", "Hexagon::PS_vloadrw_ai", "Hexagon::PS_vloadrw_nt_ai", "1", "0", "2", "0", "0", "0", "Hexagon::L2_ploadrit_io", "Hexagon::L2_ploadrif_io", "Hexagon::L2_ploadrdt_io", "Hexagon::L2_ploadrdf_io", "2", "0", "3", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "riscv_reorg", "(", "void", ")", "{", "if", "(", "TARGET_SAVE_RESTORE", ")", "riscv_remove_unneeded_save_restore_calls", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MACHINE_DEPENDENT_REORG", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", "AddrSpace", ",", "unsigned", "Align", ",", "bool", "*", "IsFast", ")", "const", "{", "if", "(", "IsFast", ")", "*", "IsFast", "=", "false", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "(", "VT", "!=", "MVT", "::", "Other", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "1024", "&&", "VT", ".", "getStoreSize", "(", ")", ">", "16", ")", ")", "{", "return", "false", ";", "}", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", "{", "bool", "AlignedBy4", "=", "(", "Align", "%", "4", "==", "0", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", ";", "}", "if", "(", "Subtarget", "->", "hasUnalignedBufferAccess", "(", ")", ")", "{", "if", "(", "IsFast", ")", "{", "*", "IsFast", "=", "(", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", ")", "?", "(", "Align", "%", "4", "==", "0", ")", ":", "true", ";", "}", "return", "true", ";", "}", "if", "(", "VT", ".", "bitsLT", "(", "MVT", "::", "i32", ")", ")", "return", "false", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "true", ";", "return", "VT", ".", "bitsGT", "(", "MVT", "::", "i32", ")", "&&", "Align", "%", "4", "==", "0", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "AMDGPU", "SI", "MVT::Other", "MVT::Other", "1024", "16", "AMDGPU", "AMDGPU", "4", "0", "AMDGPU", "4", "0", "MVT::i32", "MVT::i32", "4", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SILoadStoreOptimizerID", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "RegisterCoalescerID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "function_arg_record_value", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "int", "slotno", ",", "bool", "named", ",", "int", "regbase", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "assign_data_t", "data", ";", "int", "nregs", ";", "data", ".", "slotno", "=", "slotno", ";", "data", ".", "regbase", "=", "regbase", ";", "data", ".", "nregs", "=", "0", ";", "data", ".", "intoffset", "=", "0", ";", "data", ".", "stack", "=", "false", ";", "traverse_record_type", "<", "assign_data_t", ",", "count_registers", ">", "(", "type", ",", "named", ",", "&", "data", ")", ";", "if", "(", "compute_int_layout", "(", "size", "*", "BITS_PER_UNIT", ",", "&", "data", ",", "&", "nregs", ")", ")", "data", ".", "nregs", "+=", "nregs", ";", "nregs", "=", "data", ".", "nregs", ";", "if", "(", "nregs", "==", "0", ")", "{", "if", "(", "size", "<=", "0", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "regbase", ")", ";", "}", "nregs", "=", "CEIL_NWORDS", "(", "size", ")", ";", "if", "(", "nregs", "+", "slotno", ">", "SPARC_INT_ARG_MAX", ")", "nregs", "=", "SPARC_INT_ARG_MAX", "-", "slotno", ";", "}", "gcc_assert", "(", "nregs", ">", "0", ")", ";", "data", ".", "ret", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "data", ".", "stack", "+", "nregs", ")", ")", ";", "if", "(", "data", ".", "stack", ")", "XVECEXP", "(", "data", ".", "ret", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "data", ".", "nregs", "=", "0", ";", "data", ".", "intoffset", "=", "0", ";", "traverse_record_type", "<", "assign_data_t", ",", "assign_registers", ">", "(", "type", ",", "named", ",", "&", "data", ")", ";", "assign_int_registers", "(", "size", "*", "BITS_PER_UNIT", ",", "&", "data", ")", ";", "gcc_assert", "(", "data", ".", "nregs", "==", "nregs", ")", ";", "return", "data", ".", "ret", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "complex", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "structures", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "SLOTNO", "is", "the", "index", "number", "of", "the", "argument", "'s", "slot", "in", "the", "parameter", "array", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "REGBASE", "is", "the", "regno", "of", "the", "base", "register", "for", "the", "parameter", "array", "." ]

[ "sparc", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]