Datasets:

docz-ict

/

ComBack

like 3

[ "<s>", "machine_mode", "arm_select_dominance_cc_mode", "(", "rtx", "x", ",", "rtx", "y", ",", "HOST_WIDE_INT", "cond_or", ")", "{", "enum", "rtx_code", "cond1", ",", "cond2", ";", "int", "swapped", "=", "0", ";", "if", "(", "(", "arm_select_cc_mode", "(", "cond1", "=", "GET_CODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CCmode", ")", "||", "(", "arm_select_cc_mode", "(", "cond2", "=", "GET_CODE", "(", "y", ")", ",", "XEXP", "(", "y", ",", "0", ")", ",", "XEXP", "(", "y", ",", "1", ")", ")", "!=", "CCmode", ")", ")", "return", "CCmode", ";", "if", "(", "cond_or", "==", "DOM_CC_NX_OR_Y", ")", "cond1", "=", "reverse_condition", "(", "cond1", ")", ";", "if", "(", "cond1", "!=", "cond2", "&&", "!", "comparison_dominates_p", "(", "cond1", ",", "cond2", ")", "&&", "(", "swapped", "=", "1", ",", "!", "comparison_dominates_p", "(", "cond2", ",", "cond1", ")", ")", ")", "return", "CCmode", ";", "if", "(", "swapped", ")", "std", "::", "swap", "(", "cond1", ",", "cond2", ")", ";", "switch", "(", "cond1", ")", "{", "case", "EQ", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DEQmode", ";", "switch", "(", "cond2", ")", "{", "case", "EQ", ":", "return", "CC_DEQmode", ";", "case", "LE", ":", "return", "CC_DLEmode", ";", "case", "LEU", ":", "return", "CC_DLEUmode", ";", "case", "GE", ":", "return", "CC_DGEmode", ";", "case", "GEU", ":", "return", "CC_DGEUmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "LT", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DLTmode", ";", "switch", "(", "cond2", ")", "{", "case", "LT", ":", "return", "CC_DLTmode", ";", "case", "LE", ":", "return", "CC_DLEmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "GT", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DGTmode", ";", "switch", "(", "cond2", ")", "{", "case", "GT", ":", "return", "CC_DGTmode", ";", "case", "GE", ":", "return", "CC_DGEmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "LTU", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DLTUmode", ";", "switch", "(", "cond2", ")", "{", "case", "LTU", ":", "return", "CC_DLTUmode", ";", "case", "LEU", ":", "return", "CC_DLEUmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "GTU", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DGTUmode", ";", "switch", "(", "cond2", ")", "{", "case", "GTU", ":", "return", "CC_DGTUmode", ";", "case", "GEU", ":", "return", "CC_DGEUmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "NE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DNEmode", ";", "case", "LE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DLEmode", ";", "case", "GE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DGEmode", ";", "case", "LEU", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DLEUmode", ";", "case", "GEU", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DGEUmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Select", "a", "dominance", "comparison", "mode", "if", "possible", "for", "a", "test", "of", "the", "general", "form", "(", "OP", "(", "COND_OR", "(", "X", ")", "(", "Y", ")", ")", "(", "const_int", "0", ")", ")", ".", "We", "support", "three", "forms", ".", "COND_OR", "==", "DOM_CC_X_AND_Y", "=", ">", "(", "X", "&", "&", "Y", ")", "COND_OR", "==", "DOM_CC_NX_OR_Y", "=", ">", "(", "(", "!", "X", ")", "||", "Y", ")", "COND_OR", "==", "DOM_CC_X_OR_Y", "=", ">", "(", "X", "||", "Y", ")", "In", "all", "cases", "OP", "will", "be", "either", "EQ", "or", "NE", ",", "but", "we", "do", "n't", "need", "to", "know", "which", "here", ".", "If", "we", "are", "unable", "to", "support", "a", "dominance", "comparison", "we", "return", "CC", "mode", ".", "This", "will", "then", "fail", "to", "match", "for", "the", "RTL", "expressions", "that", "generate", "this", "call", "." ]

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

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "riscv_asan_shadow_offset", "(", "void", ")", "{", "return", "TARGET_64BIT", "?", "(", "HOST_WIDE_INT_1", "<<", "29", ")", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASAN_SHADOW_OFFSET", "." ]

[ "riscv", "29", "0" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "EXTSW_32", ":", "return", "\"PPCISD::EXTSW_32\"", ";", "case", "PPCISD", "::", "STD_32", ":", "return", "\"PPCISD::STD_32\"", ";", "case", "PPCISD", "::", "CALL_SVR4", ":", "return", "\"PPCISD::CALL_SVR4\"", ";", "case", "PPCISD", "::", "CALL_Darwin", ":", "return", "\"PPCISD::CALL_Darwin\"", ";", "case", "PPCISD", "::", "NOP", ":", "return", "\"PPCISD::NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL_Darwin", ":", "return", "\"PPCISD::BCTRL_Darwin\"", ";", "case", "PPCISD", "::", "BCTRL_SVR4", ":", "return", "\"PPCISD::BCTRL_SVR4\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "MFCR", ":", "return", "\"PPCISD::MFCR\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "MTFSB0", ":", "return", "\"PPCISD::MTFSB0\"", ";", "case", "PPCISD", "::", "MTFSB1", ":", "return", "\"PPCISD::MTFSB1\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "MTFSF", ":", "return", "\"PPCISD::MTFSF\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::EXTSW_32", "\"PPCISD::EXTSW_32\"", "PPCISD::STD_32", "\"PPCISD::STD_32\"", "PPCISD::CALL_SVR4", "\"PPCISD::CALL_SVR4\"", "PPCISD::CALL_Darwin", "\"PPCISD::CALL_Darwin\"", "PPCISD::NOP", "\"PPCISD::NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL_Darwin", "\"PPCISD::BCTRL_Darwin\"", "PPCISD::BCTRL_SVR4", "\"PPCISD::BCTRL_SVR4\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::MFCR", "\"PPCISD::MFCR\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::MTFSB0", "\"PPCISD::MTFSB0\"", "PPCISD::MTFSB1", "\"PPCISD::MTFSB1\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::MTFSF", "\"PPCISD::MTFSF\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "report_fatal_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot have arguments\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AVRFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "AVRInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "false", ")", ";", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "int", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "MI", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "assert", "(", "getStackAlignment", "(", ")", "==", "1", "&&", "\"Unsupported stack alignment\"", ")", ";", "if", "(", "Opcode", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "fixStackStores", "(", "MBB", ",", "MI", ",", "TII", ",", "true", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "unsigned", "addOpcode", ";", "if", "(", "isUInt", "<", "6", ">", "(", "Amount", ")", ")", "{", "addOpcode", "=", "AVR", "::", "ADIWRdK", ";", "}", "else", "{", "addOpcode", "=", "AVR", "::", "SUBIWRdK", ";", "Amount", "=", "-", "Amount", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPREAD", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "SP", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "addOpcode", ")", ",", "AVR", "::", "R31R30", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Amount", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "SPWRITE", ")", ",", "AVR", "::", "SP", ")", ".", "addReg", "(", "AVR", "::", "R31R30", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "MI", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "0", "1", "\"Unsupported stack alignment\"", "6", "AVR::ADIWRdK", "AVR::SUBIWRdK", "AVR::SPREAD", "AVR::R31R30", "AVR::SP", "AVR::R31R30", "AVR::R31R30", "3", "AVR::SPWRITE", "AVR::SP", "AVR::R31R30" ]

[]

[ "<s>", "bool", "MLxExpansion", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Fn", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "const", "ARMSubtarget", "*", "STI", "=", "&", "Fn", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isLikeA9", "=", "STI", "->", "isLikeA9", "(", ")", "||", "STI", "->", "isSwift", "(", ")", ";", "isSwift", "=", "STI", "->", "isSwift", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "ExpandFPMLxInstructions", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AlphaRegisterInfo", "::", "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", "::", "getUnknownLoc", "(", ")", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "static", "int", "curgpdist", "=", "0", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAHg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "const_cast", "<", "Function", "*", ">", "(", "MF", ".", "getFunction", "(", ")", ")", ")", ".", "addReg", "(", "Alpha", "::", "R27", ")", ".", "addImm", "(", "++", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "const_cast", "<", "Function", "*", ">", "(", "MF", ".", "getFunction", "(", ")", ")", ")", ".", "addReg", "(", "Alpha", "::", "R29", ")", ".", "addImm", "(", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "ALTENT", ")", ")", ".", "addGlobalAddress", "(", "const_cast", "<", "Function", "*", ">", "(", "MF", ".", "getFunction", "(", ")", ")", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "NumBytes", "+=", "8", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "unsigned", "Align", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "NumBytes", "=", "(", "NumBytes", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MFI", "->", "setStackSize", "(", "NumBytes", ")", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", ">=", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "cerr", "<<", "\"Too big a stack frame at \"", "<<", "NumBytes", "<<", "\"\\n\"", ";", "abort", "(", ")", ";", "}", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "STQ", ")", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "Alpha::LDAHg", "Alpha::R29", "Alpha::R27", "Alpha::LDAg", "Alpha::R29", "Alpha::R29", "Alpha::ALTENT", "8", "0", "1", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"", "\"\\n\"", "Alpha::STQ", "Alpha::R15", "0", "Alpha::R30", "Alpha::BISr", "Alpha::R15", "Alpha::R30", "Alpha::R30" ]

[]

[ "<s>", "void", "PTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", ",", "int", ",", "RegScavenger", "*", ")", "const", "{", "llvm_unreachable", "(", "\"FrameIndex should have been previously eliminated!\"", ")", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "\"FrameIndex should have been previously eliminated!\"" ]

[]

[ "<s>", "static", "void", "cygwin_d_os_builtins", "(", "void", ")", "{", "d_add_builtin_version", "(", "\"Windows\"", ")", ";", "d_add_builtin_version", "(", "\"Cygwin\"", ")", ";", "d_add_builtin_version", "(", "\"Posix\"", ")", ";", "d_add_builtin_version", "(", "\"CRuntime_Newlib\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_OS_VERSIONS", "for", "Cygwin", "targets", "." ]

[ "i386", "\"Windows\"", "\"Cygwin\"", "\"Posix\"", "\"CRuntime_Newlib\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "auto", "&", "HST", "=", "static_cast", "<", "const", "HexagonSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasEHReturn", "=", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "if", "(", "HasEHReturn", ")", "{", "for", "(", "const", "MCPhysReg", "*", "CSRegs", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "CSRegs", ";", "++", "CSRegs", ")", "SavedRegs", ".", "set", "(", "*", "CSRegs", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "Hexagon", "::", "IntRegsRegClass", ";", "bool", "HasReplacedPseudoInst", "=", "replacePseudoRegTransferCode", "(", "MF", ")", ";", "if", "(", "HasReplacedPseudoInst", "&&", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ")", ")", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "NumberScavengerSlots", ";", "i", "++", ")", "RS", "->", "addScavengingFrameIndex", "(", "MFI", "->", "CreateSpillStackObject", "(", "RC", ".", "getSize", "(", ")", ",", "RC", ".", "getAlignment", "(", ")", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "0" ]

[]

[ "<s>", "static", "unsigned", "rs6000_hash_constant", "(", "rtx", "k", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "k", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "k", ")", ";", "unsigned", "result", "=", "(", "code", "<<", "3", ")", "^", "mode", ";", "const", "char", "*", "format", ";", "int", "flen", ",", "fidx", ";", "format", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "flen", "=", "strlen", "(", "format", ")", ";", "fidx", "=", "0", ";", "switch", "(", "code", ")", "{", "case", "LABEL_REF", ":", "return", "result", "*", "1231", "+", "(", "unsigned", ")", "INSN_UID", "(", "XEXP", "(", "k", ",", "0", ")", ")", ";", "case", "CONST_DOUBLE", ":", "if", "(", "mode", "!=", "VOIDmode", ")", "return", "real_hash", "(", "CONST_DOUBLE_REAL_VALUE", "(", "k", ")", ")", "*", "result", ";", "flen", "=", "2", ";", "break", ";", "case", "CODE_LABEL", ":", "fidx", "=", "3", ";", "break", ";", "default", ":", "break", ";", "}", "for", "(", ";", "fidx", "<", "flen", ";", "fidx", "++", ")", "switch", "(", "format", "[", "fidx", "]", ")", "{", "case", "'s'", ":", "{", "unsigned", "i", ",", "len", ";", "const", "char", "*", "str", "=", "XSTR", "(", "k", ",", "fidx", ")", ";", "len", "=", "strlen", "(", "str", ")", ";", "result", "=", "result", "*", "613", "+", "len", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "str", "[", "i", "]", ";", "break", ";", "}", "case", "'u'", ":", "case", "'e'", ":", "result", "=", "result", "*", "1231", "+", "rs6000_hash_constant", "(", "XEXP", "(", "k", ",", "fidx", ")", ")", ";", "break", ";", "case", "'i'", ":", "case", "'n'", ":", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XINT", "(", "k", ",", "fidx", ")", ";", "break", ";", "case", "'w'", ":", "if", "(", "sizeof", "(", "unsigned", ")", ">=", "sizeof", "(", "HOST_WIDE_INT", ")", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "XWINT", "(", "k", ",", "fidx", ")", ";", "else", "{", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "HOST_WIDE_INT", ")", "/", "sizeof", "(", "unsigned", ")", ";", "i", "++", ")", "result", "=", "result", "*", "613", "+", "(", "unsigned", ")", "(", "XWINT", "(", "k", ",", "fidx", ")", ">>", "CHAR_BIT", "*", "i", ")", ";", "}", "break", ";", "case", "'0'", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Hash", "functions", "for", "the", "hash", "table", "." ]

[ "rs6000", "3", "0", "1231", "0", "2", "3", "613", "0", "613", "1231", "613", "613", "0", "613" ]

[]

[ "<s>", "static", "void", "free_bundle_state", "(", "struct", "bundle_state", "*", "state", ")", "{", "state", "->", "next", "=", "free_bundle_state_chain", ";", "free_bundle_state_chain", "=", "state", ";", "}", "</s>" ]

[ "The", "following", "function", "frees", "given", "bundle", "state", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "NVPTXInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "unsigned", "RCId", "=", "(", "RegNo", ">>", "28", ")", ";", "switch", "(", "RCId", ")", "{", "default", ":", "report_fatal_error", "(", "\"Bad virtual register encoding\"", ")", ";", "case", "0", ":", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "return", ";", "case", "1", ":", "OS", "<<", "\"%p\"", ";", "break", ";", "case", "2", ":", "OS", "<<", "\"%rs\"", ";", "break", ";", "case", "3", ":", "OS", "<<", "\"%r\"", ";", "break", ";", "case", "4", ":", "OS", "<<", "\"%rd\"", ";", "break", ";", "case", "5", ":", "OS", "<<", "\"%f\"", ";", "break", ";", "case", "6", ":", "OS", "<<", "\"%fd\"", ";", "break", ";", "}", "unsigned", "VReg", "=", "RegNo", "&", "0x0FFFFFFF", ";", "OS", "<<", "VReg", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "28", "\"Bad virtual register encoding\"", "0", "1", "\"%p\"", "2", "\"%rs\"", "3", "\"%r\"", "4", "\"%rd\"", "5", "\"%f\"", "6", "\"%fd\"", "0x0FFFFFFF" ]

[]

[ "<s>", "void", "UnwindOpcodeAssembler", "::", "EmitRegSave", "(", "uint32_t", "RegSave", ")", "{", "if", "(", "RegSave", "==", "0u", ")", "return", ";", "if", "(", "RegSave", "&", "(", "1u", "<<", "4", ")", ")", "{", "uint32_t", "Mask", "=", "RegSave", "&", "0xff0u", ";", "uint32_t", "Range", "=", "countTrailingOnes", "(", "Mask", ">>", "5", ")", ";", "Mask", "&=", "~", "(", "0xffffffe0u", "<<", "Range", ")", ";", "uint32_t", "UnmaskedReg", "=", "RegSave", "&", "0xfff0u", "&", "(", "~", "Mask", ")", ";", "if", "(", "UnmaskedReg", "==", "0u", ")", "{", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_REG_RANGE_R4", "|", "Range", ")", ";", "RegSave", "&=", "0x000fu", ";", "}", "else", "if", "(", "UnmaskedReg", "==", "(", "1u", "<<", "14", ")", ")", "{", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_REG_RANGE_R4_R14", "|", "Range", ")", ";", "RegSave", "&=", "0x000fu", ";", "}", "}", "if", "(", "(", "RegSave", "&", "0xfff0u", ")", "!=", "0", ")", "EmitInt16", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_REG_MASK_R4", "|", "(", "RegSave", ">>", "4", ")", ")", ";", "if", "(", "(", "RegSave", "&", "0x000fu", ")", "!=", "0", ")", "EmitInt16", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_REG_MASK", "|", "(", "RegSave", "&", "0x000fu", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "0u", "1u", "4", "0xff0u", "5", "0xffffffe0u", "0xfff0u", "0u", "ARM::EHABI", "0x000fu", "1u", "14", "ARM::EHABI", "0x000fu", "0xfff0u", "0", "ARM::EHABI", "4", "0x000fu", "0", "ARM::EHABI", "0x000fu" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "TM", ".", "getTargetData", "(", ")", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "const", "std", "::", "vector", "<", "const", "Function", "*", ">", "&", "Personalities", "=", "MMI", "->", "getPersonalities", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "const", "Function", "*", ">", "::", "const_iterator", "I", "=", "Personalities", ".", "begin", "(", ")", ",", "E", "=", "Personalities", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "*", "I", ")", "{", "MCSymbol", "*", "NLPSym", "=", "GetSymbolWithGlobalValueBase", "(", "*", "I", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Mang", "->", "getSymbol", "(", "*", "I", ")", ",", "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", ",", "0", ")", ";", "else", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "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", "0", "PPC", "8", "4", "0", "PPC", "3", "2", "0", "PPC", "8", "4", "0" ]

[]

[ "<s>", "const", "SISubtarget", "*", "GCNTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "StringRef", "GPU", "=", "getGPUName", "(", "F", ")", ";", "StringRef", "FS", "=", "getFeatureString", "(", "F", ")", ";", "SmallString", "<", "128", ">", "SubtargetKey", "(", "GPU", ")", ";", "SubtargetKey", ".", "append", "(", "FS", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "SubtargetKey", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "SISubtarget", ">", "(", "TargetTriple", ",", "GPU", ",", "FS", ",", "*", "this", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "SIGISelActualAccessor", "*", "GISel", "=", "new", "SIGISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AMDGPUCallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "AMDGPULegalizerInfo", "(", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "new", "AMDGPURegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ")", ";", "GISel", "->", "InstSelector", ".", "reset", "(", "new", "AMDGPUInstructionSelector", "(", "*", "I", ",", "*", "static_cast", "<", "AMDGPURegisterBankInfo", "*", ">", "(", "GISel", "->", "RegBankInfo", ".", "get", "(", ")", ")", ")", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "I", "->", "setScalarizeGlobalBehavior", "(", "ScalarizeGlobal", ")", ";", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "storeRegToStack", "(", "MBB", ",", "MBBI", ",", "SrcReg", ",", "isKill", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "Register", "PPCTargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "PPC", "::", "X3", ":", "PPC", "::", "R3", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::X3", "PPC::R3" ]

[]

[ "<s>", "void", "Cpu0SEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "hasCalls", "(", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "Cpu0", "::", "LR", ")", ";", "return", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0::LR" ]

[]

[ "<s>", "int", "arc_output_addsi", "(", "rtx", "*", "operands", ",", "bool", "cond_p", ",", "bool", "output_p", ")", "{", "char", "format", "[", "35", "]", ";", "int", "match", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "int", "match2", "=", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "2", "]", ")", ";", "int", "intval", "=", "(", "REG_P", "(", "operands", "[", "2", "]", ")", "?", "1", ":", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "?", "INTVAL", "(", "operands", "[", "2", "]", ")", ":", "0xbadc057", ")", ";", "int", "neg_intval", "=", "-", "intval", ";", "int", "short_0", "=", "satisfies_constraint_Rcq", "(", "operands", "[", "0", "]", ")", ";", "int", "short_p", "=", "(", "!", "cond_p", "&&", "short_0", "&&", "satisfies_constraint_Rcq", "(", "operands", "[", "1", "]", ")", ")", ";", "int", "ret", "=", "0", ";", "&&", "REGNO", "(", "OP", ")", "!=", "30", ")", "\\", "||", "!", "TARGET_V2", ")", ")", "if", "(", "output_p", ")", "\\", "output_asm_insn", "(", "FORMAT", ",", "operands", ")", ";", "\\", "return", "ret", ";", "\\", "}", "</s>" ]

[ "Emit", "code", "for", "an", "addsi3", "instruction", "with", "OPERANDS", ".", "COND_P", "indicates", "if", "this", "will", "use", "conditional", "execution", ".", "Return", "the", "length", "of", "the", "instruction", ".", "If", "OUTPUT_P", "is", "false", ",", "do", "n't", "actually", "output", "the", "instruction", ",", "just", "return", "its", "length", "." ]

[ "arc", "35", "0", "1", "0", "2", "2", "1", "2", "2", "0xbadc057", "0", "1", "0", "30" ]

[]

[ "<s>", "void", "Thumb1InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "tDest", "=", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "tSrc", "=", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "unsigned", "Opc", "=", "ARM", "::", "tMOVgpr2gpr", ";", "if", "(", "tDest", "&&", "tSrc", ")", "Opc", "=", "ARM", "::", "tMOVr", ";", "else", "if", "(", "tSrc", ")", "Opc", "=", "ARM", "::", "tMOVtgpr2gpr", ";", "else", "if", "(", "tDest", ")", "Opc", "=", "ARM", "::", "tMOVgpr2tgpr", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "assert", "(", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", "&&", "\"Thumb1 can only copy GPR registers\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tGPRRegClass", "ARM::tGPRRegClass", "ARM::tMOVgpr2gpr", "ARM::tMOVr", "ARM::tMOVtgpr2gpr", "ARM::tMOVgpr2tgpr", "ARM::GPRRegClass", "\"Thumb1 can only copy GPR registers\"" ]

[]

[ "<s>", "static", "void", "print_slot", "(", "rtx_sequence", "*", "seq", ")", "{", "final_scan_insn", "(", "seq", "->", "insn", "(", "1", ")", ",", "asm_out_file", ",", "optimize", ",", "1", ",", "NULL", ")", ";", "seq", "->", "insn", "(", "1", ")", "->", "set_deleted", "(", ")", ";", "}", "</s>" ]

[ "Print", "an", "instruction", "which", "would", "have", "gone", "into", "a", "delay", "slot", "after", "another", "instruction", ",", "but", "could", "n't", "because", "the", "other", "instruction", "expanded", "into", "a", "sequence", "where", "putting", "the", "slot", "insn", "at", "the", "end", "would", "n't", "work", "." ]

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

[]

[ "<s>", "static", "void", "nvptx_skip_par", "(", "unsigned", "mask", ",", "parallel", "*", "par", ")", "{", "basic_block", "tail", "=", "par", "->", "join_block", ";", "gcc_assert", "(", "tail", "->", "preds", "->", "length", "(", ")", "==", "1", ")", ";", "basic_block", "pre_tail", "=", "(", "*", "tail", "->", "preds", ")", "[", "0", "]", "->", "src", ";", "gcc_assert", "(", "pre_tail", "->", "succs", "->", "length", "(", ")", "==", "1", ")", ";", "nvptx_single", "(", "mask", ",", "par", "->", "forked_block", ",", "pre_tail", ")", ";", "}", "</s>" ]

[ "PAR", "is", "a", "parallel", "that", "is", "being", "skipped", "in", "its", "entirety", "according", "to", "MASK", ".", "Treat", "this", "as", "skipping", "a", "superblock", "starting", "at", "forked", "and", "ending", "at", "joining", "." ]

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

[]

[ "<s>", "Register", "LanaiRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", ")", "const", "{", "return", "Lanai", "::", "FP", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::FP" ]

[]

[ "<s>", "Instruction", "*", "back", "(", ")", "const", "{", "return", "Chain", ".", "back", "(", ")", ";", "}", "</s>" ]

[ "back", "-", "Get", "the", "last", "character", "in", "the", "string", "." ]

[ "Hexagon" ]

[]

[ "<s>", "PreservedAnalyses", "run", "(", "Module", "&", "M", ",", "ModuleAnalysisManager", "&", ")", "{", "if", "(", "lowerIntrinsics", "(", "M", ")", ")", "return", "PreservedAnalyses", "::", "none", "(", ")", ";", "return", "PreservedAnalyses", "::", "all", "(", ")", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "Result", ".", "reset", "(", "new", "TPCAAResult", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "hasISEL", "(", ")", ")", "return", "false", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "if", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR", "||", "Cond", "[", "1", "]", ".", "getReg", "(", ")", "==", "PPC", "::", "CTR8", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "!", "PPC", "::", "GPRCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "GPRC_NOR0RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RCRegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "!", "PPC", "::", "G8RC_NOX0RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "return", "false", ";", "CondCycles", "=", "1", ";", "TrueCycles", "=", "1", ";", "FalseCycles", "=", "1", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "PowerPC", "PPC", "2", "1", "PPC::CTR", "1", "PPC::CTR8", "PPC::GPRCRegClass", "PPC::GPRC_NOR0RegClass", "PPC::G8RCRegClass", "PPC::G8RC_NOX0RegClass", "1", "1", "1" ]

[]

[ "<s>", "static", "void", "microblaze_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "arg_number", "++", ";", "switch", "(", "arg", ".", "mode", ")", "{", "case", "E_VOIDmode", ":", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_BLKmode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "int_size_in_bytes", "(", "arg", ".", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_SFmode", ":", "cum", "->", "arg_words", "++", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "1", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DFmode", ":", "cum", "->", "arg_words", "+=", "2", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "2", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "2", ";", "break", ";", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_TImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "++", ";", "break", ";", "}", "}", "</s>" ]

[ "Advance", "the", "argument", "to", "the", "next", "argument", "position", "." ]

[ "microblaze", "1", "1", "1", "1", "2", "1", "1", "2", "2", "2", "2", "1", "2", "1", "2", "1" ]

[]

[ "<s>", "void", "SNESAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SNESMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "{", "assert", "(", "getSubtarget", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", "&&", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", ")", ";", "expandLoadStackGuard", "(", "MI", ")", ";", "MI", ".", "getParent", "(", ")", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MEMCPY", ")", "{", "expandMEMCPY", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "!", "MI", ".", "isCopy", "(", ")", "||", "Subtarget", ".", "dontWidenVMOVS", "(", ")", "||", "!", "Subtarget", ".", "hasFP64", "(", ")", ")", "return", "false", ";", "Register", "DstRegS", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcRegS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "MI", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", ".", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", ".", "RemoveOperand", "(", "ImpDefIdx", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MIB", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", ".", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"LOAD_STACK_GUARD currently supported only for MachO.\"", "ARM::MEMCPY", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "ARMCC::AL", "1", "1", "1", "\"replaced by: \"" ]

[]

[ "<s>", "Z80Subtarget", "&", "Z80Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "ParseSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "HasIdxHalfRegs", "=", "HasUndocOps", "||", "HasEZ80Ops", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "Z80", "Z80" ]

[]

[ "<s>", "static", "void", "rs6000_init_dwarf_reg_sizes_extra", "(", "tree", "address", ")", "{", "if", "(", "TARGET_MACHO", "&&", "!", "TARGET_ALTIVEC", ")", "{", "int", "i", ";", "machine_mode", "mode", "=", "TYPE_MODE", "(", "char_type_node", ")", ";", "rtx", "addr", "=", "expand_expr", "(", "address", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "addr", ")", ";", "rtx", "value", "=", "gen_int_mode", "(", "16", ",", "mode", ")", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "LAST_ALTIVEC_REGNO", "+", "1", ";", "i", "++", ")", "{", "int", "column", "=", "DWARF_REG_TO_UNWIND_COLUMN", "(", "DWARF2_FRAME_REG_OUT", "(", "DWARF_FRAME_REGNUM", "(", "i", ")", ",", "true", ")", ")", ";", "HOST_WIDE_INT", "offset", "=", "column", "*", "GET_MODE_SIZE", "(", "mode", ")", ";", "emit_move_insn", "(", "adjust_address", "(", "mem", ",", "mode", ",", "offset", ")", ",", "value", ")", ";", "}", "}", "}", "</s>" ]

[ "Fill", "in", "sizes", "of", "registers", "used", "by", "unwinder", "." ]

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

[]

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

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

[ "XCore" ]

[]

[ "<s>", "void", "sparc_expand_vcond", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ",", "int", "ccode", ",", "int", "fcode", ")", "{", "rtx", "mask", ",", "cop0", ",", "cop1", ",", "fcmp", ",", "cmask", ",", "bshuf", ",", "gsr", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "mask", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "cop0", "=", "operands", "[", "4", "]", ";", "cop1", "=", "operands", "[", "5", "]", ";", "if", "(", "code", "==", "LT", "||", "code", "==", "GE", ")", "{", "rtx", "t", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "t", "=", "cop0", ";", "cop0", "=", "cop1", ";", "cop1", "=", "t", ";", "}", "gsr", "=", "gen_rtx_REG", "(", "DImode", ",", "SPARC_GSR_REG", ")", ";", "fcmp", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "cop0", ",", "cop1", ")", ")", ",", "fcode", ")", ";", "cmask", "=", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "2", ",", "mask", ",", "gsr", ")", ",", "ccode", ")", ";", "bshuf", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "gsr", ")", ",", "UNSPEC_BSHUFFLE", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "mask", ",", "fcmp", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "gsr", ",", "cmask", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "bshuf", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "conditionally", "move", "a", "combination", "of", "OPERANDS", "[", "1", "]", "and", "OPERANDS", "[", "2", "]", "into", "OPERANDS", "[", "0", "]", "in", "MODE", ",", "depending", "on", "the", "outcome", "of", "the", "comparison", "of", "OPERANDS", "[", "4", "]", "and", "OPERANDS", "[", "5", "]", ".", "OPERANDS", "[", "3", "]", "is", "the", "operator", "of", "the", "condition", ".", "FCODE", "is", "the", "machine", "code", "to", "be", "used", "for", "OPERANDS", "[", "3", "]", "and", "CCODE", "the", "machine", "code", "to", "be", "used", "for", "the", "condition", "mask", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "Fn", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "1", "0", "X86", "0" ]

[]

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

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

[ "M680x0" ]

[]

[ "<s>", "static", "bool", "nios2_tls_symbol_p", "(", "rtx", "x", ")", "{", "return", "(", "targetm", ".", "have_tls", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "a", "thread-local", "symbol", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "RESTORE_CR", ":", "case", "PPC", "::", "RESTORE_CRBIT", ":", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LXVD2X", ":", "case", "PPC", "::", "LXVX", ":", "case", "PPC", "::", "QVLFDX", ":", "case", "PPC", "::", "QVLFSXs", ":", "case", "PPC", "::", "QVLFDXb", ":", "case", "PPC", "::", "RESTORE_VRSAVE", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "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", "." ]

[ "PowerPC", "PPC", "PPC::LD", "PPC::LWZ", "PPC::LFS", "PPC::LFD", "PPC::RESTORE_CR", "PPC::RESTORE_CRBIT", "PPC::LVX", "PPC::LXVD2X", "PPC::LXVX", "PPC::QVLFDX", "PPC::QVLFSXs", "PPC::QVLFDXb", "PPC::RESTORE_VRSAVE", "1", "1", "2", "2", "0", "0" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "ParseInstruction", "(", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "size_t", "Start", "=", "0", ",", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "unsigned", "CC", "=", "StringSwitch", "<", "unsigned", ">", "(", "Head", ".", "substr", "(", "Head", ".", "size", "(", ")", "-", "2", ")", ")", ".", "Case", "(", "\"eq\"", ",", "ARMCC", "::", "EQ", ")", ".", "Case", "(", "\"ne\"", ",", "ARMCC", "::", "NE", ")", ".", "Case", "(", "\"hs\"", ",", "ARMCC", "::", "HS", ")", ".", "Case", "(", "\"lo\"", ",", "ARMCC", "::", "LO", ")", ".", "Case", "(", "\"mi\"", ",", "ARMCC", "::", "MI", ")", ".", "Case", "(", "\"pl\"", ",", "ARMCC", "::", "PL", ")", ".", "Case", "(", "\"vs\"", ",", "ARMCC", "::", "VS", ")", ".", "Case", "(", "\"vc\"", ",", "ARMCC", "::", "VC", ")", ".", "Case", "(", "\"hi\"", ",", "ARMCC", "::", "HI", ")", ".", "Case", "(", "\"ls\"", ",", "ARMCC", "::", "LS", ")", ".", "Case", "(", "\"ge\"", ",", "ARMCC", "::", "GE", ")", ".", "Case", "(", "\"lt\"", ",", "ARMCC", "::", "LT", ")", ".", "Case", "(", "\"gt\"", ",", "ARMCC", "::", "GT", ")", ".", "Case", "(", "\"le\"", ",", "ARMCC", "::", "LE", ")", ".", "Case", "(", "\"al\"", ",", "ARMCC", "::", "AL", ")", ".", "Default", "(", "~", "0U", ")", ";", "if", "(", "CC", "==", "~", "0U", "||", "(", "CC", "==", "ARMCC", "::", "LS", "&&", "(", "Head", "==", "\"vmls\"", "||", "Head", "==", "\"vnmls\"", ")", ")", ")", "{", "CC", "=", "ARMCC", "::", "AL", ";", "}", "else", "{", "Head", "=", "Head", ".", "slice", "(", "0", ",", "Head", ".", "size", "(", ")", "-", "2", ")", ";", "}", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ")", ")", ";", "if", "(", "Head", "!=", "\"trap\"", ")", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateCondCode", "(", "ARMCC", "::", "CondCodes", "(", "CC", ")", ",", "NameLoc", ")", ")", ";", "while", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "Start", "=", "Next", ";", "Next", "=", "Name", ".", "find", "(", "'.'", ",", "Start", "+", "1", ")", ";", "Head", "=", "Name", ".", "slice", "(", "Start", ",", "Next", ")", ";", "Operands", ".", "push_back", "(", "ARMOperand", "::", "CreateToken", "(", "Head", ",", "NameLoc", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "TokError", "(", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "2", "\"eq\"", "ARMCC::EQ", "\"ne\"", "ARMCC::NE", "\"hs\"", "ARMCC::HS", "\"lo\"", "ARMCC::LO", "\"mi\"", "ARMCC::MI", "\"pl\"", "ARMCC::PL", "\"vs\"", "ARMCC::VS", "\"vc\"", "ARMCC::VC", "\"hi\"", "ARMCC::HI", "\"ls\"", "ARMCC::LS", "\"ge\"", "ARMCC::GE", "\"lt\"", "ARMCC::LT", "\"gt\"", "ARMCC::GT", "\"le\"", "ARMCC::LE", "\"al\"", "ARMCC::AL", "0U", "0U", "ARMCC::LS", "\"vmls\"", "\"vnmls\"", "ARMCC::AL", "0", "2", "ARM", "\"trap\"", "ARM", "ARMCC::CondCodes", "1", "ARM", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "static", "void", "ix86_output_indirect_branch", "(", "rtx", "call_op", ",", "const", "char", "*", "xasm", ",", "bool", "sibcall_p", ")", "{", "if", "(", "REG_P", "(", "call_op", ")", ")", "ix86_output_indirect_branch_via_reg", "(", "call_op", ",", "sibcall_p", ")", ";", "else", "ix86_output_indirect_branch_via_push", "(", "call_op", ",", "xasm", ",", "sibcall_p", ")", ";", "}", "</s>" ]

[ "Output", "indirect", "branch", "via", "a", "call", "and", "return", "thunk", ".", "CALL_OP", "is", "the", "branch", "target", ".", "XASM", "is", "the", "assembly", "template", "for", "CALL_OP", ".", "Branch", "is", "a", "tail", "call", "if", "SIBCALL_P", "is", "true", "." ]

[ "i386" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "OS", ")", "{", "printInstFlags", "(", "MI", ",", "OS", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", "{", "OS", "<<", "\"\\tdata32\"", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", "&&", "!", "printVecCompareInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::DATA16_PREFIX", "X86::Mode16Bit", "\"\\tdata32\"", "X86" ]

[]

[ "<s>", "void", "MipsInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", "&&", "!", "printAlias", "(", "*", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "rtx", "loongarch_legitimize_tls_address", "(", "rtx", "loc", ")", "{", "rtx", "dest", ",", "tp", ",", "tmp", ";", "enum", "tls_model", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "loc", ")", ";", "rtx_insn", "*", "insn", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_RETURN", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "insn", "=", "loongarch_call_tls_get_addr", "(", "loc", ",", "SYMBOL_TLSLDM", ",", "tmp", ")", ";", "emit_libcall_block", "(", "insn", ",", "dest", ",", "tmp", ",", "loc", ")", ";", "break", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_RETURN", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "insn", "=", "loongarch_call_tls_get_addr", "(", "loc", ",", "SYMBOL_TLSGD", ",", "tmp", ")", ";", "emit_libcall_block", "(", "insn", ",", "dest", ",", "tmp", ",", "loc", ")", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "tp", "=", "gen_rtx_REG", "(", "Pmode", ",", "THREAD_POINTER_REGNUM", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "loongarch_got_load_tls_ie", "(", "tmp", ",", "loc", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "tmp", ",", "tp", ")", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "tp", "=", "gen_rtx_REG", "(", "Pmode", ",", "THREAD_POINTER_REGNUM", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "loongarch_got_load_tls_le", "(", "tmp", ",", "loc", ")", ")", ";", "dest", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "tmp", ",", "tp", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "dest", ";", "}", "</s>" ]

[ "Generate", "the", "code", "to", "access", "LOC", ",", "a", "thread-local", "SYMBOL_REF", ",", "and", "return", "its", "address", ".", "The", "return", "value", "will", "be", "both", "a", "valid", "address", "and", "a", "valid", "SET_SRC", "(", "either", "a", "REG", "or", "a", "LO_SUM", ")", "." ]

[ "loongarch" ]

[]

[ "<s>", "int", "fp_sethi_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", ")", "{", "long", "i", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "i", ")", ";", "return", "!", "SPARC_SIMM13_P", "(", "i", ")", "&&", "SPARC_SETHI_P", "(", "i", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Nonzero", "if", "OP", "is", "a", "floating", "point", "constant", "which", "can", "be", "loaded", "into", "an", "integer", "register", "using", "a", "single", "sethi", "instruction", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "static", "opt_machine_mode", "ix86_get_mask_mode", "(", "machine_mode", "data_mode", ")", "{", "unsigned", "vector_size", "=", "GET_MODE_SIZE", "(", "data_mode", ")", ";", "unsigned", "nunits", "=", "GET_MODE_NUNITS", "(", "data_mode", ")", ";", "unsigned", "elem_size", "=", "vector_size", "/", "nunits", ";", "if", "(", "(", "TARGET_AVX512F", "&&", "vector_size", "==", "64", ")", "||", "(", "TARGET_AVX512VL", "&&", "(", "vector_size", "==", "32", "||", "vector_size", "==", "16", ")", ")", ")", "{", "if", "(", "elem_size", "==", "4", "||", "elem_size", "==", "8", "||", "(", "TARGET_AVX512BW", "&&", "(", "elem_size", "==", "1", "||", "elem_size", "==", "2", ")", ")", ")", "return", "smallest_int_mode_for_size", "(", "nunits", ")", ";", "}", "scalar_int_mode", "elem_mode", "=", "smallest_int_mode_for_size", "(", "elem_size", "*", "BITS_PER_UNIT", ")", ";", "gcc_assert", "(", "elem_size", "*", "nunits", "==", "vector_size", ")", ";", "return", "mode_for_vector", "(", "elem_mode", ",", "nunits", ")", ";", "}", "</s>" ]

[ "Implemenation", "of", "targetm.vectorize.get_mask_mode", "." ]

[ "i386", "64", "32", "16", "4", "8", "1", "2" ]

[]

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

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

[ "Sparc", "4", "0", "4", "0", "0x01000000" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "isa", "<", "ConstantPointerNull", ">", "(", "C", ")", ")", "{", "assert", "(", "VT", "==", "MVT", "::", "i64", "&&", "\"Expected 64-bit pointers\"", ")", ";", "return", "materializeInt", "(", "ConstantInt", "::", "get", "(", "Type", "::", "getInt64Ty", "(", "*", "Context", ")", ",", "0", ")", ",", "VT", ")", ";", "}", "if", "(", "const", "auto", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "materializeInt", "(", "CI", ",", "VT", ")", ";", "else", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "materializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "materializeGV", "(", "GV", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Emit", "a", "constant", "in", "a", "register", "using", "target-specific", "logic", ",", "such", "as", "constant", "pool", "loads", "." ]

[ "AArch64", "AArch64", "0", "MVT::i64", "\"Expected 64-bit pointers\"", "0", "0" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "static_cast", "<", "VLIWMachineScheduler", "*", ">", "(", "dag", ")", ";", "SchedModel", "=", "DAG", "->", "getSchedModel", "(", ")", ";", "TRI", "=", "DAG", "->", "TRI", ";", "Top", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "Bot", ".", "init", "(", "DAG", ",", "SchedModel", ")", ";", "const", "InstrItineraryData", "*", "Itin", "=", "DAG", "->", "getSchedModel", "(", ")", "->", "getInstrItineraries", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "DAG", "->", "MF", ".", "getTarget", "(", ")", ";", "delete", "Top", ".", "HazardRec", ";", "delete", "Bot", ".", "HazardRec", ";", "Top", ".", "HazardRec", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Bot", ".", "HazardRec", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "CreateTargetMIHazardRecognizer", "(", "Itin", ",", "DAG", ")", ";", "Top", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "Bot", ".", "ResourceModel", "=", "new", "VLIWResourceModel", "(", "TM", ",", "DAG", "->", "getSchedModel", "(", ")", ")", ";", "assert", "(", "(", "!", "llvm", "::", "ForceTopDown", "||", "!", "llvm", "::", "ForceBottomUp", ")", "&&", "\"-misched-topdown incompatible with -misched-bottomup\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "\"-misched-topdown incompatible with -misched-bottomup\"" ]

[]

[ "<s>", "static", "BasicBlock", "::", "iterator", "tryCombine", "(", "BasicBlock", "::", "iterator", "Start", ",", "BasicBlock", "::", "iterator", "End", ")", "{", "assert", "(", "Start", "!=", "End", ")", ";", "auto", "CS", "=", "CallSite", "(", "&", "*", "Start", ")", ";", "unsigned", "Size", "=", "cast", "<", "ConstantInt", ">", "(", "CS", ".", "getArgument", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "auto", "It", "=", "std", "::", "next", "(", "Start", ")", ",", "Prev", "=", "Start", ";", "bool", "Combinable", "=", "false", ";", "for", "(", ";", "It", "!=", "End", ";", "Prev", "=", "It", "++", ")", "{", "if", "(", "auto", "CurrentCS", "=", "storeConstCallSite", "(", "&", "*", "It", ")", ")", "{", "CanCombine", "Status", "=", "canCombine", "(", "Size", ",", "CurrentCS", ")", ";", "if", "(", "Status", "!=", "CanCombine", "::", "No", "&&", "CallSite", "(", "&", "*", "It", ")", ".", "getArgument", "(", "1", ")", "==", "&", "*", "Prev", ")", "{", "Combinable", "=", "true", ";", "Size", "+=", "cast", "<", "ConstantInt", ">", "(", "CurrentCS", ".", "getArgument", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Status", "==", "CanCombine", "::", "Last", "||", "!", "It", "->", "hasOneUse", "(", ")", ")", "{", "++", "It", ";", "break", ";", "}", "continue", ";", "}", "}", "break", ";", "}", "if", "(", "Combinable", "&&", "std", "::", "next", "(", "Start", ")", "!=", "It", ")", "combine", "(", "Start", ",", "It", ")", ";", "return", "It", ";", "}", "</s>" ]

[ "Try", "to", "transform", "MI", "by", "using", "all", "of", "the", "above", "combine", "functions", "." ]

[ "TVM", "2", "1", "2" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "isPCRelRegisterOperandLegal", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "assert", "(", "MO", ".", "isReg", "(", ")", ")", ";", "const", "auto", "*", "MI", "=", "MO", ".", "getParent", "(", ")", ";", "const", "uint8_t", "*", "Beads", "=", "M68k", "::", "getMCInstrBeads", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "*", "Beads", ")", ";", "const", "uint8_t", "EncEAk", "[", "3", "]", "=", "{", "0b011", ",", "0b1", ",", "0b11", "}", ";", "for", "(", "const", "uint8_t", "Pat", ":", "EncEAk", ")", "{", "uint8_t", "Bead", "=", "*", "(", "Beads", "++", ")", ";", "if", "(", "!", "Bead", ")", "return", "false", ";", "switch", "(", "Bead", "&", "0xF", ")", "{", "default", ":", "return", "false", ";", "case", "M68kBeads", "::", "Bits1", ":", "case", "M68kBeads", "::", "Bits2", ":", "case", "M68kBeads", "::", "Bits3", ":", "{", "uint8_t", "Val", "=", "(", "Bead", "&", "0xF0", ")", ">>", "4", ";", "if", "(", "Val", "!=", "Pat", ")", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Allow", "targets", "to", "tell", "MachineVerifier", "whether", "a", "specific", "register", "MachineOperand", "can", "be", "used", "as", "part", "of", "PC-relative", "addressing", "." ]

[ "M68k", "M68k", "M68k::getMCInstrBeads", "3", "0b011", "0b1", "0b11", "0xF", "M68kBeads::Bits1", "M68kBeads::Bits2", "M68kBeads::Bits3", "0xF0", "4" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "HexagonRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegsV3", "[", "]", "=", "{", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsV3EHReturn", "[", "]", "=", "{", "Hexagon", "::", "R0", ",", "Hexagon", "::", "R1", ",", "Hexagon", "::", "R2", ",", "Hexagon", "::", "R3", ",", "Hexagon", "::", "R16", ",", "Hexagon", "::", "R17", ",", "Hexagon", "::", "R18", ",", "Hexagon", "::", "R19", ",", "Hexagon", "::", "R20", ",", "Hexagon", "::", "R21", ",", "Hexagon", "::", "R22", ",", "Hexagon", "::", "R23", ",", "Hexagon", "::", "R24", ",", "Hexagon", "::", "R25", ",", "Hexagon", "::", "R26", ",", "Hexagon", "::", "R27", ",", "0", "}", ";", "bool", "HasEHReturn", "=", "MF", "->", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ";", "switch", "(", "MF", "->", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getHexagonArchVersion", "(", ")", ")", "{", "case", "HexagonSubtarget", "::", "V4", ":", "case", "HexagonSubtarget", "::", "V5", ":", "case", "HexagonSubtarget", "::", "V55", ":", "case", "HexagonSubtarget", "::", "V60", ":", "case", "HexagonSubtarget", "::", "V62", ":", "return", "HasEHReturn", "?", "CalleeSavedRegsV3EHReturn", ":", "CalleeSavedRegsV3", ";", "}", "llvm_unreachable", "(", "\"Callee saved registers requested for unknown architecture \"", "\"version\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon::R0", "Hexagon::R1", "Hexagon::R2", "Hexagon::R3", "Hexagon::R16", "Hexagon::R17", "Hexagon::R18", "Hexagon::R19", "Hexagon::R20", "Hexagon::R21", "Hexagon::R22", "Hexagon::R23", "Hexagon::R24", "Hexagon::R25", "Hexagon::R26", "Hexagon::R27", "0", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Callee saved registers requested for unknown architecture \"", "\"version\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "MipsRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "CSR_SingleFloatOnly_RegMask", ";", "if", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", "return", "CSR_N64_RegMask", ";", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "CSR_N32_RegMask", ";", "if", "(", "Subtarget", ".", "isFP64bit", "(", ")", ")", "return", "CSR_O32_FP64_RegMask", ";", "if", "(", "Subtarget", ".", "isFPXX", "(", ")", ")", "return", "CSR_O32_FPXX_RegMask", ";", "return", "CSR_O32_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Ty", "->", "getTypeID", "(", ")", "==", "Type", "::", "VoidTyID", ")", "return", "AM", ".", "Scale", "==", "0", "&&", "isImmUs", "(", "AM", ".", "BaseOffs", ")", "&&", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "const", "TargetData", "*", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "unsigned", "Size", "=", "TD", "->", "getTypeAllocSize", "(", "Ty", ")", ";", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "Size", ">=", "4", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "%", "4", "==", "0", ";", "}", "switch", "(", "Size", ")", "{", "case", "1", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "2", ":", "case", "3", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs2", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "2", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "default", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "4", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "}", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "XCore", "XCore", "0", "4", "0", "4", "0", "1", "0", "1", "0", "2", "3", "0", "2", "0", "0", "4", "0" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "TM", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", "&&", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "{", "addPass", "(", "createAMDGPUPromoteAlloca", "(", "&", "TM", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "arm_emit_multi_reg_pop", "(", "unsigned", "long", "saved_regs_mask", ")", "{", "int", "num_regs", "=", "0", ";", "int", "i", ",", "j", ";", "rtx", "par", ";", "rtx", "dwarf", "=", "NULL_RTX", ";", "rtx", "tmp", ",", "reg", ";", "bool", "return_in_pc", "=", "saved_regs_mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ";", "int", "offset_adj", ";", "int", "emit_update", ";", "offset_adj", "=", "return_in_pc", "?", "1", ":", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_ARM_REGNUM", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "num_regs", "++", ";", "gcc_assert", "(", "num_regs", "&&", "num_regs", "<=", "16", ")", ";", "emit_update", "=", "(", "saved_regs_mask", "&", "(", "1", "<<", "SP_REGNUM", ")", ")", "?", "0", ":", "1", ";", "par", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "num_regs", "+", "emit_update", "+", "offset_adj", ")", ")", ";", "if", "(", "return_in_pc", ")", "XVECEXP", "(", "par", ",", "0", ",", "0", ")", "=", "ret_rtx", ";", "if", "(", "emit_update", ")", "{", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "num_regs", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "offset_adj", ")", "=", "tmp", ";", "}", "for", "(", "j", "=", "0", ",", "i", "=", "0", ";", "j", "<", "num_regs", ";", "i", "++", ")", "if", "(", "saved_regs_mask", "&", "(", "1", "<<", "i", ")", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "i", ")", ";", "if", "(", "(", "num_regs", "==", "1", ")", "&&", "emit_update", "&&", "!", "return_in_pc", ")", "{", "tmp", "=", "gen_frame_mem", "(", "SImode", ",", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ")", ";", "tmp", "=", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "tmp", ")", ")", ";", "REG_NOTES", "(", "tmp", ")", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "return", ";", "}", "tmp", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "4", "*", "j", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "tmp", ")", "=", "1", ";", "XVECEXP", "(", "par", ",", "0", ",", "j", "+", "emit_update", "+", "offset_adj", ")", "=", "tmp", ";", "if", "(", "i", "!=", "PC_REGNUM", ")", "dwarf", "=", "alloc_reg_note", "(", "REG_CFA_RESTORE", ",", "reg", ",", "dwarf", ")", ";", "j", "++", ";", "}", "if", "(", "return_in_pc", ")", "par", "=", "emit_jump_insn", "(", "par", ")", ";", "else", "par", "=", "emit_insn", "(", "par", ")", ";", "REG_NOTES", "(", "par", ")", "=", "dwarf", ";", "if", "(", "!", "return_in_pc", ")", "arm_add_cfa_adjust_cfa_note", "(", "par", ",", "UNITS_PER_WORD", "*", "num_regs", ",", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "and", "emit", "an", "insn", "pattern", "that", "we", "will", "recognize", "as", "a", "pop_multi", ".", "SAVED_REGS_MASK", "shows", "which", "registers", "need", "to", "be", "restored", ".", "Unfortunately", ",", "since", "this", "insn", "does", "not", "reflect", "very", "well", "the", "actual", "semantics", "of", "the", "operation", ",", "we", "need", "to", "annotate", "the", "insn", "for", "the", "benefit", "of", "DWARF2", "frame", "unwind", "information", "." ]

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

[]

[ "<s>", "unsigned", "MipsTargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "RegisterVT", "=", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "IntermediateVT", "=", "RegisterVT", ";", "NumIntermediates", "=", "VT", ".", "getSizeInBits", "(", ")", "<", "RegisterVT", ".", "getSizeInBits", "(", ")", "?", "VT", ".", "getVectorNumElements", "(", ")", ":", "VT", ".", "getSizeInBits", "(", ")", "/", "RegisterVT", ".", "getSizeInBits", "(", ")", ";", "return", "NumIntermediates", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "SystemZXPLINKFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "SystemZ", "::", "FP64BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "FP64BitRegClass", ",", "TRI", ")", ";", "if", "(", "SystemZ", "::", "VR128BitRegClass", ".", "contains", "(", "Reg", ")", ")", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ",", "CSI", "[", "I", "]", ".", "getFrameIdx", "(", ")", ",", "&", "SystemZ", "::", "VR128BitRegClass", ",", "TRI", ")", ";", "}", "SystemZ", "::", "GPRRegs", "RestoreGPRs", "=", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", ")", "{", "assert", "(", "isInt", "<", "20", ">", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ")", ";", "if", "(", "RestoreGPRs", ".", "LowGPR", "==", "RestoreGPRs", ".", "HighGPR", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LG", ")", ",", "RestoreGPRs", ".", "LowGPR", ")", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ".", "addImm", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ".", "addReg", "(", "0", ")", ";", "else", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "SystemZ", "::", "LMG", ")", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "LowGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "RestoreGPRs", ".", "HighGPR", ",", "RegState", "::", "Define", ")", ";", "MIB", ".", "addReg", "(", "Regs", ".", "getStackPointerRegister", "(", ")", ")", ";", "MIB", ".", "addImm", "(", "Regs", ".", "getStackPointerBias", "(", ")", "+", "RestoreGPRs", ".", "GPROffset", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CSI", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "I", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ">", "RestoreGPRs", ".", "LowGPR", "&&", "Reg", "<", "RestoreGPRs", ".", "HighGPR", ")", "MIB", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "SystemZ::FP64BitRegClass", "SystemZ::FP64BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::VR128BitRegClass", "SystemZ::GPRRegs", "20", "SystemZ::LG", "0", "SystemZ::LMG", "0" ]

[]

[ "<s>", "void", "DLXPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createDLXDelaySlotFillerPass", "(", "getDLXTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "DLX", "DLX" ]

[]

[ "<s>", "static", "void", "sh_canonicalize_comparison", "(", "int", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_preserve_value", ")", "{", "enum", "rtx_code", "tmp_code", "=", "(", "enum", "rtx_code", ")", "*", "code", ";", "sh_canonicalize_comparison", "(", "tmp_code", ",", "*", "op0", ",", "*", "op1", ",", "VOIDmode", ",", "op0_preserve_value", ")", ";", "*", "code", "=", "(", "int", ")", "tmp_code", ";", "}", "</s>" ]

[ "This", "function", "implements", "the", "canonicalize_comparison", "target", "hook", ".", "This", "wrapper", "around", "the", "internally", "used", "sh_canonicalize_comparison", "function", "is", "needed", "to", "do", "the", "enum", "rtx_code", "<", "-", ">", "int", "conversion", ".", "Target", "hooks", "can", "not", "use", "enum", "rtx_code", "in", "its", "definition", "." ]

[ "sh" ]

[]

[ "<s>", "tree", "aarch64_fold_builtin", "(", "tree", "fndecl", ",", "int", "n_args", "ATTRIBUTE_UNUSED", ",", "tree", "*", "args", ",", "bool", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "switch", "(", "fcode", ")", "{", "BUILTIN_VDQF", "(", "UNOP", ",", "abs", ",", "2", ")", "return", "fold_build1", "(", "ABS_EXPR", ",", "type", ",", "args", "[", "0", "]", ")", ";", "VAR1", "(", "UNOP", ",", "floatv2si", ",", "2", ",", "v2sf", ")", "VAR1", "(", "UNOP", ",", "floatv4si", ",", "2", ",", "v4sf", ")", "VAR1", "(", "UNOP", ",", "floatv2di", ",", "2", ",", "v2df", ")", "return", "fold_build1", "(", "FLOAT_EXPR", ",", "type", ",", "args", "[", "0", "]", ")", ";", "default", ":", "break", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_FOLD_BUILTIN", "." ]

[ "aarch64", "2", "0", "2", "2", "2", "0" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMI", "*", "DAG", "=", "createGenericSchedPostRA", "(", "C", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "DAG", "->", "addMutation", "(", "createLoadClusterDAGMutation", "(", "DAG", "->", "TII", ",", "DAG", "->", "TRI", ")", ")", ";", "DAG", "->", "addMutation", "(", "ST", ".", "createFillMFMAShadowMutation", "(", "DAG", "->", "TII", ")", ")", ";", "DAG", "->", "addMutation", "(", "createMFMAIGroupLPDAGMutation", "(", ")", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "create_regs_rtx", "(", "void", ")", "{", "ix_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_X_REGNUM", ")", ";", "iy_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_Y_REGNUM", ")", ";", "d_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "HARD_D_REGNUM", ")", ";", "m68hc11_soft_tmp_reg", "=", "gen_rtx_REG", "(", "HImode", ",", "SOFT_TMP_REGNUM", ")", ";", "stack_push_word", "=", "gen_rtx_MEM", "(", "HImode", ",", "gen_rtx_PRE_DEC", "(", "HImode", ",", "gen_rtx_REG", "(", "HImode", ",", "HARD_SP_REGNUM", ")", ")", ")", ";", "stack_pop_word", "=", "gen_rtx_MEM", "(", "HImode", ",", "gen_rtx_POST_INC", "(", "HImode", ",", "gen_rtx_REG", "(", "HImode", ",", "HARD_SP_REGNUM", ")", ")", ")", ";", "}", "</s>" ]

[ "Reload", "and", "register", "operations", "." ]

[ "m68hc11" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "Subtarget", "->", "hasV6T2Ops", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "R600" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "Subtarget", ".", "hasQPX", "(", ")", "&&", "Op", ".", "size", "(", ")", ">=", "32", "&&", "(", "Op", ".", "isMemcpy", "(", ")", "||", "Op", ".", "size", "(", ")", ">=", "64", ")", "&&", "Op", ".", "isAligned", "(", "Align", "(", "32", ")", ")", "&&", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "return", "MVT", "::", "v4f64", ";", "}", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "&&", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", "||", "(", "(", "Op", ".", "isMemset", "(", ")", "&&", "Subtarget", ".", "hasVSX", "(", ")", ")", "||", "Subtarget", ".", "hasP8Vector", "(", ")", ")", ")", ")", "return", "MVT", "::", "v4i32", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "PowerPC", "PPC", "32", "64", "32", "MVT::v4f64", "16", "16", "MVT::v4i32", "PPC", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "void", "ia64_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "next_cum", "=", "*", "cum", ";", "ia64_function_arg_advance", "(", "&", "next_cum", ",", "mode", ",", "type", ",", "1", ")", ";", "if", "(", "next_cum", ".", "words", "<", "MAX_ARGUMENT_SLOTS", ")", "{", "int", "n", "=", "MAX_ARGUMENT_SLOTS", "-", "next_cum", ".", "words", ";", "*", "pretend_size", "=", "n", "*", "UNITS_PER_WORD", ";", "cfun", "->", "machine", "->", "n_varargs", "=", "n", ";", "}", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ".", "We", "generate", "the", "actual", "spill", "instructions", "during", "prologue", "generation", "." ]

[ "ia64", "1" ]

[]

[ "<s>", "static", "void", "xstormy16_asm_init_sections", "(", "void", ")", "{", "bss100_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", "|", "SECTION_BSS", ",", "output_section_asm_op", ",", "\"\\t.section \\\".bss_below100\\\",\\\"aw\\\",@nobits\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INIT_SECTIONS", "." ]

[ "stormy16", "\"\\t.section \\\".bss_below100\\\",\\\"aw\\\",@nobits\"" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "FSGNJ_D", ":", "case", "RISCV", "::", "FSGNJ_S", ":", "case", "RISCV", "::", "FSGNJ_H", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "case", "RISCV", "::", "ADDI", ":", "case", "RISCV", "::", "ORI", ":", "case", "RISCV", "::", "XORI", ":", "return", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "RISCV", "::", "X0", ")", "||", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "}", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "RISCV", "RISCV", "RISCV::FSGNJ_D", "RISCV::FSGNJ_S", "RISCV::FSGNJ_H", "1", "2", "1", "2", "RISCV::ADDI", "RISCV::ORI", "RISCV::XORI", "1", "1", "RISCV::X0", "2", "2", "0" ]

[]

[ "<s>", "virtual", "EVT", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", ")", "const", "LLVM_OVERRIDE", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "SystemZ", "MVT::i32" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "void", "visium_expand_copysign", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "rtx", "op2", "=", "operands", "[", "2", "]", ";", "rtx", "mask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "0x7fffffff", ")", ")", ";", "rtx", "x", ";", "gcc_assert", "(", "mode", "==", "SFmode", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op1", ")", ")", ")", "op1", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op1", ",", "mode", ")", ";", "if", "(", "op1", "!=", "CONST0_RTX", "(", "mode", ")", ")", "{", "long", "l", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op1", ")", ",", "l", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_int_mode", "(", "l", ",", "SImode", ")", ")", ";", "}", "}", "else", "{", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op1", ")", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op1", ",", "mask", ")", ")", ";", "}", "mask", "=", "force_reg", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ";", "op2", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op2", ")", ")", ";", "op2", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op2", ",", "mask", ")", ")", ";", "if", "(", "op1", "==", "CONST0_RTX", "(", "SFmode", ")", ")", "x", "=", "op2", ";", "else", "x", "=", "force_reg", "(", "SImode", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_lowpart", "(", "SFmode", ",", "x", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "copysign", "of", "OPERANDS", "in", "MODE", "." ]

[ "visium", "0", "1", "2", "0x7fffffff" ]

[]

[ "<s>", "static", "bool", "frv_sort_insn_group_1", "(", "enum", "frv_insn_group", "group", ",", "unsigned", "int", "lower_slot", ",", "unsigned", "int", "upper_slot", ",", "unsigned", "int", "issued", ",", "unsigned", "int", "num_insns", ",", "state_t", "state", ")", "{", "struct", "frv_packet_group", "*", "packet_group", ";", "unsigned", "int", "i", ";", "state_t", "test_state", ";", "size_t", "dfa_size", ";", "rtx_insn", "*", "insn", ";", "if", "(", "lower_slot", "==", "upper_slot", ")", "return", "true", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "group", "]", ";", "dfa_size", "=", "state_size", "(", ")", ";", "test_state", "=", "alloca", "(", "dfa_size", ")", ";", "for", "(", "i", "=", "num_insns", "-", "1", ";", "i", "+", "1", "!=", "0", ";", "i", "--", ")", "if", "(", "~", "issued", "&", "(", "1", "<<", "i", ")", ")", "{", "insn", "=", "packet_group", "->", "sorted", "[", "i", "]", ";", "memcpy", "(", "test_state", ",", "state", ",", "dfa_size", ")", ";", "if", "(", "state_transition", "(", "test_state", ",", "insn", ")", "<", "0", "&&", "cpu_unit_reservation_p", "(", "test_state", ",", "NTH_UNIT", "(", "group", ",", "upper_slot", "-", "1", ")", ")", "&&", "frv_sort_insn_group_1", "(", "group", ",", "lower_slot", ",", "upper_slot", "-", "1", ",", "issued", "|", "(", "1", "<<", "i", ")", ",", "num_insns", ",", "test_state", ")", ")", "{", "packet_group", "->", "sorted", "[", "upper_slot", "-", "1", "]", "=", "insn", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Subroutine", "of", "frv_sort_insn_group", ".", "We", "are", "trying", "to", "sort", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "0", "...", "NUM_INSNS-1", "]", "into", "assembly", "language", "order", ".", "We", "have", "already", "picked", "a", "new", "position", "for", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "X", "]", "if", "bit", "X", "of", "ISSUED", "is", "set", ".", "These", "instructions", "will", "occupy", "elements", "[", "0", ",", "LOWER_SLOT", ")", "and", "[", "UPPER_SLOT", ",", "NUM_INSNS", ")", "of", "the", "final", "(", "sorted", ")", "array", ".", "STATE", "is", "the", "DFA", "state", "after", "issuing", "these", "instructions", ".", "Try", "filling", "elements", "[", "LOWER_SLOT", ",", "UPPER_SLOT", ")", "with", "every", "permutation", "of", "the", "unused", "instructions", ".", "Return", "true", "if", "one", "such", "permutation", "gives", "a", "valid", "ordering", ",", "leaving", "the", "successful", "permutation", "in", "sorted", "[", "]", ".", "Do", "not", "modify", "sorted", "[", "]", "until", "a", "valid", "permutation", "is", "found", "." ]

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

[]

[ "<s>", "rtx", "c4x_operand_subword", "(", "rtx", "op", ",", "int", "i", ",", "int", "validate_address", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "mode", "!=", "HImode", "&&", "mode", "!=", "HFmode", ")", "fatal_insn", "(", "\"c4x_operand_subword: invalid mode\"", ",", "op", ")", ";", "if", "(", "mode", "==", "HFmode", "&&", "REG_P", "(", "op", ")", ")", "fatal_insn", "(", "\"c4x_operand_subword: invalid operand\"", ",", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", ";", "enum", "machine_mode", "submode", ";", "submode", "=", "mode", ";", "if", "(", "mode", "==", "HImode", ")", "submode", "=", "QImode", ";", "else", "if", "(", "mode", "==", "HFmode", ")", "submode", "=", "QFmode", ";", "switch", "(", "code", ")", "{", "case", "POST_INC", ":", "case", "PRE_INC", ":", "return", "gen_rtx_MEM", "(", "submode", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "case", "POST_DEC", ":", "case", "PRE_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "fatal_insn", "(", "\"c4x_operand_subword: invalid autoincrement\"", ",", "op", ")", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "CONST", ":", "case", "CONST_INT", ":", "fatal_insn", "(", "\"c4x_operand_subword: invalid address\"", ",", "op", ")", ";", "case", "LO_SUM", ":", "fatal_insn", "(", "\"c4x_operand_subword: address not offsettable\"", ",", "op", ")", ";", "default", ":", "break", ";", "}", "}", "return", "operand_subword", "(", "op", ",", "i", ",", "validate_address", ",", "mode", ")", ";", "}", "</s>" ]

[ "This", "is", "similar", "to", "operand_subword", "but", "allows", "autoincrement", "addressing", "." ]

[ "c4x", "\"c4x_operand_subword: invalid mode\"", "\"c4x_operand_subword: invalid operand\"", "0", "0", "0", "\"c4x_operand_subword: invalid autoincrement\"", "\"c4x_operand_subword: invalid address\"", "\"c4x_operand_subword: address not offsettable\"" ]

[]

[ "<s>", "void", "x86_output_aligned_bss", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "align", ")", "{", "if", "(", "(", "ix86_cmodel", "==", "CM_MEDIUM", "||", "ix86_cmodel", "==", "CM_MEDIUM_PIC", ")", "&&", "size", ">", "(", "unsigned", "int", ")", "ix86_section_threshold", ")", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "\".lbss\"", ",", "0", ")", ")", ";", "else", "switch_to_section", "(", "bss_section", ")", ";", "ASM_OUTPUT_ALIGN", "(", "file", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "last_assemble_variable_decl", "=", "decl", ";", "ASM_DECLARE_OBJECT_NAME", "(", "file", ",", "name", ",", "decl", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "name", ")", ";", "ASM_OUTPUT_SKIP", "(", "file", ",", "size", "?", "size", ":", "1", ")", ";", "}", "</s>" ]

[ "Utility", "function", "for", "targets", "to", "use", "in", "implementing", "ASM_OUTPUT_ALIGNED_BSS", "." ]

[ "i386", "\".lbss\"", "0", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "EVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "isLegal", "=", "getT2IndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "else", "isLegal", "=", "getARMIndexedAddressParts", "(", "Op", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "!", "isLegal", ")", "return", "false", ";", "AM", "=", "isInc", "?", "ISD", "::", "POST_INC", ":", "ISD", "::", "POST_DEC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ARM", "ISD::POST_INC", "ISD::POST_DEC" ]

[]

[ "<s>", "virtual", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "assert", "(", "!", "\"Not implemented\"", ")", ";", "}", "</s>" ]

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

[ "R600", "\"Not implemented\"" ]

[]

[ "<s>", "static", "void", "alpha_setup_incoming_varargs", "(", "cumulative_args_t", "pcum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "cum", "=", "*", "get_cumulative_args", "(", "pcum", ")", ";", "targetm", ".", "calls", ".", "function_arg_advance", "(", "pack_cumulative_args", "(", "&", "cum", ")", ",", "arg", ")", ";", "if", "(", "cum", ".", "num_args", "<", "6", ")", "{", "if", "(", "!", "no_rtl", ")", "{", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "1", ")", ",", "virtual_incoming_args_rtx", ")", ";", "emit_insn", "(", "gen_arg_home", "(", ")", ")", ";", "}", "*", "pretend_size", "=", "7", "*", "UNITS_PER_WORD", ";", "}", "if", "(", "cum", ">=", "6", ")", "return", ";", "if", "(", "!", "no_rtl", ")", "{", "int", "count", ";", "alias_set_type", "set", "=", "get_varargs_alias_set", "(", ")", ";", "rtx", "tmp", ";", "count", "=", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "count", ">", "6", "-", "cum", ")", "count", "=", "6", "-", "cum", ";", "gcc_assert", "(", "(", "VA_LIST_MAX_FPR_SIZE", "&", "3", ")", "==", "3", ")", ";", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "1", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "(", "cum", "+", "6", ")", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", ",", "tmp", ",", "count", ")", ";", "}", "if", "(", "cfun", "->", "va_list_fpr_size", "&", "2", ")", "{", "tmp", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "cum", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "tmp", ")", "=", "1", ";", "set_mem_alias_set", "(", "tmp", ",", "set", ")", ";", "move_block_from_reg", "(", "16", "+", "cum", "+", "TARGET_FPREGS", "*", "32", ",", "tmp", ",", "count", ")", ";", "}", "}", "*", "pretend_size", "=", "12", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", "." ]

[ "alpha", "6", "1", "7", "6", "6", "6", "3", "3", "1", "6", "1", "16", "2", "1", "16", "32", "12" ]

[]

[ "<s>", "void", "visium_expand_copysign", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "mask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "0x7fffffff", ")", ")", ";", "rtx", "x", ";", "gcc_assert", "(", "mode", "==", "SFmode", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op0", ")", ")", ")", "op0", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op0", ",", "mode", ")", ";", "if", "(", "op0", "!=", "CONST0_RTX", "(", "mode", ")", ")", "{", "long", "l", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op0", ")", ",", "l", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "trunc_int_for_mode", "(", "l", ",", "SImode", ")", ")", ")", ";", "}", "}", "else", "{", "op0", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op0", ")", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op0", ",", "mask", ")", ")", ";", "}", "mask", "=", "force_reg", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ";", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op1", ")", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op1", ",", "mask", ")", ")", ";", "if", "(", "op0", "==", "CONST0_RTX", "(", "SFmode", ")", ")", "x", "=", "op1", ";", "else", "x", "=", "force_reg", "(", "SImode", ",", "gen_rtx_IOR", "(", "SImode", ",", "op0", ",", "op1", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "gen_lowpart", "(", "SFmode", ",", "x", ")", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "copysign", "of", "OPERANDS", "in", "MODE", "." ]

[ "visium", "0", "1", "2", "0x7fffffff" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "Subtarget", "->", "useSjLjEH", "(", ")", "?", "ARM", "::", "NoRegister", ":", "ARM", "::", "R1", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "ARM", "ARM", "ARM::NoRegister", "ARM::R1" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineInstr", "*", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "MR", "=", "MF", ".", "getRegInfo", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "bool", "Is64Bit", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "is64Bit", "(", ")", ";", "unsigned", "CvtaLocalOpcode", "=", "(", "Is64Bit", "?", "NVPTX", "::", "cvta_local_yes_64", ":", "NVPTX", "::", "cvta_local_yes", ")", ";", "unsigned", "MovDepotOpcode", "=", "(", "Is64Bit", "?", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ":", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ";", "if", "(", "!", "MR", ".", "use_empty", "(", "NVPTX", "::", "VRFrame", ")", ")", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "CvtaLocalOpcode", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "NVPTX", "::", "VRFrameLocal", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "MovDepotOpcode", ")", ",", "NVPTX", "::", "VRFrameLocal", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Shrink-wrapping not yet supported\"", "NVPTX", "NVPTX::cvta_local_yes_64", "NVPTX::cvta_local_yes", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::MOV_DEPOT_ADDR", "NVPTX::VRFrame", "NVPTX::VRFrame", "NVPTX::VRFrameLocal", "NVPTX::VRFrameLocal" ]

[]

[ "<s>", "Register", "getScratchRSrcReg", "(", ")", "const", "{", "return", "ScratchRSrcReg", ";", "}", "</s>" ]

[ "Returns", "the", "physical", "register", "reserved", "for", "use", "as", "the", "resource", "descriptor", "for", "scratch", "accesses", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "MVT", "getPointerTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", "=", "0", ")", "const", "override", "{", "return", "MVT", "::", "getIntegerVT", "(", "64", ")", ";", "}", "</s>" ]

[ "Return", "the", "pointer", "type", "for", "the", "given", "address", "space", ",", "defaults", "to", "the", "pointer", "type", "from", "the", "data", "layout", "." ]

[ "AArch64", "0", "MVT::getIntegerVT", "64" ]

[]

[ "<s>", "bool", "tilepro_emit_setcc", "(", "rtx", "operands", "[", "]", ",", "machine_mode", "cmp_mode", ")", "{", "return", "tilepro_emit_setcc_internal", "(", "operands", "[", "0", "]", ",", "GET_CODE", "(", "operands", "[", "1", "]", ")", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ",", "cmp_mode", ")", ";", "}", "</s>" ]

[ "Implement", "cstore", "patterns", "." ]

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

[]

[ "<s>", "BitVector", "TLCS900RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "PCB", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "SPB", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "SRB", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "CGB", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "PCW", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "SPW", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "SRW", ")", ";", "Reserved", ".", "set", "(", "TLCS900", "::", "CGW", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "TLCS900", "::", "FPW", ")", ";", "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", "." ]

[ "TLCS900", "TLCS900", "TLCS900::PCB", "TLCS900::SPB", "TLCS900::SRB", "TLCS900::CGB", "TLCS900::PCW", "TLCS900::SPW", "TLCS900::SRW", "TLCS900::CGW", "TLCS900::FPW" ]

[]

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

[ "Returns", "true", "if", "the", "target", "is", "expected", "to", "pass", "all", "machine", "verifier", "checks", "." ]

[ "X86" ]

[]

[ "<s>", "void", "RISCVAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ",", "Ctx", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "Info", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</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", "." ]

[ "RISCV", "RISCV", "7", "8", "\"Invalid fixup offset!\"", "0", "4", "8", "0xff" ]

[]

[ "<s>", "static", "void", "avr_conditional_register_usage", "(", "void", ")", "{", "if", "(", "AVR_TINY", ")", "{", "const", "int", "tiny_reg_alloc_order", "[", "]", "=", "{", "24", ",", "25", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<=", "17", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "for", "(", "size_t", "i", "=", "18", ";", "i", "<=", "LAST_CALLEE_SAVED_REG", ";", "i", "++", ")", "{", "call_used_regs", "[", "i", "]", "=", "0", ";", "}", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "tiny_reg_alloc_order", ")", ";", "i", "++", ")", "{", "reg_alloc_order", "[", "i", "]", "=", "tiny_reg_alloc_order", "[", "i", "]", ";", "}", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "ADDW_REGS", "]", ")", ";", "CLEAR_HARD_REG_SET", "(", "reg_class_contents", "[", "(", "int", ")", "NO_LD_REGS", "]", ")", ";", "}", "}", "</s>" ]

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

[ "avr", "24", "25", "22", "23", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "0", "17", "1", "1", "18", "0", "0" ]

[]

[ "<s>", "static", "tree", "ix86_builtin_tm_store", "(", "tree", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "switch", "(", "tree_to_uhwi", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "{", "case", "64", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_STORE_M64", ")", ";", "case", "128", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_STORE_M128", ")", ";", "case", "256", ":", "return", "builtin_decl_explicit", "(", "BUILT_IN_TM_STORE_M256", ")", ";", "}", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Return", "the", "builtin", "decl", "needed", "to", "store", "a", "vector", "of", "TYPE", "." ]

[ "i386", "64", "128", "256" ]

[]

[ "<s>", "bool", "OptimizeLEAPass", "::", "isReplaceable", "(", "const", "MachineInstr", "&", "First", ",", "const", "MachineInstr", "&", "Last", ",", "int64_t", "&", "AddrDispShift", ")", "const", "{", "assert", "(", "isLEA", "(", "First", ")", "&&", "isLEA", "(", "Last", ")", "&&", "\"The function works only with LEA instructions\"", ")", ";", "if", "(", "MRI", "->", "getRegClass", "(", "First", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "!=", "MRI", "->", "getRegClass", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "return", "false", ";", "AddrDispShift", "=", "getAddrDispShift", "(", "Last", ",", "1", ",", "First", ",", "1", ")", ";", "for", "(", "auto", "&", "MO", ":", "MRI", "->", "use_nodbg_operands", "(", "Last", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MO", ".", "getParent", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "int", "MemOpNo", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "MemOpNo", "<", "0", ")", "return", "false", ";", "MemOpNo", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "if", "(", "!", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", ",", "MO", ")", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "MI", ".", "getNumOperands", "(", ")", ";", "i", "++", ")", "if", "(", "i", "!=", "(", "unsigned", ")", "(", "MemOpNo", "+", "X86", "::", "AddrBaseReg", ")", "&&", "isIdenticalOp", "(", "MI", ".", "getOperand", "(", "i", ")", ",", "MO", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "isImm", "(", ")", "&&", "!", "isInt", "<", "32", ">", "(", "MI", ".", "getOperand", "(", "MemOpNo", "+", "X86", "::", "AddrDisp", ")", ".", "getImm", "(", ")", "+", "AddrDispShift", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "metadata", "is", "replaceable", "." ]

[ "X86", "\"The function works only with LEA instructions\"", "0", "0", "1", "1", "0", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "0", "X86::AddrBaseReg", "X86::AddrDisp", "32", "X86::AddrDisp" ]

[]

[ "<s>", "static", "enum", "flt_eval_method", "ix86_get_excess_precision", "(", "enum", "excess_precision_type", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "EXCESS_PRECISION_TYPE_FAST", ":", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "case", "EXCESS_PRECISION_TYPE_STANDARD", ":", "case", "EXCESS_PRECISION_TYPE_IMPLICIT", ":", "if", "(", "!", "TARGET_80387", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "else", "if", "(", "!", "TARGET_MIX_SSE_I387", ")", "{", "if", "(", "!", "(", "TARGET_SSE", "&&", "TARGET_SSE_MATH", ")", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE", ";", "else", "if", "(", "TARGET_SSE2", ")", "return", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ";", "}", "return", "(", "type", "==", "EXCESS_PRECISION_TYPE_STANDARD", "?", "FLT_EVAL_METHOD_PROMOTE_TO_FLOAT", ":", "FLT_EVAL_METHOD_UNPREDICTABLE", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "FLT_EVAL_METHOD_UNPREDICTABLE", ";", "}", "</s>" ]

[ "Set", "the", "value", "of", "FLT_EVAL_METHOD", "in", "float.h", ".", "When", "using", "only", "the", "FPU", ",", "assume", "that", "the", "fpcw", "is", "set", "to", "extended", "precision", ";", "when", "using", "only", "SSE", ",", "rounding", "is", "correct", ";", "when", "using", "both", "SSE", "and", "the", "FPU", ",", "the", "rounding", "precision", "is", "indeterminate", ",", "since", "either", "may", "be", "chosen", "apparently", "at", "random", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".insn\"", ")", "return", "ParseDirectiveInsn", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\".insn\"" ]

[]

[ "<s>", "void", "print", "(", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" iteration \"", "<<", "IterCnt", "<<", "'\\n'", ";", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "\" iteration \"" ]

[]

[ "<s>", "static", "void", "loongarch_emit_int_compare", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ")", "{", "static", "const", "enum", "rtx_code", "mag_comparisons", "[", "]", "[", "2", "]", "=", "{", "{", "LEU", ",", "LTU", "}", ",", "{", "GTU", ",", "GEU", "}", ",", "{", "LE", ",", "LT", "}", ",", "{", "GT", ",", "GE", "}", "}", ";", "if", "(", "splittable_const_int_operand", "(", "*", "op1", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "rhs", "=", "INTVAL", "(", "*", "op1", ")", ";", "if", "(", "*", "code", "==", "EQ", "||", "*", "code", "==", "NE", ")", "{", "if", "(", "IMM12_OPERAND", "(", "-", "rhs", ")", ")", "{", "*", "op0", "=", "loongarch_force_binary", "(", "GET_MODE", "(", "*", "op0", ")", ",", "PLUS", ",", "*", "op0", ",", "GEN_INT", "(", "-", "rhs", ")", ")", ";", "*", "op1", "=", "const0_rtx", ";", "}", "}", "else", "{", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mag_comparisons", ")", ";", "i", "++", ")", "{", "HOST_WIDE_INT", "new_rhs", ";", "bool", "increment", "=", "*", "code", "==", "mag_comparisons", "[", "i", "]", "[", "0", "]", ";", "bool", "decrement", "=", "*", "code", "==", "mag_comparisons", "[", "i", "]", "[", "1", "]", ";", "if", "(", "!", "increment", "&&", "!", "decrement", ")", "continue", ";", "if", "(", "(", "increment", "&&", "rhs", "==", "HOST_WIDE_INT_MAX", ")", "||", "(", "decrement", "&&", "rhs", "==", "HOST_WIDE_INT_MIN", ")", ")", "break", ";", "new_rhs", "=", "rhs", "+", "(", "increment", "?", "1", ":", "-", "1", ")", ";", "if", "(", "loongarch_integer_cost", "(", "new_rhs", ")", "<", "loongarch_integer_cost", "(", "rhs", ")", ")", "{", "*", "op1", "=", "GEN_INT", "(", "new_rhs", ")", ";", "*", "code", "=", "mag_comparisons", "[", "i", "]", "[", "increment", "]", ";", "}", "break", ";", "}", "}", "}", "loongarch_extend_comparands", "(", "*", "code", ",", "op0", ",", "op1", ")", ";", "*", "op0", "=", "force_reg", "(", "word_mode", ",", "*", "op0", ")", ";", "if", "(", "*", "op1", "!=", "const0_rtx", ")", "*", "op1", "=", "force_reg", "(", "word_mode", ",", "*", "op1", ")", ";", "}", "</s>" ]

[ "Convert", "a", "comparison", "into", "something", "that", "can", "be", "used", "in", "a", "branch", ".", "On", "entry", ",", "*", "OP0", "and", "*", "OP1", "are", "the", "values", "being", "compared", "and", "*", "CODE", "is", "the", "code", "used", "to", "compare", "them", ".", "Update", "them", "to", "describe", "the", "final", "comparison", "." ]

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

[]

[ "<s>", "bool", "TPCMCInstrInfo", "::", "isPredicated", "(", "MCInstrInfo", "const", "&", "MCII", ",", "MCInst", "const", "&", "MCI", ")", "{", "return", "TPCII", "::", "getIsPredicated", "(", "getDesc", "(", "MCII", ",", "MCI", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "TPC", "TPC", "TPC" ]

[]

[ "<s>", "void", "Z80oldFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "StackSize", "=", "-", "int", "(", "MFI", ".", "getStackSize", "(", ")", ")", ";", "unsigned", "ScratchReg", "=", "Z80old", "::", "HL", ";", "while", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "MI", "->", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ")", "{", "++", "MI", ";", "}", "int", "FPOffset", "=", "-", "1", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ")", "{", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "LD16ri", ")", ",", "ScratchReg", ")", ".", "addImm", "(", "StackSize", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "CALL16i", ")", ")", ".", "addExternalSymbol", "(", "\"_frameset\"", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "ImplicitKill", ")", ";", "return", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "CALL16i", ")", ")", ".", "addExternalSymbol", "(", "\"_frameset0\"", ")", ";", "return", ";", "}", "unsigned", "FrameReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "FrameReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "LD16ri", ")", ",", "FrameReg", ")", ".", "addImm", "(", "0", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "ADD16SP", ")", ",", "FrameReg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "FPOffset", "=", "0", ";", "}", "BuildStackAdjustment", "(", "MF", ",", "MBB", ",", "MI", ",", "DL", ",", "ScratchReg", ",", "StackSize", ",", "FPOffset", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80old::HL", "1", "Z80old::LD16ri", "Z80old::CALL16i", "\"_frameset\"", "Z80old::CALL16i", "\"_frameset0\"", "Z80old::PUSH16r", "Z80old::LD16ri", "0", "Z80old::ADD16SP", "0" ]

[]

[ "<s>", "static", "rtx", "save_gprs", "(", "rtx", "base", ",", "int", "offset", ",", "int", "first", ",", "int", "last", ")", "{", "rtx", "addr", ",", "insn", ",", "note", ";", "int", "i", ";", "addr", "=", "plus_constant", "(", "base", ",", "offset", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "if", "(", "first", "==", "last", ")", "{", "if", "(", "TARGET_64BIT", ")", "insn", "=", "gen_movdi", "(", "addr", ",", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ")", ";", "else", "insn", "=", "gen_movsi", "(", "addr", ",", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "insn", "=", "gen_store_multiple", "(", "addr", ",", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "GEN_INT", "(", "last", "-", "first", "+", "1", ")", ")", ";", "if", "(", "first", "<=", "6", "&&", "current_function_stdarg", ")", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "PATTERN", "(", "insn", ")", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "mem", "=", "XEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "i", ")", ",", "0", ")", ";", "if", "(", "first", "+", "i", "<=", "6", ")", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "}", "if", "(", "first", ">=", "6", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "else", "if", "(", "last", ">=", "6", ")", "{", "addr", "=", "plus_constant", "(", "base", ",", "offset", "+", "(", "6", "-", "first", ")", "*", "UNITS_PER_WORD", ")", ";", "note", "=", "gen_store_multiple", "(", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "6", ")", ",", "GEN_INT", "(", "last", "-", "6", "+", "1", ")", ")", ";", "note", "=", "PATTERN", "(", "note", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "gen_rtx_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "note", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "note", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "note", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "note", ",", "0", ",", "i", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "insn", "to", "save", "registers", "FIRST", "to", "LAST", "into", "the", "register", "save", "area", "located", "at", "offset", "OFFSET", "relative", "to", "register", "BASE", "." ]

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

[]