Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "MCS51TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "if", "(", "CallConv", "==", "CallingConv", "::", "MCS51_BUILTIN", ")", "{", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MCS51_BUILTIN", ")", ";", "}", "else", "{", "analyzeReturnValues", "(", "Outs", ",", "CCInfo", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeList", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "const", "MCS51MachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "MCS51MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "RetOpc", "=", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "MCS51ISD", "::", "RETI_FLAG", ":", "MCS51ISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "MCS51", "MCS51", "ISD::OutputArg", "16", "MCS51", "MCS51", "4", "1", "0", "\"Can only return in registers!\"", "1", "MCS51", "MCS51", "MCS51ISD::RETI_FLAG", "MCS51ISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "bool", "XCoreTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", "Ty", ")", "const", "{", "MVT", "VT", "=", "getValueType", "(", "Ty", ",", "true", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ")", "{", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "break", ";", "case", "MVT", "::", "i1", ":", "VT", "=", "MVT", "::", "i8", ";", "break", ";", "default", ":", "VT", "=", "MVT", "::", "i32", ";", "break", ";", "}", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "VT", "==", "MVT", "::", "i32", "&&", "!", "AM", ".", "HasBaseReg", "&&", "AM", ".", "Scale", "==", "0", "&&", "AM", ".", "BaseOffs", "%", "4", "==", "0", ";", "}", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i8", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "1", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "MVT", "::", "i16", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs2", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "2", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "case", "MVT", "::", "i32", ":", "if", "(", "AM", ".", "Scale", "==", "0", ")", "{", "return", "isImmUs4", "(", "AM", ".", "BaseOffs", ")", ";", "}", "return", "AM", ".", "Scale", "==", "4", "&&", "AM", ".", "BaseOffs", "==", "0", ";", "}", "return", "false", ";", "}", "</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", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i1", "MVT::i8", "MVT::i32", "MVT::i32", "0", "4", "0", "MVT::i8", "0", "1", "0", "MVT::i16", "0", "2", "0", "MVT::i32", "0", "4", "0" ]

[]

[ "<s>", "AsmToken", "LexToken", "(", ")", "{", "if", "(", "!", "Lexer", ")", "{", "SetError", "(", "SMLoc", "(", ")", ",", "\"No MCAsmLexer installed\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "}", "switch", "(", "AsmInfo", ".", "getAssemblerDialect", "(", ")", ")", "{", "default", ":", "SetError", "(", "SMLoc", "(", ")", ",", "\"Unhandled dialect\"", ")", ";", "return", "AsmToken", "(", "AsmToken", "::", "Error", ",", "\"\"", ",", "0", ")", ";", "case", "0", ":", "return", "LexTokenUAL", "(", ")", ";", "}", "}", "</s>" ]

[ "LexToken", "-", "Read", "the", "next", "token", "and", "return", "its", "code", "." ]

[ "ARM", "\"No MCAsmLexer installed\"", "\"\"", "0", "\"Unhandled dialect\"", "\"\"", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "ReplaceBITCASTResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SADDV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "ADD", ",", "AArch64ISD", "::", "SADDV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UADDV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "ADD", ",", "AArch64ISD", "::", "UADDV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SMINV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "SMIN", ",", "AArch64ISD", "::", "SMINV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UMINV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "UMIN", ",", "AArch64ISD", "::", "UMINV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SMAXV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "SMAX", ",", "AArch64ISD", "::", "SMAXV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UMAXV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "UMAX", ",", "AArch64ISD", "::", "UMAXV", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i128", "&&", "\"unexpected illegal conversion\"", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_128Results", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom expand this\"", "ISD::BITCAST", "AArch64ISD::SADDV", "ISD::ADD", "AArch64ISD::SADDV", "AArch64ISD::UADDV", "ISD::ADD", "AArch64ISD::UADDV", "AArch64ISD::SMINV", "ISD::SMIN", "AArch64ISD::SMINV", "AArch64ISD::UMINV", "ISD::UMIN", "AArch64ISD::UMINV", "AArch64ISD::SMAXV", "ISD::SMAX", "AArch64ISD::SMAXV", "AArch64ISD::UMAXV", "ISD::UMAX", "AArch64ISD::UMAXV", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "0", "MVT::i128", "\"unexpected illegal conversion\"", "ISD::ATOMIC_CMP_SWAP" ]

[]

[ "<s>", "void", "GCNScheduleDAGMILive", "::", "finalizeSchedule", "(", ")", "{", "GCNMaxOccupancySchedStrategy", "&", "S", "=", "(", "GCNMaxOccupancySchedStrategy", "&", ")", "*", "SchedImpl", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"All regions recorded, starting actual scheduling.\\n\"", ")", ";", "LiveIns", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "Pressure", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RescheduleRegions", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "RescheduleRegions", ".", "set", "(", ")", ";", "if", "(", "!", "Regions", ".", "empty", "(", ")", ")", "BBLiveInMap", "=", "getBBLiveInMap", "(", ")", ";", "std", "::", "vector", "<", "std", "::", "unique_ptr", "<", "ScheduleDAGMutation", ">>", "SavedMutations", ";", "do", "{", "Stage", "++", ";", "RegionIdx", "=", "0", ";", "MachineBasicBlock", "*", "MBB", "=", "nullptr", ";", "if", "(", "Stage", ">", "InitialSchedule", ")", "{", "if", "(", "!", "LIS", ")", "break", ";", "if", "(", "Stage", "==", "UnclusteredReschedule", ")", "{", "if", "(", "RescheduleRegions", ".", "none", "(", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Retrying function scheduling without clustering.\\n\"", ")", ";", "}", "if", "(", "Stage", "==", "ClusteredLowOccupancyReschedule", ")", "{", "if", "(", "StartingOccupancy", "<=", "MinOccupancy", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Retrying function scheduling with lowest recorded occupancy \"", "<<", "MinOccupancy", "<<", "\".\\n\"", ")", ";", "S", ".", "setTargetOccupancy", "(", "MinOccupancy", ")", ";", "}", "}", "if", "(", "Stage", "==", "UnclusteredReschedule", ")", "SavedMutations", ".", "swap", "(", "Mutations", ")", ";", "for", "(", "auto", "Region", ":", "Regions", ")", "{", "if", "(", "Stage", "==", "UnclusteredReschedule", "&&", "!", "RescheduleRegions", "[", "RegionIdx", "]", ")", "{", "++", "RegionIdx", ";", "continue", ";", "}", "RegionBegin", "=", "Region", ".", "first", ";", "RegionEnd", "=", "Region", ".", "second", ";", "if", "(", "RegionBegin", "->", "getParent", "(", ")", "!=", "MBB", ")", "{", "if", "(", "MBB", ")", "finishBlock", "(", ")", ";", "MBB", "=", "RegionBegin", "->", "getParent", "(", ")", ";", "startBlock", "(", "MBB", ")", ";", "if", "(", "Stage", "==", "InitialSchedule", ")", "computeBlockPressure", "(", "MBB", ")", ";", "}", "unsigned", "NumRegionInstrs", "=", "std", "::", "distance", "(", "begin", "(", ")", ",", "end", "(", ")", ")", ";", "enterRegion", "(", "MBB", ",", "begin", "(", ")", ",", "end", "(", ")", ",", "NumRegionInstrs", ")", ";", "if", "(", "begin", "(", ")", "==", "end", "(", ")", "||", "begin", "(", ")", "==", "std", "::", "prev", "(", "end", "(", ")", ")", ")", "{", "exitRegion", "(", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Scheduling **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MF", ".", "getName", "(", ")", "<<", "\":\"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\" \"", "<<", "MBB", "->", "getName", "(", ")", "<<", "\"\\n From: \"", "<<", "*", "begin", "(", ")", "<<", "\" To: \"", ";", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", ")", "dbgs", "(", ")", "<<", "*", "RegionEnd", ";", "else", "dbgs", "(", ")", "<<", "\"End\"", ";", "dbgs", "(", ")", "<<", "\" RegionInstrs: \"", "<<", "NumRegionInstrs", "<<", "'\\n'", ")", ";", "schedule", "(", ")", ";", "exitRegion", "(", ")", ";", "++", "RegionIdx", ";", "}", "finishBlock", "(", ")", ";", "if", "(", "Stage", "==", "UnclusteredReschedule", ")", "SavedMutations", ".", "swap", "(", "Mutations", ")", ";", "}", "while", "(", "Stage", "!=", "LastStage", ")", ";", "}", "</s>" ]

[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]

[ "AMDGPU", "\"All regions recorded, starting actual scheduling.\\n\"", "0", "\"Retrying function scheduling without clustering.\\n\"", "\"Retrying function scheduling with lowest recorded occupancy \"", "\".\\n\"", "\"********** MI Scheduling **********\\n\"", "\":\"", "\" \"", "\"\\n From: \"", "\" To: \"", "\"End\"", "\" RegionInstrs: \"" ]

[]

[ "<s>", "bool", "DLXInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "TargetIRAnalysis", "HexagonTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "HexagonTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

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

[]

[ "<s>", "static", "void", "msp430_compute_frame_info", "(", "void", ")", "{", "int", "i", ";", "cfun", "->", "machine", "->", "computed", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "=", "0", ";", "cfun", "->", "machine", "->", "framesize_locals", "=", "get_frame_size", "(", ")", ";", "cfun", "->", "machine", "->", "framesize_outgoing", "=", "crtl", "->", "outgoing_args_size", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARG_POINTER_REGNUM", ";", "i", "++", ")", "if", "(", "msp430_preserve_reg_p", "(", "i", ")", ")", "{", "cfun", "->", "machine", "->", "need_to_save", "[", "i", "]", "=", "1", ";", "cfun", "->", "machine", "->", "framesize_regs", "+=", "(", "TARGET_LARGE", "?", "4", ":", "2", ")", ";", "}", "else", "cfun", "->", "machine", "->", "need_to_save", "[", "i", "]", "=", "0", ";", "if", "(", "(", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", "&", "1", ")", "cfun", "->", "machine", "->", "framesize_locals", "++", ";", "cfun", "->", "machine", "->", "framesize", "=", "(", "cfun", "->", "machine", "->", "framesize_regs", "+", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ")", ";", "}", "</s>" ]

[ "Compute", "all", "the", "frame-related", "fields", "in", "our", "machine_function", "structure", "." ]

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

[]

[ "<s>", "const", "char", "*", "XCoreTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "XCoreISD", "::", "BL", ":", "return", "\"XCoreISD::BL\"", ";", "case", "XCoreISD", "::", "PCRelativeWrapper", ":", "return", "\"XCoreISD::PCRelativeWrapper\"", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "return", "\"XCoreISD::DPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "return", "\"XCoreISD::CPRelativeWrapper\"", ";", "case", "XCoreISD", "::", "LDWSP", ":", "return", "\"XCoreISD::LDWSP\"", ";", "case", "XCoreISD", "::", "STWSP", ":", "return", "\"XCoreISD::STWSP\"", ";", "case", "XCoreISD", "::", "RETSP", ":", "return", "\"XCoreISD::RETSP\"", ";", "case", "XCoreISD", "::", "LADD", ":", "return", "\"XCoreISD::LADD\"", ";", "case", "XCoreISD", "::", "LSUB", ":", "return", "\"XCoreISD::LSUB\"", ";", "case", "XCoreISD", "::", "LMUL", ":", "return", "\"XCoreISD::LMUL\"", ";", "case", "XCoreISD", "::", "MACCU", ":", "return", "\"XCoreISD::MACCU\"", ";", "case", "XCoreISD", "::", "MACCS", ":", "return", "\"XCoreISD::MACCS\"", ";", "case", "XCoreISD", "::", "CRC8", ":", "return", "\"XCoreISD::CRC8\"", ";", "case", "XCoreISD", "::", "BR_JT", ":", "return", "\"XCoreISD::BR_JT\"", ";", "case", "XCoreISD", "::", "BR_JT32", ":", "return", "\"XCoreISD::BR_JT32\"", ";", "case", "XCoreISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "\"XCoreISD::FRAME_TO_ARGS_OFFSET\"", ";", "case", "XCoreISD", "::", "EH_RETURN", ":", "return", "\"XCoreISD::EH_RETURN\"", ";", "case", "XCoreISD", "::", "MEMBARRIER", ":", "return", "\"XCoreISD::MEMBARRIER\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCoreISD::BL", "\"XCoreISD::BL\"", "XCoreISD::PCRelativeWrapper", "\"XCoreISD::PCRelativeWrapper\"", "XCoreISD::DPRelativeWrapper", "\"XCoreISD::DPRelativeWrapper\"", "XCoreISD::CPRelativeWrapper", "\"XCoreISD::CPRelativeWrapper\"", "XCoreISD::LDWSP", "\"XCoreISD::LDWSP\"", "XCoreISD::STWSP", "\"XCoreISD::STWSP\"", "XCoreISD::RETSP", "\"XCoreISD::RETSP\"", "XCoreISD::LADD", "\"XCoreISD::LADD\"", "XCoreISD::LSUB", "\"XCoreISD::LSUB\"", "XCoreISD::LMUL", "\"XCoreISD::LMUL\"", "XCoreISD::MACCU", "\"XCoreISD::MACCU\"", "XCoreISD::MACCS", "\"XCoreISD::MACCS\"", "XCoreISD::CRC8", "\"XCoreISD::CRC8\"", "XCoreISD::BR_JT", "\"XCoreISD::BR_JT\"", "XCoreISD::BR_JT32", "\"XCoreISD::BR_JT32\"", "XCoreISD::FRAME_TO_ARGS_OFFSET", "\"XCoreISD::FRAME_TO_ARGS_OFFSET\"", "XCoreISD::EH_RETURN", "\"XCoreISD::EH_RETURN\"", "XCoreISD::MEMBARRIER", "\"XCoreISD::MEMBARRIER\"" ]

[]

[ "<s>", "static", "bool", "rs6000_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "return", "rs6000_mode_dependent_address_ptr", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODE_DEPENDENT_ADDRESS_P", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasCMov", "(", ")", ")", "return", "false", ";", "if", "(", "Cond", ".", "size", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "(", "X86", "::", "CondCode", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ">", "X86", "::", "COND_S", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</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", "." ]

[ "X86", "X86", "X86", "1", "X86::CondCode", "0", "X86::COND_S", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "2", "2", "2" ]

[]

[ "<s>", "static", "SDValue", "getAllOnesMask", "(", "MVT", "VecVT", ",", "SDValue", "VL", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "{", "MVT", "MaskVT", "=", "getMaskTypeFor", "(", "VecVT", ")", ";", "return", "DAG", ".", "getNode", "(", "RISCVISD", "::", "VMSET_VL", ",", "DL", ",", "MaskVT", ",", "VL", ")", ";", "}", "</s>" ]

[ "Return", "an", "all", "true", "boolean", "vector", "(", "mask", ")", "with", "NumElts", "lanes", "." ]

[ "RISCV", "RISCVISD::VMSET_VL" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Aggressive", "&&", "EnableLoadStoreOpt", ")", "addPass", "(", "createAArch64LoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "EnableA53Fix835769", ")", "addPass", "(", "createAArch64A53Fix835769", "(", ")", ")", ";", "if", "(", "EnableBranchTargets", ")", "addPass", "(", "createAArch64BranchTargetsPass", "(", ")", ")", ";", "if", "(", "BranchRelaxation", ")", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCompressJumpTables", ")", "addPass", "(", "createAArch64CompressJumpTablesPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableCollectLOH", "&&", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSBinFormatMachO", "(", ")", ")", "addPass", "(", "createAArch64CollectLOHPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCustomEHPadPreservedMask", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetLinux", "(", ")", ")", "return", "CSR_AArch64_AAPCS_RegMask", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "for", "the", "registers", "preserved", "by", "the", "unwinder", ",", "or", "nullptr", "if", "no", "custom", "mask", "is", "needed", "." ]

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

[]

[ "<s>", "const", "RegisterBank", "&", "X86RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "X86", "::", "GR8RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR16RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR32RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "GR64RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "X86", "::", "GPRRegBankID", ")", ";", "if", "(", "X86", "::", "FR32XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "FR64XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR128XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR256XRegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", "||", "X86", "::", "VR512RegClass", ".", "hasSubClassEq", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "X86", "::", "VECRRegBankID", ")", ";", "llvm_unreachable", "(", "\"Unsupported register kind yet.\"", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::GR8RegClass", "X86::GR16RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "X86::GPRRegBankID", "X86::FR32XRegClass", "X86::FR64XRegClass", "X86::VR128XRegClass", "X86::VR256XRegClass", "X86::VR512RegClass", "X86::VECRRegBankID", "\"Unsupported register kind yet.\"" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "unsigned", "OperandIdx", "=", "1", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "++", "OperandIdx", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "1", "\"unexpected token\"" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "VTBits", "=", "Op", ".", "getScalarValueSizeInBits", "(", ")", ";", "unsigned", "Opcode", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "case", "X86ISD", "::", "SETCC_CARRY", ":", "return", "VTBits", ";", "case", "X86ISD", "::", "VSEXT", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "Tmp", "+=", "VTBits", "-", "Src", ".", "getScalarValueSizeInBits", "(", ")", ";", "return", "Tmp", ";", "}", "case", "X86ISD", "::", "PACKSS", ":", "{", "unsigned", "SrcBits", "=", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", ";", "unsigned", "Tmp0", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "unsigned", "Tmp1", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Depth", "+", "1", ")", ";", "unsigned", "Tmp", "=", "std", "::", "min", "(", "Tmp0", ",", "Tmp1", ")", ";", "if", "(", "Tmp", ">", "(", "SrcBits", "-", "VTBits", ")", ")", "return", "Tmp", "-", "(", "SrcBits", "-", "VTBits", ")", ";", "return", "1", ";", "}", "case", "X86ISD", "::", "VSHLI", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "APInt", "ShiftVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getAPIntValue", "(", ")", ";", "if", "(", "ShiftVal", ".", "uge", "(", "VTBits", ")", ")", "return", "VTBits", ";", "if", "(", "ShiftVal", ".", "uge", "(", "Tmp", ")", ")", "return", "1", ";", "return", "Tmp", "-", "ShiftVal", ".", "getZExtValue", "(", ")", ";", "}", "case", "X86ISD", "::", "VSRAI", ":", "{", "SDValue", "Src", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Src", ",", "Depth", "+", "1", ")", ";", "APInt", "ShiftVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "->", "getAPIntValue", "(", ")", ";", "ShiftVal", "+=", "Tmp", ";", "return", "ShiftVal", ".", "uge", "(", "VTBits", ")", "?", "VTBits", ":", "ShiftVal", ".", "getZExtValue", "(", ")", ";", "}", "case", "X86ISD", "::", "PCMPGT", ":", "case", "X86ISD", "::", "PCMPEQ", ":", "case", "X86ISD", "::", "CMPP", ":", "case", "X86ISD", "::", "VPCOM", ":", "case", "X86ISD", "::", "VPCOMU", ":", "return", "VTBits", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "X86", "X86", "X86ISD::SETCC_CARRY", "X86ISD::VSEXT", "0", "1", "X86ISD::PACKSS", "0", "0", "1", "1", "1", "1", "X86ISD::VSHLI", "0", "1", "1", "1", "X86ISD::VSRAI", "0", "1", "1", "X86ISD::PCMPGT", "X86ISD::PCMPEQ", "X86ISD::CMPP", "X86ISD::VPCOM", "X86ISD::VPCOMU", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getLargestLegalSuperClass", "(", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "if", "(", "Subtarget", ".", "hasVSX", "(", ")", ")", "{", "if", "(", "RC", "==", "&", "PPC", "::", "F8RCRegClass", ")", "return", "&", "PPC", "::", "VSFRCRegClass", ";", "else", "if", "(", "RC", "==", "&", "PPC", "::", "VRRCRegClass", ")", "return", "&", "PPC", "::", "VSRCRegClass", ";", "else", "if", "(", "RC", "==", "&", "PPC", "::", "F4RCRegClass", "&&", "Subtarget", ".", "hasP8Vector", "(", ")", ")", "return", "&", "PPC", "::", "VSSRCRegClass", ";", "}", "return", "TargetRegisterInfo", "::", "getLargestLegalSuperClass", "(", "RC", ",", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "the", "largest", "super", "class", "of", "RC", "that", "is", "legal", "to", "use", "in", "the", "current", "sub-target", "and", "has", "the", "same", "spill", "size", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC::F8RCRegClass", "PPC::VSFRCRegClass", "PPC::VRRCRegClass", "PPC::VSRCRegClass", "PPC::F4RCRegClass", "PPC::VSSRCRegClass" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "TPCAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "InfosLE", "[", "TPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_loop\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_loop\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "InfosLE", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC::NumTargetFixupKinds", "\"fixup_loop\"", "0", "16", "\"fixup_loop\"", "0", "16", "\"Invalid kind!\"" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "Glue", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDValue", "Callee", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Hexagon", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "RetVal", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "==", "MVT", "::", "i1", ")", "{", "auto", "&", "MRI", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ";", "SDValue", "FR0", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "MVT", "::", "i32", ",", "Glue", ")", ";", "unsigned", "PredR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "PredRegsRegClass", ")", ";", "SDValue", "TPR", "=", "DAG", ".", "getCopyToReg", "(", "FR0", ".", "getValue", "(", "1", ")", ",", "dl", ",", "PredR", ",", "FR0", ".", "getValue", "(", "0", ")", ",", "FR0", ".", "getValue", "(", "2", ")", ")", ";", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "TPR", ".", "getValue", "(", "0", ")", ",", "dl", ",", "PredR", ",", "MVT", "::", "i1", ")", ";", "Glue", "=", "TPR", ".", "getValue", "(", "1", ")", ";", "}", "else", "{", "RetVal", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Glue", ")", ";", "Glue", "=", "RetVal", ".", "getValue", "(", "2", ")", ";", "}", "InVals", ".", "push_back", "(", "RetVal", ".", "getValue", "(", "0", ")", ")", ";", "Chain", "=", "RetVal", ".", "getValue", "(", "1", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::InputArg", "16", "Hexagon", "0", "MVT::i1", "MVT::i32", "Hexagon::PredRegsRegClass", "1", "0", "2", "0", "MVT::i1", "1", "2", "0", "1" ]

[]

[ "<s>", "int", "arm_attr_length_push_multi", "(", "rtx", "parallel_op", ",", "rtx", "first_op", ")", "{", "int", "i", ",", "regno", ",", "hi_reg", ";", "int", "num_saves", "=", "XVECLEN", "(", "parallel_op", ",", "0", ")", ";", "if", "(", "TARGET_ARM", ")", "return", "4", ";", "if", "(", "TARGET_THUMB1", ")", "return", "2", ";", "regno", "=", "REGNO", "(", "first_op", ")", ";", "hi_reg", "=", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "HI_REGS", ")", "&&", "(", "regno", "!=", "LR_REGNUM", ")", ";", "for", "(", "i", "=", "1", ";", "i", "<", "num_saves", "&&", "!", "hi_reg", ";", "i", "++", ")", "{", "regno", "=", "REGNO", "(", "XEXP", "(", "XVECEXP", "(", "parallel_op", ",", "0", ",", "i", ")", ",", "0", ")", ")", ";", "hi_reg", "|=", "(", "REGNO_REG_CLASS", "(", "regno", ")", "==", "HI_REGS", ")", "&&", "(", "regno", "!=", "LR_REGNUM", ")", ";", "}", "if", "(", "!", "hi_reg", ")", "return", "2", ";", "return", "4", ";", "}", "</s>" ]

[ "Compute", "the", "atrribute", "``", "length", "''", "of", "insn", "``", "*", "push_multi", "''", ".", "So", "this", "function", "MUST", "be", "kept", "in", "sync", "with", "that", "insn", "pattern", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev_local", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "HOST_WIDE_INT", "diff", ";", "unsigned", "int", "i", ",", "size", ",", "unspec", ";", "machine_mode", "pred_mode", ";", "if", "(", "d", "->", "vec_flags", "==", "VEC_SVE_PRED", "||", "!", "d", "->", "one_vector_p", "||", "!", "d", "->", "perm", "[", "0", "]", ".", "is_constant", "(", "&", "diff", ")", ")", "return", "false", ";", "size", "=", "(", "diff", "+", "1", ")", "*", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ";", "if", "(", "size", "==", "8", ")", "{", "unspec", "=", "UNSPEC_REV64", ";", "pred_mode", "=", "VNx2BImode", ";", "}", "else", "if", "(", "size", "==", "4", ")", "{", "unspec", "=", "UNSPEC_REV32", ";", "pred_mode", "=", "VNx4BImode", ";", "}", "else", "if", "(", "size", "==", "2", ")", "{", "unspec", "=", "UNSPEC_REV16", ";", "pred_mode", "=", "VNx8BImode", ";", "}", "else", "return", "false", ";", "unsigned", "int", "step", "=", "diff", "+", "1", ";", "for", "(", "i", "=", "0", ";", "i", "<", "step", ";", "++", "i", ")", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "i", ",", "step", ",", "diff", "-", "i", ",", "step", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "rtx", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "1", ",", "d", "->", "op0", ")", ",", "unspec", ")", ";", "if", "(", "d", "->", "vec_flags", "==", "VEC_SVE_DATA", ")", "{", "rtx", "pred", "=", "force_reg", "(", "pred_mode", ",", "CONSTM1_RTX", "(", "pred_mode", ")", ")", ";", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "2", ",", "pred", ",", "src", ")", ",", "UNSPEC_MERGE_PTRUE", ")", ";", "}", "emit_set_insn", "(", "d", "->", "target", ",", "src", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "{", "64,32,16", "}", "insns", ",", "which", "reverse", "elements", "within", "each", "64-bit", ",", "32-bit", "or", "16-bit", "granule", "." ]

[ "aarch64", "0", "1", "8", "4", "2", "1", "0", "1", "2" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "SubExpr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "GBZ80" ]

[]

[ "<s>", "static", "Matcher", "<", "V", ">", "Create", "(", "const", "char", "*", "name", ",", "F", "func", ")", "{", "static_assert", "(", "NoOverlap", "<", "u16", ",", "expected", ",", "OperandAtT", "::", "Mask", "...", ">", ",", "\"Error\"", ")", ";", "Proxy", "<", "typename", "FilterOperand", "<", "OperandAtT", "...", ">", "::", "result", ">", "proxy", "{", "func", "}", ";", "constexpr", "u16", "mask", "=", "(", "~", "OperandAtT", "::", "Mask", "&", "...", "&", "0xFFFF", ")", ";", "constexpr", "bool", "expanded", "=", "(", "OperandAtT", "::", "NeedExpansion", "||", "...", ")", ";", "return", "Matcher", "<", "V", ">", "(", "name", ",", "mask", ",", "expected", ",", "expanded", ",", "proxy", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "Teak", "\"Error\"", "0xFFFF" ]

[]

[ "<s>", "bool", "Mips16DAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "return", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "section", "*", "mips_function_rodata_section", "(", "tree", "decl", ",", "bool", ")", "{", "if", "(", "!", "TARGET_ABICALLS", "||", "TARGET_ABSOLUTE_ABICALLS", "||", "TARGET_GPWORD", ")", "return", "default_function_rodata_section", "(", "decl", ",", "false", ")", ";", "if", "(", "decl", "&&", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "const", "char", "*", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "DECL_COMDAT_GROUP", "(", "decl", ")", "&&", "strncmp", "(", "name", ",", "\".gnu.linkonce.t.\"", ",", "16", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "rname", "[", "14", "]", "=", "'d'", ";", "return", "get_section", "(", "rname", ",", "SECTION_LINKONCE", "|", "SECTION_WRITE", ",", "decl", ")", ";", "}", "else", "if", "(", "flag_function_sections", "&&", "flag_data_sections", "&&", "strncmp", "(", "name", ",", "\".text.\"", ",", "6", ")", "==", "0", ")", "{", "char", "*", "rname", "=", "ASTRDUP", "(", "name", ")", ";", "memcpy", "(", "rname", "+", "1", ",", "\"data\"", ",", "4", ")", ";", "return", "get_section", "(", "rname", ",", "SECTION_WRITE", ",", "decl", ")", ";", "}", "}", "return", "data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FUNCTION_RODATA_SECTION", ".", "The", "complication", "here", "is", "that", ",", "with", "the", "combination", "TARGET_ABICALLS", "&", "&", "!", "TARGET_GPWORD", ",", "jump", "tables", "will", "use", "absolute", "addresses", ",", "and", "should", "therefore", "not", "be", "included", "in", "the", "read-only", "part", "of", "a", "DSO", ".", "Handle", "such", "cases", "by", "selecting", "a", "normal", "data", "section", "instead", "of", "a", "read-only", "one", ".", "The", "logic", "apes", "that", "in", "default_function_rodata_section", "." ]

[ "mips", "\".gnu.linkonce.t.\"", "16", "0", "14", "\".text.\"", "6", "0", "1", "\"data\"", "4" ]

[]

[ "<s>", "bool", "lm32_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "STACK_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "?", "false", ":", "true", ";", "}", "</s>" ]

[ "Implemenent", "TARGET_CAN_ELIMINATE", "." ]

[ "lm32" ]

[]

[ "<s>", "const", "HSAILRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ".", "resolve", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "auto", "FuncTypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getSectionName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "\"Null section for Function Label\"", "\".text\"" ]

[]

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

[ "Enable", "matching", "of", "interleaved", "access", "groups", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "int", "ix86_issue_rate", "(", "void", ")", "{", "switch", "(", "ix86_tune", ")", "{", "case", "PROCESSOR_PENTIUM", ":", "case", "PROCESSOR_LAKEMONT", ":", "case", "PROCESSOR_BONNELL", ":", "case", "PROCESSOR_SILVERMONT", ":", "case", "PROCESSOR_KNL", ":", "case", "PROCESSOR_KNM", ":", "case", "PROCESSOR_INTEL", ":", "case", "PROCESSOR_K6", ":", "case", "PROCESSOR_BTVER2", ":", "case", "PROCESSOR_PENTIUM4", ":", "case", "PROCESSOR_NOCONA", ":", "return", "2", ";", "case", "PROCESSOR_PENTIUMPRO", ":", "case", "PROCESSOR_ATHLON", ":", "case", "PROCESSOR_K8", ":", "case", "PROCESSOR_AMDFAM10", ":", "case", "PROCESSOR_BTVER1", ":", "return", "3", ";", "case", "PROCESSOR_BDVER1", ":", "case", "PROCESSOR_BDVER2", ":", "case", "PROCESSOR_BDVER3", ":", "case", "PROCESSOR_BDVER4", ":", "case", "PROCESSOR_ZNVER1", ":", "case", "PROCESSOR_CORE2", ":", "case", "PROCESSOR_NEHALEM", ":", "case", "PROCESSOR_SANDYBRIDGE", ":", "case", "PROCESSOR_HASWELL", ":", "case", "PROCESSOR_GENERIC", ":", "return", "4", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "maximum", "number", "of", "instructions", "a", "cpu", "can", "issue", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "int", "icode", "=", "INSN_CODE", "(", "insn", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", "&&", "(", "icode", "==", "CODE_FOR_ctrsi_internal1", "||", "icode", "==", "CODE_FOR_ctrdi_internal1", "||", "icode", "==", "CODE_FOR_ctrsi_internal2", "||", "icode", "==", "CODE_FOR_ctrdi_internal2", "||", "icode", "==", "CODE_FOR_ctrsi_internal3", "||", "icode", "==", "CODE_FOR_ctrdi_internal3", "||", "icode", "==", "CODE_FOR_ctrsi_internal4", "||", "icode", "==", "CODE_FOR_ctrdi_internal4", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_LEGITIMATE_COMBINED_INSN", "hook", "." ]

[ "rs6000" ]

[]

[ "<s>", "SDValue", "XtensaTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "LLVM_DEBUG", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"ISelDAG: Lowering formal arguments\\n\"", ")", ";", "if", "(", "isVarArg", ")", "{", "LLVM_DEBUG", "(", "llvm", "::", "errs", "(", ")", "<<", "\"ISelDAG: Can't lower variadic arguments\\n\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CCAssignFnForCall", "(", "CallConv", ",", "isVarArg", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "XtensaISD", "::", "ENTRY_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "{", "Chain", ",", "DAG", ".", "getRegister", "(", "Xtensa", "::", "a1", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getTargetConstant", "(", "4", ",", "DL", ",", "MVT", "::", "i32", ")", "}", ")", ";", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Ins", ".", "size", "(", ")", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "assert", "(", "VA", ".", "needsCustom", "(", ")", "==", "false", "&&", "\"Doesn't support custom argument lowering\"", ")", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "RegVT", "==", "MVT", "::", "i32", ")", "RC", "=", "&", "Xtensa", "::", "GPRRegClass", ";", "else", "if", "(", "RegVT", "==", "MVT", "::", "f32", ")", "RC", "=", "&", "Xtensa", "::", "FPRRegClass", ";", "else", "llvm_unreachable", "(", "\"Unhandled simple type\"", ")", ";", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "RC", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RegVT", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "ArgValue", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "llvm", "::", "errs", "(", ")", "<<", "\"ISelDAG: Too many arguments passed to function\\n\"", ";", "return", "SDValue", "(", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "ISD::InputArg", "\"ISelDAG: Lowering formal arguments\\n\"", "\"ISelDAG: Can't lower variadic arguments\\n\"", "16", "XtensaISD::ENTRY_FLAG", "MVT::Other", "Xtensa::a1", "MVT::i32", "4", "MVT::i32", "\"Doesn't support custom argument lowering\"", "MVT::i32", "Xtensa::GPRRegClass", "MVT::f32", "Xtensa::FPRRegClass", "\"Unhandled simple type\"", "\"Unknown loc info!\"", "ISD::BITCAST", "\"ISelDAG: Too many arguments passed to function\\n\"" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "arc_init", "(", "void", ")", "{", "if", "(", "TARGET_V2", ")", "{", "if", "(", "TARGET_MPYW", "||", "TARGET_MULTI", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "ARC_TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "ARC_TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_NOMPY_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_ARC600_FAMILY", ")", "error", "(", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "||", "TARGET_DPFP_COMPACT_SET", "||", "TARGET_SPFP", ")", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"no FPX/FPU mixing allowed\"", ")", ";", "if", "(", "flag_pic", "&&", "TARGET_ARC600_FAMILY", ")", "{", "warning", "(", "0", ",", "\"PIC is not supported for %qs\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "arc_punct_chars", "[", "'+'", "]", "=", "1", ";", "arc_punct_chars", "[", "'_'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "arc", "1", "0", "4", "30", "3", "30", "4", "30", "\"%<-mno-mpy%> supported only for ARC700 or ARCv2\"", "\"%<-mno-dpfp-lrsr%> supported only with %<-mdpfp%>\"", "\"FPX fast and compact options cannot be specified together\"", "\"%<-mspfp_fast%> not available on ARC600 or ARC601\"", "\"no FPX/FPU mixing allowed\"", "0", "\"PIC is not supported for %qs\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "LLT", "MemTy", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", "||", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "{", "MemTy", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "assert", "(", "MRI", ".", "getType", "(", "ValVReg", ")", ".", "isScalar", "(", ")", "&&", "\"Only scalars supported atm\"", ")", ";", "auto", "LoadVReg", "=", "buildLoad", "(", "LLT", "::", "scalar", "(", "32", ")", ",", "Addr", ",", "MemTy", ",", "MPO", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "LoadVReg", ")", ";", "}", "else", "{", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "MemTy", ",", "MPO", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "32", "\"Only scalars supported atm\"", "32" ]

[]

[ "<s>", "void", "X86AsmParser", "::", "EmitInstruction", "(", "MCInst", "&", "Inst", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "Instrumentation", "->", "InstrumentAndEmitInstruction", "(", "Inst", ",", "Operands", ",", "getContext", "(", ")", ",", "MII", ",", "Out", ")", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "const", "AArch64TargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "rtx", "mark_constant_pool_use", "(", "rtx", "x", ")", "{", "if", "(", "x", "==", "NULL_RTX", ")", "return", "x", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "case", "CODE_LABEL", ":", "break", ";", "default", ":", "return", "x", ";", "}", "rtx_insn", "*", "lab", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ";", "for", "(", "rtx_insn", "*", "insn", "=", "PREV_INSN", "(", "lab", ")", ";", "insn", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "LABEL_P", "(", "insn", ")", "||", "LABEL_REFS", "(", "insn", ")", "!=", "NEXT_INSN", "(", "insn", ")", ")", "break", ";", "lab", "=", "insn", ";", "}", "for", "(", "rtx", "insn", "=", "LABEL_REFS", "(", "lab", ")", ";", "insn", ";", "insn", "=", "LABEL_REFS", "(", "insn", ")", ")", "as_a", "<", "rtx_insn", "*", ">", "(", "insn", ")", "->", "set_deleted", "(", ")", ";", "for", "(", "rtx_insn", "*", "insn", "=", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "x", ")", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "UNSPEC_VOLATILE", ")", "continue", ";", "switch", "(", "XINT", "(", "pattern", ",", "1", ")", ")", "{", "case", "UNSPECV_CONST2", ":", "case", "UNSPECV_CONST4", ":", "case", "UNSPECV_CONST8", ":", "XVECEXP", "(", "pattern", ",", "0", ",", "1", ")", "=", "const1_rtx", ";", "break", ";", "case", "UNSPECV_WINDOW_END", ":", "if", "(", "XVECEXP", "(", "pattern", ",", "0", ",", "0", ")", "==", "x", ")", "return", "lab", ";", "break", ";", "case", "UNSPECV_CONST_END", ":", "return", "lab", ";", "default", ":", "break", ";", "}", "}", "return", "lab", ";", "}", "</s>" ]

[ "Mark", "the", "use", "of", "a", "constant", "in", "the", "literal", "table", ".", "If", "the", "constant", "has", "multiple", "labels", ",", "make", "it", "unique", "." ]

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

[]

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

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

[ "X86" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "TargetTriple", "(", "TT", ")", ",", "CPUString", "(", "CPU", ")", ",", "IsLittleEndian", "(", "LittleEndian", ")", "{", "initializeSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssemblyReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "WebAssembly", "::", "NoRegister", "+", "1", ";", "PReg", "<", "WebAssembly", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "WebAssembly", "::", "EXPR_STACK", "||", "PReg", "==", "WebAssembly", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "WebAssembly", "::", "NoRegister", ";", "for", "(", "auto", "I", "=", "MRI", ".", "reg_begin", "(", "PReg", ")", ",", "E", "=", "MRI", ".", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", "++", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "WebAssembly", "::", "NoRegister", ")", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MO", ".", "setReg", "(", "VReg", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "WebAssembly::NoRegister", "1", "WebAssembly::NUM_TARGET_REGS", "WebAssembly::EXPR_STACK", "WebAssembly::ARGUMENTS", "WebAssembly::NoRegister", "WebAssembly::NoRegister" ]

[]

[ "<s>", "static", "void", "aarch64_override_options", "(", "void", ")", "{", "unsigned", "long", "cpu_isa", "=", "0", ";", "unsigned", "long", "arch_isa", "=", "0", ";", "aarch64_isa_flags", "=", "0", ";", "bool", "valid_cpu", "=", "true", ";", "bool", "valid_tune", "=", "true", ";", "bool", "valid_arch", "=", "true", ";", "selected_cpu", "=", "NULL", ";", "selected_arch", "=", "NULL", ";", "selected_tune", "=", "NULL", ";", "if", "(", "aarch64_cpu_string", ")", "valid_cpu", "=", "aarch64_validate_mcpu", "(", "aarch64_cpu_string", ",", "&", "selected_cpu", ",", "&", "cpu_isa", ")", ";", "if", "(", "aarch64_arch_string", ")", "valid_arch", "=", "aarch64_validate_march", "(", "aarch64_arch_string", ",", "&", "selected_arch", ",", "&", "arch_isa", ")", ";", "if", "(", "aarch64_tune_string", ")", "valid_tune", "=", "aarch64_validate_mtune", "(", "aarch64_tune_string", ",", "&", "selected_tune", ")", ";", "if", "(", "!", "selected_cpu", ")", "{", "if", "(", "selected_arch", ")", "{", "selected_cpu", "=", "&", "all_cores", "[", "selected_arch", "->", "ident", "]", ";", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "else", "{", "selected_cpu", "=", "aarch64_get_tune_cpu", "(", "aarch64_none", ")", ";", "aarch64_isa_flags", "=", "TARGET_CPU_DEFAULT", ">>", "6", ";", "}", "if", "(", "selected_tune", ")", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "}", "else", "if", "(", "selected_arch", ")", "{", "if", "(", "selected_arch", "->", "arch", "!=", "selected_cpu", "->", "arch", ")", "{", "warning", "(", "0", ",", "\"switch -mcpu=%s conflicts with -march=%s switch\"", ",", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ".", "name", ",", "selected_arch", "->", "name", ")", ";", "}", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "}", "else", "{", "aarch64_isa_flags", "=", "cpu_isa", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "if", "(", "!", "selected_arch", ")", "{", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "}", "if", "(", "!", "selected_tune", ")", "selected_tune", "=", "selected_cpu", ";", "if", "(", "TARGET_ILP32", ")", "error", "(", "\"Assembler does not support -mabi=ilp32\"", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_tune_string", "&&", "valid_tune", ")", ")", "gcc_assert", "(", "explicit_tune_core", "!=", "aarch64_none", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_arch_string", "&&", "valid_arch", ")", ")", "gcc_assert", "(", "explicit_arch", "!=", "aarch64_no_arch", ")", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "aarch64_register_fma_steering", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "aarch64", "0", "0", "0", "6", "0", "\"switch -mcpu=%s conflicts with -march=%s switch\"", "\"Assembler does not support -mabi=ilp32\"" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "getCmpLibcallReturnType", "(", ")", "const", "override", "{", "return", "MVT", "::", "i16", ";", "}", "</s>" ]

[ "Return", "the", "ValueType", "for", "comparison", "libcalls", "." ]

[ "AAP", "MVT::SimpleValueType", "MVT::i16" ]

[]

[ "<s>", "MVT", "RISCVTargetLowering", "::", "getPointerMemTy", "(", "const", "DataLayout", "&", "DL", ",", "uint32_t", "AS", ")", "const", "{", "if", "(", "AS", "==", "UINT32_MAX", ")", "{", "AS", "=", "0", ";", "}", "return", "MVT", "::", "getIntegerVT", "(", "DL", ".", "getPointerSizeInBits", "(", "AS", ")", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "MVT::getIntegerVT" ]

[]

[ "<s>", "bool", "SNESAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "SNES", "::", "A", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "SNES", "::", "X", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "SNES::A", "\"Z\"", "SNES::X", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Replace Physical Registers\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Replace Physical Registers\"" ]

[]

[ "<s>", "const", "RAInfo", "::", "LocType", "&", "getType", "(", ")", "const", "{", "return", "type", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_regs_using_mov", "(", "rtx", "pointer", ",", "HOST_WIDE_INT", "offset", ")", "{", "unsigned", "int", "regno", ";", "rtx", "insn", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "insn", "=", "emit_move_insn", "(", "adjust_address", "(", "gen_rtx_MEM", "(", "Pmode", ",", "pointer", ")", ",", "Pmode", ",", "offset", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "offset", "+=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "POINTER", "+", "OFFSET", "." ]

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

[]

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

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

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

[]

[ "<s>", "void", "DCPU16InstrInfo", "::", "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", "==", "&", "DCPU16", "::", "GR16RegClass", "||", "RC", "==", "&", "DCPU16", "::", "GEXR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "DCPU16", "::", "MOV16rm", ")", ",", "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", "." ]

[ "Dcpu16", "DCPU16", "DCPU16::GR16RegClass", "DCPU16::GEXR16RegClass", "DCPU16::MOV16rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

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

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

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

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "hasStackObjects", "(", ")", ")", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineInstr", "*", "MI", "=", "&", "MBB", ".", "front", "(", ")", ";", "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>", "SDValue", "AMDGPUTargetLowering", "::", "CreateLiveInRegister", "(", "SelectionDAG", "&", "DAG", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ",", "EVT", "VT", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "VirtualRegister", ";", "if", "(", "!", "MRI", ".", "isLiveIn", "(", "Reg", ")", ")", "{", "VirtualRegister", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MRI", ".", "addLiveIn", "(", "Reg", ",", "VirtualRegister", ")", ";", "}", "else", "{", "VirtualRegister", "=", "MRI", ".", "getLiveInVirtReg", "(", "Reg", ")", ";", "}", "return", "DAG", ".", "getRegister", "(", "VirtualRegister", ",", "VT", ")", ";", "}", "</s>" ]

[ "Helper", "function", "that", "adds", "Reg", "to", "the", "LiveIn", "list", "of", "the", "DAG", "'s", "MachineFunction", "." ]

[ "R600" ]

[]

[ "<s>", "static", "int", "vax_address_cost_1", "(", "rtx", "addr", ")", "{", "int", "reg", "=", "0", ",", "indexed", "=", "0", ",", "indir", "=", "0", ",", "offset", "=", "0", ",", "predec", "=", "0", ";", "rtx", "plus_op0", "=", "0", ",", "plus_op1", "=", "0", ";", "restart", ":", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "predec", "=", "1", ";", "case", "REG", ":", "case", "SUBREG", ":", "case", "POST_INC", ":", "reg", "=", "1", ";", "break", ";", "case", "MULT", ":", "case", "ASHIFT", ":", "indexed", "=", "1", ";", "break", ";", "case", "CONST_INT", ":", "if", "(", "offset", "==", "0", ")", "offset", "=", "(", "unsigned", "HOST_WIDE_INT", ")", "(", "INTVAL", "(", "addr", ")", "+", "128", ")", ">", "256", ";", "break", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "offset", "=", "1", ";", "break", ";", "case", "LABEL_REF", ":", "if", "(", "offset", "==", "0", ")", "offset", "=", "1", ";", "break", ";", "case", "PLUS", ":", "if", "(", "plus_op0", ")", "plus_op1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "plus_op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "goto", "restart", ";", "case", "MEM", ":", "indir", "=", "2", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "goto", "restart", ";", "default", ":", "break", ";", "}", "if", "(", "plus_op0", ")", "{", "addr", "=", "plus_op0", ";", "plus_op0", "=", "0", ";", "goto", "restart", ";", "}", "if", "(", "plus_op1", ")", "{", "addr", "=", "plus_op1", ";", "plus_op1", "=", "0", ";", "goto", "restart", ";", "}", "if", "(", "reg", "&&", "indexed", "&&", "offset", ")", "return", "reg", "+", "indir", "+", "offset", "+", "predec", ";", "return", "reg", "+", "indexed", "+", "indir", "+", "offset", "+", "predec", ";", "}", "</s>" ]

[ "Return", "the", "cost", "in", "cycles", "of", "a", "memory", "address", ",", "relative", "to", "register", "indirect", ".", "Each", "of", "the", "following", "adds", "the", "indicated", "number", "of", "cycles", ":", "1", "-", "symbolic", "address", "1", "-", "pre-decrement", "1", "-", "indexing", "and/or", "offset", "(", "register", ")", "2", "-", "indirect" ]

[ "vax", "0", "0", "0", "0", "0", "0", "0", "1", "1", "1", "0", "128", "256", "1", "0", "1", "0", "0", "1", "2", "0", "0", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getNumLocalDynamicTLSAccesses", "(", ")", "<", "2", ")", "{", "return", "false", ";", "}", "MachineDominatorTree", "*", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "return", "VisitNode", "(", "DT", "->", "getRootNode", "(", ")", ",", "0", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "2", "0" ]

[]

[ "<s>", "void", "XCoreMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "const", "PPCMCExpr", "*", "PPCMCExpr", "::", "create", "(", "VariantKind", "Kind", ",", "const", "MCExpr", "*", "Expr", ",", "bool", "IsDarwin", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "PPCMCExpr", "(", "Kind", ",", "Expr", ",", "IsDarwin", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ";", "if", "(", "CC", "==", "CallingConv", "::", "Intel_OCL_BI", ")", "{", "if", "(", "IsWin64", "&&", "HasAVX512", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "Is64Bit", "&&", "HasAVX512", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "IsWin64", "&&", "HasAVX", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "Is64Bit", "&&", "HasAVX", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "GHC", "||", "CC", "==", "CallingConv", "::", "HiPE", ")", "return", "CSR_NoRegs_RegMask", ";", "if", "(", "!", "Is64Bit", ")", "return", "CSR_32_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "Cold", ")", "return", "CSR_MostRegs_64_RegMask", ";", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "needsFixedCatchObjects", "(", ")", "const", "{", "return", "Subtarget", ".", "isTargetWin64", "(", ")", ";", "}", "</s>" ]

[ "Used", "for", "exception", "handling", "on", "Win64", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "aarch64_float_const_zero_rtx_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "false", ";", "if", "(", "REAL_VALUE_MINUS_ZERO", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ")", ")", "return", "!", "HONOR_SIGNED_ZEROS", "(", "GET_MODE", "(", "x", ")", ")", ";", "return", "real_equal", "(", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "&", "dconst0", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "X", "is", "immediate", "constant", "0.0" ]

[ "aarch64" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Opcode", "=", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "addOperand", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "unsigned", "MipsFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "const", "TargetRegisterClass", "*", "RC", "=", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ".", "inMips16Mode", "(", ")", "?", "&", "Mips", "::", "CPU16RegsRegClass", ":", "static_cast", "<", "const", "MipsTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "getABI", "(", ")", ".", "IsN64", "(", ")", "?", "&", "Mips", "::", "GPR64RegClass", ":", "&", "Mips", "::", "GPR32RegClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::CPU16RegsRegClass", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "const", "BasicBlock", "*", "getBasicBlock", "(", ")", "{", "return", "BB", ";", "}", "</s>" ]

[ "Return", "the", "LLVM", "basic", "block", "that", "this", "instance", "corresponded", "to", "originally", "." ]

[ "TPC" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", "&", "getPPCTargetMachine", "(", ")", ")", ")", ";", "bool", "UsePrefetching", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getVendor", "(", ")", "==", "Triple", "::", "BGQ", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "UsePrefetching", "=", "EnablePrefetch", ";", "if", "(", "UsePrefetching", ")", "addPass", "(", "createPPCLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "TM", ",", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "0", "PPC" ]

[]

[ "<s>", "static", "bool", "nvptx_legitimate_address_p", "(", "machine_mode", ",", "rtx", "x", ",", "bool", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "return", "true", ";", "case", "PLUS", ":", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "true", ";", "return", "false", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "X", "is", "a", "valid", "address", "for", "use", "in", "a", "memory", "reference", "." ]

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

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "AC", "=", "&", "getAnalysis", "<", "AssumptionCacheTracker", ">", "(", ")", ".", "getAssumptionCache", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ParseInstruction\\n\"", ")", ";", "getTargetStreamer", "(", ")", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "!", "mnemonicIsValid", "(", "Name", ",", "0", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "NameLoc", ",", "\"unknown instruction\"", ")", ";", "}", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ",", "*", "this", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", "&&", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "if", "(", "parseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "else", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", "&&", "parseParenSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"ParseInstruction\\n\"", "0", "\"unknown instruction\"", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "static", "bool", "ix86_fixed_condition_code_regs", "(", "unsigned", "int", "*", "p1", ",", "unsigned", "int", "*", "p2", ")", "{", "*", "p1", "=", "FLAGS_REG", ";", "*", "p2", "=", "INVALID_REGNUM", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "the", "fixed", "registers", "used", "for", "condition", "codes", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "const", "FunctionType", "*", "FTy", "=", "F", ".", "getFunctionType", "(", ")", ";", "LocalMemAvailable", "=", "ST", ".", "getLocalMemorySize", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "FTy", "->", "getNumParams", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "Type", "*", "ParamTy", "=", "FTy", "->", "getParamType", "(", "i", ")", ";", "if", "(", "ParamTy", "->", "isPointerTy", "(", ")", "&&", "ParamTy", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "{", "LocalMemAvailable", "=", "0", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", ")", ";", "break", ";", "}", "}", "if", "(", "LocalMemAvailable", ">", "0", ")", "{", "for", "(", "Module", "::", "global_iterator", "I", "=", "Mod", "->", "global_begin", "(", ")", ",", "E", "=", "Mod", "->", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GlobalVariable", "*", "GV", "=", "I", ";", "PointerType", "*", "GVTy", "=", "GV", "->", "getType", "(", ")", ";", "if", "(", "GVTy", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "LOCAL_ADDRESS", ")", "continue", ";", "for", "(", "Value", "::", "use_iterator", "U", "=", "GV", "->", "use_begin", "(", ")", ",", "UE", "=", "GV", "->", "use_end", "(", ")", ";", "U", "!=", "UE", ";", "++", "U", ")", "{", "Instruction", "*", "Use", "=", "dyn_cast", "<", "Instruction", ">", "(", "*", "U", ")", ";", "if", "(", "!", "Use", ")", "continue", ";", "if", "(", "Use", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "==", "&", "F", ")", "LocalMemAvailable", "-=", "Mod", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GVTy", "->", "getElementType", "(", ")", ")", ";", "}", "}", "}", "LocalMemAvailable", "=", "std", "::", "max", "(", "0", ",", "LocalMemAvailable", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "LocalMemAvailable", "<<", "\"bytes free in local memory.\\n\"", ")", ";", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "0", "AMDGPUAS::LOCAL_ADDRESS", "0", "\"Function has local memory argument. Promoting to \"", "\"local memory disabled.\\n\"", "0", "AMDGPUAS::LOCAL_ADDRESS", "0", "\"bytes free in local memory.\\n\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Nyuzi", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_Nyuzi_Branch20\"", ",", "5", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Nyuzi_Branch25\"", ",", "0", ",", "25", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_Nyuzi_HI19\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_Nyuzi_IMM_LO13\"", ",", "10", ",", "13", ",", "0", "}", ",", "{", "\"fixup_Nyuzi_GOT\"", ",", "10", ",", "15", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi::NumTargetFixupKinds", "\"fixup_Nyuzi_Branch20\"", "5", "20", "\"fixup_Nyuzi_Branch25\"", "0", "25", "\"fixup_Nyuzi_HI19\"", "0", "32", "0", "\"fixup_Nyuzi_IMM_LO13\"", "10", "13", "0", "\"fixup_Nyuzi_GOT\"", "10", "15", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64bit", ")", ",", "DataLayout", "(", "Subtarget", ".", "getDataLayout", "(", ")", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "FrameInfo", "(", "TargetFrameInfo", "::", "StackGrowsDown", ",", "8", ",", "0", ")", "{", "}", "</s>" ]

[ "Create", "an", "ILP32", "architecture", "model", "." ]

[ "Sparc", "Sparc", "Sparc", "8", "0" ]

[]

[ "<s>", "rtx", "frv_split_minmax", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "minmax", "=", "operands", "[", "1", "]", ";", "rtx", "src1", "=", "operands", "[", "2", "]", ";", "rtx", "src2", "=", "operands", "[", "3", "]", ";", "rtx", "cc_reg", "=", "operands", "[", "4", "]", ";", "rtx", "cr_reg", "=", "operands", "[", "5", "]", ";", "rtx", "ret", ";", "enum", "rtx_code", "test_code", ";", "machine_mode", "cr_mode", "=", "GET_MODE", "(", "cr_reg", ")", ";", "start_sequence", "(", ")", ";", "switch", "(", "GET_CODE", "(", "minmax", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "SMIN", ":", "test_code", "=", "LT", ";", "break", ";", "case", "SMAX", ":", "test_code", "=", "GT", ";", "break", ";", "case", "UMIN", ":", "test_code", "=", "LTU", ";", "break", ";", "case", "UMAX", ":", "test_code", "=", "GTU", ";", "break", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "GET_MODE", "(", "cc_reg", ")", ",", "src1", ",", "src2", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cr_reg", ",", "gen_rtx_fmt_ee", "(", "test_code", ",", "GET_MODE", "(", "cr_reg", ")", ",", "cc_reg", ",", "const0_rtx", ")", ")", ")", ";", "if", "(", "GET_CODE", "(", "src2", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src2", ")", "!=", "0", ")", "{", "gcc_assert", "(", "!", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "src2", ")", ";", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src1", ")", ")", ")", ";", "}", "else", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src1", ")", ")", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src1", ")", ")", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src2", ")", ")", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "cr_mode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src2", ")", ")", ")", ";", "}", "ret", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Split", "a", "min/max", "operation", "returning", "a", "SEQUENCE", "containing", "all", "of", "the", "insns", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "tree", "sh_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "ARRAY_SIZE", "(", "bdesc", ")", ")", "return", "error_mark_node", ";", "if", "(", "!", "bdesc", "[", "code", "]", ".", "is_enabled", "(", ")", ")", "return", "error_mark_node", ";", "return", "bdesc", "[", "code", "]", ".", "fndecl", ";", "}", "</s>" ]

[ "Returns", "the", "sh", "builtin", "decl", "for", "CODE", "." ]

[ "sh" ]

[]

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

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

[ "AMDGPU", "\"AMDGPU Lower Intrinsics\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", "VT", ",", "unsigned", ",", "unsigned", "Alignment", ",", "MachineMemOperand", "::", "Flags", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "AllowsUnaligned", "=", "Subtarget", "->", "allowsUnalignedMem", "(", ")", ";", "auto", "Ty", "=", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ";", "if", "(", "Ty", "==", "MVT", "::", "i8", "||", "Ty", "==", "MVT", "::", "i16", "||", "Ty", "==", "MVT", "::", "i32", ")", "{", "if", "(", "AllowsUnaligned", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "Subtarget", "->", "hasV7Ops", "(", ")", ";", "return", "true", ";", "}", "}", "if", "(", "Ty", "==", "MVT", "::", "f64", "||", "Ty", "==", "MVT", "::", "v2f64", ")", "{", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", "&&", "(", "AllowsUnaligned", "||", "Subtarget", "->", "isLittle", "(", ")", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "}", "if", "(", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "(", "Ty", "==", "MVT", "::", "v16i1", "||", "Ty", "==", "MVT", "::", "v8i1", "||", "Ty", "==", "MVT", "::", "v4i1", ")", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "if", "(", "(", "Ty", "==", "MVT", "::", "v4i8", "||", "Ty", "==", "MVT", "::", "v8i8", "||", "Ty", "==", "MVT", "::", "v4i16", ")", "&&", "Alignment", ">=", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "8", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Ty", "==", "MVT", "::", "v16i8", "||", "Ty", "==", "MVT", "::", "v8i16", "||", "Ty", "==", "MVT", "::", "v8f16", "||", "Ty", "==", "MVT", "::", "v4i32", "||", "Ty", "==", "MVT", "::", "v4f32", "||", "Ty", "==", "MVT", "::", "v2i64", "||", "Ty", "==", "MVT", "::", "v2f64", ")", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::f64", "MVT::v2f64", "MVT::v16i1", "MVT::v8i1", "MVT::v4i1", "MVT::v4i8", "MVT::v8i8", "MVT::v4i16", "8", "MVT::v16i8", "MVT::v8i16", "MVT::v8f16", "MVT::v4i32", "MVT::v4f32", "MVT::v2i64", "MVT::v2f64" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MIB", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Define", ")", ";", "}", "MIB", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "AMDGPU::VGPR_32RegClass", "0" ]

[]

[ "<s>", "int", "arm_split_constant", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "insn", ",", "HOST_WIDE_INT", "val", ",", "rtx", "target", ",", "rtx", "source", ",", "int", "subtargets", ")", "{", "rtx", "cond", ";", "if", "(", "insn", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", ")", "cond", "=", "COND_EXEC_TEST", "(", "PATTERN", "(", "insn", ")", ")", ";", "else", "cond", "=", "NULL_RTX", ";", "if", "(", "subtargets", "||", "code", "==", "SET", "||", "(", "REG_P", "(", "target", ")", "&&", "REG_P", "(", "source", ")", "&&", "REGNO", "(", "target", ")", "!=", "REGNO", "(", "source", ")", ")", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "after_arm_reorg", "&&", "!", "cond", "&&", "(", "arm_gen_constant", "(", "code", ",", "mode", ",", "NULL_RTX", ",", "val", ",", "target", ",", "source", ",", "1", ",", "0", ")", ">", "(", "arm_constant_limit", "(", "optimize_function_for_size_p", "(", "cfun", ")", ")", "+", "(", "code", "!=", "SET", ")", ")", ")", ")", "{", "if", "(", "code", "==", "SET", ")", "{", "if", "(", "TARGET_USE_MOVT", ")", "arm_emit_movpair", "(", "target", ",", "GEN_INT", "(", "val", ")", ")", ";", "else", "emit_set_insn", "(", "target", ",", "GEN_INT", "(", "val", ")", ")", ";", "return", "1", ";", "}", "else", "{", "rtx", "temp", "=", "subtargets", "?", "gen_reg_rtx", "(", "mode", ")", ":", "target", ";", "if", "(", "TARGET_USE_MOVT", ")", "arm_emit_movpair", "(", "temp", ",", "GEN_INT", "(", "val", ")", ")", ";", "else", "emit_set_insn", "(", "temp", ",", "GEN_INT", "(", "val", ")", ")", ";", "if", "(", "code", "==", "MINUS", ")", "emit_set_insn", "(", "target", ",", "gen_rtx_MINUS", "(", "mode", ",", "temp", ",", "source", ")", ")", ";", "else", "emit_set_insn", "(", "target", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "source", ",", "temp", ")", ")", ";", "return", "2", ";", "}", "}", "}", "return", "arm_gen_constant", "(", "code", ",", "mode", ",", "cond", ",", "val", ",", "target", ",", "source", ",", "subtargets", ",", "1", ")", ";", "}", "</s>" ]

[ "Emit", "a", "sequence", "of", "insns", "to", "handle", "a", "large", "constant", ".", "CODE", "is", "the", "code", "of", "the", "operation", "required", ",", "it", "can", "be", "any", "of", "SET", ",", "PLUS", ",", "IOR", ",", "AND", ",", "XOR", ",", "MINUS", ";", "MODE", "is", "the", "mode", "in", "which", "the", "operation", "is", "being", "performed", ";", "VAL", "is", "the", "integer", "to", "operate", "on", ";", "SOURCE", "is", "the", "other", "operand", "(", "a", "register", ",", "or", "a", "null-pointer", "for", "SET", ")", ";", "SUBTARGETS", "means", "it", "is", "safe", "to", "create", "scratch", "registers", "if", "that", "will", "either", "produce", "a", "simpler", "sequence", ",", "or", "we", "will", "want", "to", "cse", "the", "values", ".", "Return", "value", "is", "the", "number", "of", "insns", "emitted", "." ]

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

[]

[ "<s>", "int", "shl_and_scr_length", "(", "rtx", "insn", ")", "{", "rtx", "set_src", "=", "SET_SRC", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ";", "int", "len", "=", "ashl_lshr_seq", "[", "INTVAL", "(", "XEXP", "(", "set_src", ",", "1", ")", ")", "&", "31", "]", ".", "insn_count", ";", "rtx", "op", "=", "XEXP", "(", "set_src", ",", "0", ")", ";", "len", "+=", "ashl_lshr_seq", "[", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&", "31", "]", ".", "insn_count", "+", "1", ";", "op", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "return", "len", "+", "ashl_lshr_seq", "[", "INTVAL", "(", "XEXP", "(", "op", ",", "1", ")", ")", "&", "31", "]", ".", "insn_count", ";", "}", "</s>" ]

[ "This", "is", "used", "in", "length", "attribute", "of", "the", "and_shl_scratch", "instruction", "." ]

[ "sh", "0", "0", "1", "31", "0", "1", "31", "1", "0", "0", "1", "31" ]

[]

[ "<s>", "bool", "nds32_rtx_costs_impl", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "if", "(", "speed", ")", "goto", "performance_cost", ";", "else", "goto", "size_cost", ";", "performance_cost", ":", "switch", "(", "code", ")", "{", "case", "SET", ":", "return", "false", ";", "case", "USE", ":", "*", "total", "=", "0", ";", "break", ";", "case", "MULT", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "case", "DIV", ":", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "7", ")", ";", "break", ";", "default", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "true", ";", "size_cost", ":", "switch", "(", "code", ")", "{", "case", "SET", ":", "return", "false", ";", "case", "USE", ":", "*", "total", "=", "0", ";", "break", ";", "case", "CONST_INT", ":", "if", "(", "outer_code", "==", "SET", ")", "{", "if", "(", "satisfies_constraint_Is05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "if", "(", "satisfies_constraint_Is20", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "}", "else", "if", "(", "outer_code", "==", "PLUS", "||", "outer_code", "==", "MINUS", ")", "{", "if", "(", "satisfies_constraint_Iu05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "if", "(", "outer_code", "==", "ASHIFT", ")", "{", "if", "(", "satisfies_constraint_Iu03", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "if", "(", "outer_code", "==", "ASHIFTRT", "||", "outer_code", "==", "LSHIFTRT", ")", "{", "if", "(", "satisfies_constraint_Iu05", "(", "x", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "-", "2", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "}", "break", ";", "case", "CONST_DOUBLE", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "2", ")", ";", "break", ";", "default", ":", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "nds32", "0", "1", "7", "1", "0", "1", "2", "1", "2", "1", "2", "1", "1", "2", "1", "1", "2", "1", "1", "2", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "mips_use_anchors_for_symbol_p", "(", "const_rtx", "symbol", ")", "{", "switch", "(", "mips_classify_symbol", "(", "symbol", ",", "SYMBOL_CONTEXT_MEM", ")", ")", "{", "case", "SYMBOL_PC_RELATIVE", ":", "case", "SYMBOL_GP_RELATIVE", ":", "return", "false", ";", "default", ":", "return", "default_use_anchors_for_symbol_p", "(", "symbol", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_USE_ANCHORS_FOR_SYMBOL_P", ".", "We", "do", "n't", "want", "to", "use", "anchors", "for", "small", "data", ":", "the", "GP", "register", "acts", "as", "an", "anchor", "in", "that", "case", ".", "We", "also", "do", "n't", "want", "to", "use", "them", "for", "PC-relative", "accesses", ",", "where", "the", "PC", "acts", "as", "an", "anchor", "." ]

[ "mips" ]

[]

[ "<s>", "void", "or1k_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "sp_offset", "=", "-", "cfun", "->", "machine", "->", "total_size", ";", "HOST_WIDE_INT", "reg_offset", ",", "this_offset", ";", "rtx", "insn", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "-", "sp_offset", ";", "if", "(", "sp_offset", "==", "0", ")", "goto", "fini", ";", "reg_offset", "=", "(", "sp_offset", "+", "cfun", "->", "machine", "->", "local_vars_size", "+", "cfun", "->", "machine", "->", "args_size", ")", ";", "this_offset", "=", "MAX", "(", "sp_offset", ",", "-", "32764", ")", ";", "reg_offset", "-=", "this_offset", ";", "sp_offset", "-=", "this_offset", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "this_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "for", "(", "int", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "&&", "regno", "!=", "LR_REGNUM", "&&", "callee_saved_regno_p", "(", "regno", ")", ")", "{", "or1k_save_reg", "(", "regno", ",", "reg_offset", ")", ";", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "callee_saved_regno_p", "(", "HARD_FRAME_POINTER_REGNUM", ")", ")", "{", "or1k_save_reg", "(", "HARD_FRAME_POINTER_REGNUM", ",", "reg_offset", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "this_offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "callee_saved_regno_p", "(", "LR_REGNUM", ")", ")", "{", "or1k_save_reg", "(", "LR_REGNUM", ",", "reg_offset", ")", ";", "reg_offset", "+=", "UNITS_PER_WORD", ";", "}", "gcc_assert", "(", "reg_offset", "+", "this_offset", "==", "0", ")", ";", "if", "(", "sp_offset", "!=", "0", ")", "{", "if", "(", "sp_offset", "<", "2", "*", "-", "32768", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "emit_move_insn", "(", "tmp", ",", "GEN_INT", "(", "sp_offset", ")", ")", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "if", "(", "!", "frame_pointer_needed", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "sp_offset", ")", ")", ")", ";", "}", "}", "else", "{", "do", "{", "this_offset", "=", "MAX", "(", "sp_offset", ",", "-", "32768", ")", ";", "sp_offset", "-=", "this_offset", ";", "insn", "=", "emit_insn", "(", "gen_frame_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "this_offset", ")", ")", ")", ";", "if", "(", "!", "frame_pointer_needed", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "while", "(", "sp_offset", "!=", "0", ")", ";", "}", "}", "fini", ":", "rtx_insn", "*", "set_got_insn", "=", "cfun", "->", "machine", "->", "set_got_insn", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "{", "rtx", "reg", "=", "SET_DEST", "(", "PATTERN", "(", "set_got_insn", ")", ")", ";", "rtx_insn", "*", "insn", "=", "emit_insn_before", "(", "gen_set_got", "(", "reg", ")", ",", "set_got_insn", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_FLUSH_QUEUE", ",", "NULL_RTX", ")", ";", "}", "delete_insn", "(", "set_got_insn", ")", ";", "}", "</s>" ]

[ "Expand", "the", "``", "prologue", "''", "pattern", "." ]

[ "or1k", "0", "32764", "1", "0", "1", "0", "0", "2", "32768", "1", "32768", "1", "0", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "PatmosRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "Patmos", "::", "S0", ",", "Patmos", "::", "SRB", ",", "Patmos", "::", "SRO", ",", "Patmos", "::", "R21", ",", "Patmos", "::", "R22", ",", "Patmos", "::", "R23", ",", "Patmos", "::", "R24", ",", "Patmos", "::", "R25", ",", "Patmos", "::", "R26", ",", "Patmos", "::", "R27", ",", "Patmos", "::", "R28", ",", "Patmos", "::", "P1", ",", "Patmos", "::", "P2", ",", "Patmos", "::", "P3", ",", "Patmos", "::", "P4", ",", "Patmos", "::", "P5", ",", "Patmos", "::", "P6", ",", "Patmos", "::", "P7", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "Patmos", "::", "S0", ",", "Patmos", "::", "SRB", ",", "Patmos", "::", "SRO", ",", "Patmos", "::", "R21", ",", "Patmos", "::", "R22", ",", "Patmos", "::", "R23", ",", "Patmos", "::", "R24", ",", "Patmos", "::", "R25", ",", "Patmos", "::", "R26", ",", "Patmos", "::", "R27", ",", "Patmos", "::", "R28", ",", "Patmos", "::", "RFP", ",", "Patmos", "::", "P1", ",", "Patmos", "::", "P2", ",", "Patmos", "::", "P3", ",", "Patmos", "::", "P4", ",", "Patmos", "::", "P5", ",", "Patmos", "::", "P6", ",", "Patmos", "::", "P7", ",", "0", "}", ";", "return", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "?", "CalleeSavedRegsFP", ":", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos::S0", "Patmos::SRB", "Patmos::SRO", "Patmos::R21", "Patmos::R22", "Patmos::R23", "Patmos::R24", "Patmos::R25", "Patmos::R26", "Patmos::R27", "Patmos::R28", "Patmos::P1", "Patmos::P2", "Patmos::P3", "Patmos::P4", "Patmos::P5", "Patmos::P6", "Patmos::P7", "0", "Patmos::S0", "Patmos::SRB", "Patmos::SRO", "Patmos::R21", "Patmos::R22", "Patmos::R23", "Patmos::R24", "Patmos::R25", "Patmos::R26", "Patmos::R27", "Patmos::R28", "Patmos::RFP", "Patmos::P1", "Patmos::P2", "Patmos::P3", "Patmos::P4", "Patmos::P5", "Patmos::P6", "Patmos::P7", "0" ]

[]

[ "<s>", "bool", "MipsLongBranch", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "const", "MipsInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "const", "MipsSubtarget", "&", "STI", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "inMips16Mode", "(", ")", "||", "!", "STI", ".", "enableLongBranchPass", "(", ")", ")", "return", "false", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isABI_O32", "(", ")", "&&", "F", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", "->", "globalBaseRegSet", "(", ")", ")", "emitGPDisp", "(", "F", ",", "TII", ")", ";", "if", "(", "SkipLongBranch", ")", "return", "true", ";", "MF", "=", "&", "F", ";", "initMBBInfo", "(", ")", ";", "SmallVectorImpl", "<", "MBBInfo", ">", "::", "iterator", "I", ",", "E", "=", "MBBInfos", ".", "end", "(", ")", ";", "bool", "EverMadeChange", "=", "false", ",", "MadeChange", "=", "true", ";", "while", "(", "MadeChange", ")", "{", "MadeChange", "=", "false", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "Br", "||", "I", "->", "HasLongBranch", ")", "continue", ";", "int", "ShVal", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMicroMipsMode", "(", ")", "?", "2", ":", "4", ";", "int64_t", "Offset", "=", "computeOffset", "(", "I", "->", "Br", ")", "/", "ShVal", ";", "if", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "Offset", "*=", "2", ";", "}", "if", "(", "!", "ForceLongBranch", "&&", "isInt", "<", "16", ">", "(", "Offset", ")", ")", "continue", ";", "I", "->", "HasLongBranch", "=", "true", ";", "I", "->", "Size", "+=", "LongBranchSeqSize", "*", "4", ";", "++", "LongBranches", ";", "EverMadeChange", "=", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "!", "EverMadeChange", ")", "return", "true", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "uint64_t", "Address", "=", "0", ";", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "Address", "+=", "I", "->", "Size", ",", "++", "I", ")", "I", "->", "Address", "=", "Address", ";", "}", "for", "(", "I", "=", "MBBInfos", ".", "begin", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "I", "->", "HasLongBranch", ")", "expandToLongBranch", "(", "*", "I", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "2", "4", "Mips", "2", "16", "4", "0" ]

[]

[ "<s>", "poly_int64", "ix86_push_rounding", "(", "poly_int64", "bytes", ")", "{", "return", "ROUND_UP", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "PUSH_ROUNDING", ".", "On", "386", ",", "we", "have", "pushw", "instruction", "that", "decrements", "by", "exactly", "2", "no", "matter", "what", "the", "position", "was", ",", "there", "is", "no", "pushb", ".", "But", "as", "CIE", "data", "alignment", "factor", "on", "this", "arch", "is", "-4", "for", "32bit", "targets", "and", "-8", "for", "64bit", "targets", ",", "we", "need", "to", "make", "sure", "all", "stack", "pointer", "adjustments", "are", "in", "multiple", "of", "4", "for", "32bit", "targets", "and", "8", "for", "64bit", "targets", "." ]

[ "i386" ]

[]

[ "<s>", "void", "emitFill", "(", "const", "MCExpr", "&", "NumBytes", ",", "uint64_t", "FillValue", ",", "SMLoc", "Loc", ")", "override", "{", "emitDataMappingSymbol", "(", ")", ";", "MCObjectStreamer", "::", "emitFill", "(", "NumBytes", ",", "FillValue", ",", "Loc", ")", ";", "}", "</s>" ]

[ "Emit", "Size", "bytes", "worth", "of", "the", "value", "specified", "by", "FillValue", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "PPCTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPCISD", "::", "LBRX", ":", "{", "if", "(", "cast", "<", "VTSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", "->", "getVT", "(", ")", "==", "MVT", "::", "i16", ")", "Known", ".", "Zero", "=", "0xFFFF0000", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "ppc_altivec_vcmpbfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpeqfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequb_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequd_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpequq_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgefp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtfp_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsb_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsd_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtsq_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtub_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuh_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuw_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtud_p", ":", "case", "Intrinsic", "::", "ppc_altivec_vcmpgtuq_p", ":", "Known", ".", "Zero", "=", "~", "1U", ";", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "PowerPC", "PPC", "PPCISD::LBRX", "2", "MVT::i16", "0xFFFF0000", "ISD::INTRINSIC_WO_CHAIN", "0", "Intrinsic::ppc_altivec_vcmpbfp_p", "Intrinsic::ppc_altivec_vcmpeqfp_p", "Intrinsic::ppc_altivec_vcmpequb_p", "Intrinsic::ppc_altivec_vcmpequh_p", "Intrinsic::ppc_altivec_vcmpequw_p", "Intrinsic::ppc_altivec_vcmpequd_p", "Intrinsic::ppc_altivec_vcmpequq_p", "Intrinsic::ppc_altivec_vcmpgefp_p", "Intrinsic::ppc_altivec_vcmpgtfp_p", "Intrinsic::ppc_altivec_vcmpgtsb_p", "Intrinsic::ppc_altivec_vcmpgtsh_p", "Intrinsic::ppc_altivec_vcmpgtsw_p", "Intrinsic::ppc_altivec_vcmpgtsd_p", "Intrinsic::ppc_altivec_vcmpgtsq_p", "Intrinsic::ppc_altivec_vcmpgtub_p", "Intrinsic::ppc_altivec_vcmpgtuh_p", "Intrinsic::ppc_altivec_vcmpgtuw_p", "Intrinsic::ppc_altivec_vcmpgtud_p", "Intrinsic::ppc_altivec_vcmpgtuq_p", "1U" ]

[]

[ "<s>", "static", "void", "emit_store_direct", "(", "rtx", "block", ",", "int", "offset", ",", "int", "value", ")", "{", "emit_insn", "(", "gen_store_direct", "(", "adjust_address", "(", "block", ",", "SImode", ",", "offset", ")", ",", "force_reg", "(", "SImode", ",", "gen_int_mode", "(", "value", ",", "SImode", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Directly", "store", "VALUE", "into", "memory", "object", "BLOCK", "at", "OFFSET", "." ]

[ "arc" ]

[]

[ "<s>", "static", "int", "comparator", "(", "const", "void", "*", "va", ",", "const", "void", "*", "vb", ")", "{", "const", "char", "*", "a", "=", "*", "(", "const", "char", "*", "const", "*", ")", "va", ";", "const", "char", "*", "b", "=", "*", "(", "const", "char", "*", "const", "*", ")", "vb", ";", "while", "(", "*", "a", "&&", "*", "b", ")", "{", "if", "(", "letter", "(", "*", "a", ")", "&&", "digit", "(", "*", "b", ")", ")", "return", "-", "1", ";", "if", "(", "digit", "(", "*", "a", ")", "&&", "letter", "(", "*", "b", ")", ")", "return", "1", ";", "if", "(", "*", "a", "!=", "*", "b", ")", "return", "*", "a", "-", "*", "b", ";", "a", "++", ";", "b", "++", ";", "}", "return", "*", "a", "-", "*", "b", ";", "}", "</s>" ]

[ "Compare", "two", "MCUs", "and", "order", "them", "for", "easy", "lookup", "." ]

[ "avr", "1", "1" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "SDValue", "Mask", ",", "MVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "return", "(", "Mask", ".", "getNode", "(", ")", "->", "getNumOperands", "(", ")", "<=", "4", "||", "isIdentityMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "isIdentityMask", "(", "Mask", ".", "getNode", "(", ")", ",", "true", ")", "||", "isSplatMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isPSHUFHWMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isPSHUFLWMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isUNPCKLMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isUNPCKHMask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isUNPCKL_v_undef_Mask", "(", "Mask", ".", "getNode", "(", ")", ")", "||", "X86", "::", "isUNPCKH_v_undef_Mask", "(", "Mask", ".", "getNode", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "64", "4", "X86::isPSHUFHWMask", "X86::isPSHUFLWMask", "X86::isUNPCKLMask", "X86::isUNPCKHMask", "X86::isUNPCKL_v_undef_Mask", "X86::isUNPCKH_v_undef_Mask" ]

[]

[ "<s>", "unsigned", "postOffset", "(", ")", "const", "{", "return", "Offset", "+", "Size", ";", "}", "</s>" ]

[ "Compute", "the", "offset", "immediately", "following", "this", "block", "." ]

[ "Mips" ]

[]

[ "<s>", "ARCTargetMachine", "::", "ARCTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ")", ",", "OL", ")", ",", "TLOF", "(", "make_unique", "<", "TargetLoweringObjectFileELF", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "ARCTargetMachine", "ctor", "-", "Create", "an", "ILP32", "architecture", "model", "." ]

[ "ARC", "ARC", "ARC", "\"e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-\"", "\"f32:32:32-i64:32-f64:32-a:0:32-n32\"" ]

[]

[ "<s>", "TargetIRAnalysis", "LanaiTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "LanaiTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnablePromoteConstant", ")", "addPass", "(", "createAArch64PromoteConstantPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64AddressTypePromotionPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandLoadLinkedPass", "(", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "arm_const_double_by_parts", "(", "rtx", "val", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "val", ")", ";", "rtx", "part", ";", "if", "(", "optimize_size", "||", "arm_ld_sched", ")", "return", "true", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "part", "=", "gen_highpart_mode", "(", "SImode", ",", "mode", ",", "val", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "part", ")", "==", "CONST_INT", ")", ";", "if", "(", "const_ok_for_arm", "(", "INTVAL", "(", "part", ")", ")", "||", "const_ok_for_arm", "(", "~", "INTVAL", "(", "part", ")", ")", ")", "return", "true", ";", "part", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "part", ")", "==", "CONST_INT", ")", ";", "if", "(", "const_ok_for_arm", "(", "INTVAL", "(", "part", ")", ")", "||", "const_ok_for_arm", "(", "~", "INTVAL", "(", "part", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "worthwhile", "to", "split", "a", "64-bit", "constant", "into", "two", "32-bit", "operations", ".", "This", "is", "the", "case", "if", "optimizing", "for", "size", ",", "or", "if", "we", "have", "load", "delay", "slots", ",", "or", "if", "one", "32-bit", "part", "can", "be", "done", "with", "a", "single", "data", "operation", "." ]

[ "arm" ]

[]

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

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

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

[]