Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "PatmosTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "CLI", ".", "IsTailCall", "=", "false", ";", "switch", "(", "CLI", ".", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "CLI", ",", "InVals", ")", ";", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "MCSymbol", "*", "MSP430MCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "MSP430", "MSP430", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "int", "includes_rshift_p", "(", "rtx", "shiftop", ",", "rtx", "andop", ")", "{", "unsigned", "HOST_WIDE_INT", "shift_mask", "=", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0", ";", "shift_mask", ">>=", "INTVAL", "(", "shiftop", ")", ";", "return", "(", "INTVAL", "(", "andop", ")", "&", "0xffffffff", "&", "~", "shift_mask", ")", "==", "0", ";", "}", "</s>" ]

[ "Similar", ",", "but", "for", "right", "shift", "." ]

[ "rs6000", "0", "0xffffffff", "0" ]

[]

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

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

[ "MBlaze", "\"MBlaze Assembly Printer\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"P2 DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "P2", "\"P2 DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "SNESFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "SNES", "SNES" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "ARM64", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "ARM64", "ARM64::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "JVMAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "int", "arc_compute_millicode_save_restore_regs", "(", "unsigned", "int", "gmask", ",", "struct", "arc_frame_info", "*", "frame", ")", "{", "int", "regno", ";", "int", "start_reg", "=", "13", ",", "end_reg", "=", "25", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1L", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "if", "(", "regno", "-", "start_reg", ">=", "3", "-", "(", "crtl", "->", "is_leaf", "==", "0", ")", ")", "{", "frame", "->", "millicode_start_reg", "=", "13", ";", "frame", "->", "millicode_end_reg", "=", "regno", "-", "1", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "there", "are", "registers", "to", "be", "saved", "or", "loaded", "using", "millicode", "thunks", ".", "We", "can", "only", "use", "consecutive", "sequences", "starting", "with", "r13", ",", "and", "not", "going", "beyond", "r25", ".", "GMASK", "is", "a", "bitmask", "of", "registers", "to", "save", ".", "This", "function", "sets", "FRAME-", ">", "millicod_start_reg", "..", "FRAME-", ">", "millicode_end_reg", "to", "the", "range", "of", "registers", "to", "be", "saved", "/", "restored", "with", "a", "millicode", "call", "." ]

[ "arc", "13", "25", "1L", "1", "3", "0", "13", "1", "1", "0" ]

[]

[ "<s>", "void", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "{", "if", "(", "tryInlineAsm", "(", "N", ")", ")", "return", ";", "break", ";", "}", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "ReplaceNode", "(", "N", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "CurDAG", "->", "getCopyToReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "SP", "::", "Y", ",", "TopPart", ",", "SDValue", "(", ")", ")", ".", "getValue", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "if", "(", "(", "(", "SparcTargetMachine", "&", ")", "TM", ")", ".", "getSubtargetImpl", "(", ")", "->", "performSDIVReplace", "(", ")", "&&", "Opcode", "==", "SP", "::", "SDIVrr", ")", "{", "Opcode", "=", "SP", "::", "SDIVCCrr", ";", "}", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "ISD::INLINEASM", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::Y", "1", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "Sparc", "SP::SDIVrr", "SP::SDIVCCrr", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "ix86_must_pass_in_stack", "(", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "must_pass_in_stack_var_size_or_pad", "(", "arg", ")", ")", "return", "true", ";", "return", "(", "!", "TARGET_64BIT", "&&", "arg", ".", "mode", "==", "TImode", "&&", "arg", ".", "type", "&&", "TREE_CODE", "(", "arg", ".", "type", ")", "!=", "VECTOR_TYPE", ")", ";", "}", "</s>" ]

[ "Return", "if", "we", "do", "not", "know", "how", "to", "pass", "TYPE", "solely", "in", "registers", "." ]

[ "i386" ]

[]

[ "<s>", "void", "split_di", "(", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "SImode", ",", "4", ")", ";", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "SImode", ",", "op", ",", "GET_MODE", "(", "op", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "op", ")", ",", "4", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "DImode", "RTL", "references", "into", "pairs", "of", "SImode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "DImode", "RTL", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

[ "i386", "0", "4", "0", "4" ]

[]

[ "<s>", "void", "emitAssignment", "(", "MCSymbol", "*", "Symbol", ",", "const", "MCExpr", "*", "Value", ")", "override", "{", "}", "</s>" ]

[ "Emit", "an", "assignment", "of", "Value", "to", "Symbol", "." ]

[ "Patmos" ]

[]

[ "<s>", "SDNode", "*", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ";", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"=> \"", ";", "if", "(", "ResNode", "==", "nullptr", "||", "ResNode", "==", "Node", ")", "Node", "->", "dump", "(", "CurDAG", ")", ";", "else", "ResNode", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"Selecting: \"", "\"== \"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr", "\"=> \"" ]

[]

[ "<s>", "void", "VLIWMachineScheduler", "::", "schedule", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Converging Scheduling VLIW \"", "<<", "printMBBReference", "(", "*", "BB", ")", "<<", "\" \"", "<<", "BB", "->", "getName", "(", ")", "<<", "\" in_func \"", "<<", "BB", "->", "getParent", "(", ")", "->", "getName", "(", ")", "<<", "\" at loop depth \"", "<<", "MLI", "->", "getLoopDepth", "(", "BB", ")", "<<", "\" \\n\"", ")", ";", "buildDAGWithRegPressure", "(", ")", ";", "Topo", ".", "InitDAGTopologicalSorting", "(", ")", ";", "postprocessDAG", "(", ")", ";", "SmallVector", "<", "SUnit", "*", ",", "8", ">", "TopRoots", ",", "BotRoots", ";", "findRootsAndBiasEdges", "(", "TopRoots", ",", "BotRoots", ")", ";", "SchedImpl", "->", "initialize", "(", "this", ")", ";", "DEBUG", "(", "unsigned", "maxH", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ">", "maxH", ")", "maxH", "=", "SUnits", "[", "su", "]", ".", "getHeight", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Height \"", "<<", "maxH", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "unsigned", "maxD", "=", "0", ";", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "if", "(", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ">", "maxD", ")", "maxD", "=", "SUnits", "[", "su", "]", ".", "getDepth", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Max Depth \"", "<<", "maxD", "<<", "\"\\n\"", ";", ")", ";", "DEBUG", "(", "for", "(", "unsigned", "su", "=", "0", ",", "e", "=", "SUnits", ".", "size", "(", ")", ";", "su", "!=", "e", ";", "++", "su", ")", "SUnits", "[", "su", "]", ".", "dumpAll", "(", "this", ")", ")", ";", "initQueues", "(", "TopRoots", ",", "BotRoots", ")", ";", "bool", "IsTopNode", "=", "false", ";", "while", "(", "true", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", ")", ";", "SUnit", "*", "SU", "=", "SchedImpl", "->", "pickNode", "(", "IsTopNode", ")", ";", "if", "(", "!", "SU", ")", "break", ";", "if", "(", "!", "checkSchedLimit", "(", ")", ")", "break", ";", "scheduleMI", "(", "SU", ",", "IsTopNode", ")", ";", "SchedImpl", "->", "schedNode", "(", "SU", ",", "IsTopNode", ")", ";", "updateQueues", "(", "SU", ",", "IsTopNode", ")", ";", "}", "assert", "(", "CurrentTop", "==", "CurrentBottom", "&&", "\"Nonempty unscheduled zone.\"", ")", ";", "placeDebugValues", "(", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"*** Final schedule for \"", "<<", "printMBBReference", "(", "*", "begin", "(", ")", "->", "getParent", "(", ")", ")", "<<", "\" ***\\n\"", ";", "dumpSchedule", "(", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Schedule", "-", "This", "is", "called", "back", "from", "ScheduleDAGInstrs", ":", ":Run", "(", ")", "when", "it", "'s", "time", "to", "do", "some", "work", "." ]

[ "Hexagon", "\"********** MI Converging Scheduling VLIW \"", "\" \"", "\" in_func \"", "\" at loop depth \"", "\" \\n\"", "8", "0", "0", "\"Max Height \"", "\"\\n\"", "0", "0", "\"Max Depth \"", "\"\\n\"", "0", "\"** VLIWMachineScheduler::schedule picking next node\\n\"", "\"Nonempty unscheduled zone.\"", "\"*** Final schedule for \"", "\" ***\\n\"" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MachineLocation", "DstML", ",", "SrcML", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "CSI", ".", "size", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", "->", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "::", "const_iterator", "I", "=", "CSI", ".", "begin", "(", ")", ",", "E", "=", "CSI", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "int64_t", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "I", "->", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", "->", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MMI", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "FunctionPass", "*", "WebAssemblyPassConfig", "::", "createTargetRegisterAllocator", "(", "bool", ")", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "createTargetRegisterAllocator", "-", "Create", "the", "register", "allocator", "pass", "for", "this", "target", "at", "the", "current", "optimization", "level", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "hasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "make_early_inc_range", "(", "Entry", ")", ")", "{", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF", "WebAssembly::isArgument" ]

[]

[ "<s>", "int", "h8300_tiny_constant_address_p", "(", "rtx", "x", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "h1", "=", "trunc_int_for_mode", "(", "0x00000000", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "h2", "=", "trunc_int_for_mode", "(", "0x00007fff", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "h3", "=", "trunc_int_for_mode", "(", "0x00ff8000", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "h4", "=", "trunc_int_for_mode", "(", "0x00ffffff", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s1", "=", "trunc_int_for_mode", "(", "0x00000000", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s2", "=", "trunc_int_for_mode", "(", "0x00007fff", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s3", "=", "trunc_int_for_mode", "(", "0xffff8000", ",", "SImode", ")", ";", "const", "unsigned", "HOST_WIDE_INT", "s4", "=", "trunc_int_for_mode", "(", "0xffffffff", ",", "SImode", ")", ";", "unsigned", "HOST_WIDE_INT", "addr", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "return", "(", "TARGET_NORMAL_MODE", "||", "(", "SYMBOL_REF_FLAGS", "(", "x", ")", "&", "SYMBOL_FLAG_TINY_DATA", ")", "!=", "0", ")", ";", "case", "CONST_INT", ":", "addr", "=", "INTVAL", "(", "x", ")", ";", "return", "(", "TARGET_NORMAL_MODE", "||", "(", "TARGET_H8300H", "&&", "(", "IN_RANGE", "(", "addr", ",", "h1", ",", "h2", ")", "||", "IN_RANGE", "(", "addr", ",", "h3", ",", "h4", ")", ")", ")", "||", "(", "TARGET_H8300S", "&&", "(", "IN_RANGE", "(", "addr", ",", "s1", ",", "s2", ")", "||", "IN_RANGE", "(", "addr", ",", "s3", ",", "s4", ")", ")", ")", ")", ";", "case", "CONST", ":", "return", "TARGET_NORMAL_MODE", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Nonzero", "if", "X", "is", "a", "constant", "address", "suitable", "as", "an", "16-bit", "absolute", "on", "H8/300H", "and", "H8S", "." ]

[ "h8300", "0x00000000", "0x00007fff", "0x00ff8000", "0x00ffffff", "0x00000000", "0x00007fff", "0xffff8000", "0xffffffff", "0", "0" ]

[]

[ "<s>", "bool", "AVRAsmParser", "::", "ParseDirective", "(", "llvm", "::", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".long\"", ")", "{", "parseLiteralValues", "(", "SIZE_LONG", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".word\"", "||", "IDVal", ".", "lower", "(", ")", "==", "\".short\"", ")", "{", "parseLiteralValues", "(", "SIZE_WORD", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "else", "if", "(", "IDVal", ".", "lower", "(", ")", "==", "\".byte\"", ")", "{", "parseLiteralValues", "(", "1", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "\".long\"", "\".word\"", "\".short\"", "\".byte\"", "1" ]

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "BitSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "Size", "=", "(", "BitSize", "+", "7", ")", "/", "8", ";", "assert", "(", "Offset", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "Value", "=", "extractBitsForFixup", "(", "Kind", ",", "Value", ",", "Fixup", ",", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "BitSize", "<", "64", ")", "Value", "&=", "(", "(", "uint64_t", ")", "1", "<<", "BitSize", ")", "-", "1", ";", "unsigned", "ShiftValue", "=", "(", "Size", "*", "8", ")", "-", "8", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "!=", "Size", ";", "++", "I", ")", "{", "Data", "[", "Offset", "+", "I", "]", "|=", "uint8_t", "(", "Value", ">>", "ShiftValue", ")", ";", "ShiftValue", "-=", "8", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "7", "8", "\"Invalid fixup offset!\"", "64", "1", "1", "8", "8", "0", "8" ]

[]

[ "<s>", "static", "void", "tilegx_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "byte_size", "=", "(", "(", "mode", "==", "BLKmode", ")", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "int", "word_size", "=", "(", "byte_size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "bool", "doubleword_aligned_p", ";", "doubleword_aligned_p", "=", "tilegx_function_arg_boundary", "(", "mode", ",", "type", ")", ">", "BITS_PER_WORD", ";", "if", "(", "doubleword_aligned_p", ")", "*", "cum", "+=", "*", "cum", "&", "1", ";", "if", "(", "*", "cum", "<", "TILEGX_NUM_ARG_REGS", "&&", "*", "cum", "+", "word_size", ">", "TILEGX_NUM_ARG_REGS", ")", "*", "cum", "=", "TILEGX_NUM_ARG_REGS", ";", "*", "cum", "+=", "word_size", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "tilegx", "1", "1" ]

[]

[ "<s>", "SDValue", "SPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "(", "unsigned", ")", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "{", "errs", "(", ")", "<<", "\"SPUTargetLowering::LowerOperation(): need to lower this!\\n\"", ";", "errs", "(", ")", "<<", "\"Op.getOpcode() = \"", "<<", "Opc", "<<", "\"\\n\"", ";", "errs", "(", ")", "<<", "\"*Op.getNode():\\n\"", ";", "Op", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "EXTLOAD", ":", "case", "ISD", "::", "SEXTLOAD", ":", "case", "ISD", "::", "ZEXTLOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ",", "SPUTM", ".", "getSubtargetImpl", "(", ")", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "LowerConstantFP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "ROTR", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "{", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "LowerI8Math", "(", "Op", ",", "DAG", ",", "Opc", ",", "*", "this", ")", ";", "break", ";", "}", "case", "ISD", "::", "FP_TO_SINT", ":", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "LowerByteImmed", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "LowerI8Math", "(", "Op", ",", "DAG", ",", "Opc", ",", "*", "this", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "LowerTRUNCATE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "\"SPUTargetLowering::LowerOperation(): need to lower this!\\n\"", "\"Op.getOpcode() = \"", "\"\\n\"", "\"*Op.getNode():\\n\"", "0", "ISD::LOAD", "ISD::EXTLOAD", "ISD::SEXTLOAD", "ISD::ZEXTLOAD", "SPU", "ISD::STORE", "SPU", "ISD::ConstantPool", "SPU", "ISD::GlobalAddress", "SPU", "ISD::JumpTable", "SPU", "ISD::ConstantFP", "ISD::ADD", "ISD::SUB", "ISD::ROTR", "ISD::ROTL", "ISD::SRL", "ISD::SHL", "ISD::SRA", "MVT::i8", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::BUILD_VECTOR", "ISD::SCALAR_TO_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::AND", "ISD::OR", "ISD::XOR", "ISD::MUL", "MVT::i8", "ISD::CTPOP", "ISD::SELECT_CC", "ISD::SETCC", "ISD::TRUNCATE", "ISD::SIGN_EXTEND" ]

[]

[ "<s>", "static", "void", "nvptx_goacc_reduction_init", "(", "gcall", "*", "call", ",", "offload_attrs", "*", "oa", ")", "{", "gimple_stmt_iterator", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "call", ")", ";", "tree", "var", "=", "gimple_call_arg", "(", "call", ",", "2", ")", ";", "int", "level", "=", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "3", ")", ")", ";", "enum", "tree_code", "rcode", "=", "(", "enum", "tree_code", ")", "TREE_INT_CST_LOW", "(", "gimple_call_arg", "(", "call", ",", "4", ")", ")", ";", "tree", "init", "=", "omp_reduction_init_op", "(", "gimple_location", "(", "call", ")", ",", "rcode", ",", "TREE_TYPE", "(", "var", ")", ")", ";", "gimple_seq", "seq", "=", "NULL", ";", "push_gimplify_context", "(", "true", ")", ";", "if", "(", "level", "==", "GOMP_DIM_VECTOR", "&&", "oa", "->", "vector_length", "==", "PTX_WARP_SIZE", ")", "{", "tree", "tid", "=", "make_ssa_name", "(", "integer_type_node", ")", ";", "tree", "dim_vector", "=", "gimple_call_arg", "(", "call", ",", "3", ")", ";", "gimple", "*", "tid_call", "=", "gimple_build_call_internal", "(", "IFN_GOACC_DIM_POS", ",", "1", ",", "dim_vector", ")", ";", "gimple", "*", "cond_stmt", "=", "gimple_build_cond", "(", "NE_EXPR", ",", "tid", ",", "integer_zero_node", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "gimple_call_set_lhs", "(", "tid_call", ",", "tid", ")", ";", "gimple_seq_add_stmt", "(", "&", "seq", ",", "tid_call", ")", ";", "gimple_seq_add_stmt", "(", "&", "seq", ",", "cond_stmt", ")", ";", "edge", "init_edge", "=", "split_block", "(", "gsi_bb", "(", "gsi", ")", ",", "call", ")", ";", "basic_block", "init_bb", "=", "init_edge", "->", "dest", ";", "basic_block", "call_bb", "=", "init_edge", "->", "src", ";", "init_edge", "->", "flags", "^=", "EDGE_FALLTHRU", "|", "EDGE_TRUE_VALUE", ";", "init_edge", "->", "probability", "=", "profile_probability", "::", "even", "(", ")", ";", "gimple_seq", "init_seq", "=", "NULL", ";", "tree", "init_var", "=", "make_ssa_name", "(", "TREE_TYPE", "(", "var", ")", ")", ";", "gimplify_assign", "(", "init_var", ",", "init", ",", "&", "init_seq", ")", ";", "gsi", "=", "gsi_start_bb", "(", "init_bb", ")", ";", "gsi_insert_seq_before", "(", "&", "gsi", ",", "init_seq", ",", "GSI_SAME_STMT", ")", ";", "gsi_prev", "(", "&", "gsi", ")", ";", "edge", "inited_edge", "=", "split_block", "(", "gsi_bb", "(", "gsi", ")", ",", "gsi_stmt", "(", "gsi", ")", ")", ";", "basic_block", "dst_bb", "=", "inited_edge", "->", "dest", ";", "edge", "nop_edge", "=", "make_edge", "(", "call_bb", ",", "dst_bb", ",", "EDGE_FALSE_VALUE", ")", ";", "nop_edge", "->", "probability", "=", "profile_probability", "::", "even", "(", ")", ";", "gphi", "*", "phi", "=", "create_phi_node", "(", "lhs", ",", "dst_bb", ")", ";", "add_phi_arg", "(", "phi", ",", "init_var", ",", "inited_edge", ",", "gimple_location", "(", "call", ")", ")", ";", "add_phi_arg", "(", "phi", ",", "var", ",", "nop_edge", ",", "gimple_location", "(", "call", ")", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "dst_bb", ",", "call_bb", ")", ";", "gsi", "=", "gsi_for_stmt", "(", "call", ")", ";", "}", "else", "{", "if", "(", "level", "==", "GOMP_DIM_GANG", ")", "{", "tree", "ref_to_res", "=", "gimple_call_arg", "(", "call", ",", "1", ")", ";", "if", "(", "integer_zerop", "(", "ref_to_res", ")", ")", "init", "=", "var", ";", "}", "if", "(", "lhs", "!=", "NULL_TREE", ")", "gimplify_assign", "(", "lhs", ",", "init", ",", "&", "seq", ")", ";", "}", "pop_gimplify_context", "(", "NULL", ")", ";", "gsi_replace_with_seq", "(", "&", "gsi", ",", "seq", ",", "true", ")", ";", "}", "</s>" ]

[ "NVPTX", "implementation", "of", "GOACC_REDUCTION_INIT", "." ]

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

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "AArch64" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Op", ",", "DAGCombinerInfo", "&", "DCI", ",", "unsigned", "&", "RefinementSteps", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "const", "char", "*", "RecipOp", ";", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "Subtarget", "->", "hasSSE1", "(", ")", ")", "RecipOp", "=", "\"divf\"", ";", "else", "if", "(", "(", "VT", "==", "MVT", "::", "v4f32", "&&", "Subtarget", "->", "hasSSE1", "(", ")", ")", "||", "(", "VT", "==", "MVT", "::", "v8f32", "&&", "Subtarget", "->", "hasAVX", "(", ")", ")", ")", "RecipOp", "=", "\"vec-divf\"", ";", "else", "return", "SDValue", "(", ")", ";", "TargetRecip", "Recips", "=", "DCI", ".", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "Reciprocals", ";", "if", "(", "!", "Recips", ".", "isEnabled", "(", "RecipOp", ")", ")", "return", "SDValue", "(", ")", ";", "RefinementSteps", "=", "Recips", ".", "getRefinementSteps", "(", "RecipOp", ")", ";", "return", "DCI", ".", "DAG", ".", "getNode", "(", "X86ISD", "::", "FRCP", ",", "SDLoc", "(", "Op", ")", ",", "VT", ",", "Op", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "X86", "X86", "MVT::f32", "\"divf\"", "MVT::v4f32", "MVT::v8f32", "\"vec-divf\"", "X86ISD::FRCP" ]

[]

[ "<s>", "const", "RegClassWeight", "&", "R600RegisterInfo", "::", "getRegClassWeight", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "RCW", ";", "}", "</s>" ]

[ "Get", "the", "weight", "in", "units", "of", "pressure", "for", "this", "register", "class", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "int", "m32c_limit_reload_class", "(", "enum", "machine_mode", "mode", ",", "int", "rclass", ")", "{", "fprintf", "(", "stderr", ",", "\"limit_reload_class for %s: %s ->\"", ",", "mode_name", "[", "mode", "]", ",", "class_names", "[", "rclass", "]", ")", ";", "if", "(", "mode", "==", "QImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "HL_REGS", ",", "rclass", ")", ";", "else", "if", "(", "mode", "==", "HImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "HI_REGS", ",", "rclass", ")", ";", "else", "if", "(", "mode", "==", "SImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "SI_REGS", ",", "rclass", ")", ";", "if", "(", "rclass", "!=", "A_REGS", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "DI_REGS", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\" %s\\n\"", ",", "class_names", "[", "rclass", "]", ")", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implements", "LIMIT_RELOAD_CLASS", ".", "We", "basically", "want", "to", "avoid", "using", "address", "registers", "for", "reloads", "since", "they", "'re", "needed", "for", "address", "reloads", "." ]

[ "m32c", "\"limit_reload_class for %s: %s ->\"", "\" %s\\n\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "using", "namespace", "llvm", "::", "PatternMatch", ";", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", "||", "!", "Subtarget", ".", "hasStdExtV", "(", ")", ")", "return", "false", ";", "auto", "IsSinker", "=", "[", "&", "]", "(", "Instruction", "*", "I", ",", "int", "Operand", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "FAdd", ":", "case", "Instruction", "::", "FSub", ":", "case", "Instruction", "::", "FMul", ":", "case", "Instruction", "::", "FDiv", ":", "return", "true", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "Operand", "==", "1", ";", "case", "Instruction", "::", "Call", ":", "if", "(", "auto", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "I", ")", ")", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "fma", ":", "return", "Operand", "==", "0", "||", "Operand", "==", "1", ";", "default", ":", "return", "false", ";", "}", "}", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", ";", "for", "(", "auto", "OpIdx", ":", "enumerate", "(", "I", "->", "operands", "(", ")", ")", ")", "{", "if", "(", "!", "IsSinker", "(", "I", ",", "OpIdx", ".", "index", "(", ")", ")", ")", "continue", ";", "Instruction", "*", "Op", "=", "dyn_cast", "<", "Instruction", ">", "(", "OpIdx", ".", "value", "(", ")", ".", "get", "(", ")", ")", ";", "if", "(", "!", "Op", "||", "any_of", "(", "Ops", ",", "[", "&", "]", "(", "Use", "*", "U", ")", "{", "return", "U", "->", "get", "(", ")", "==", "Op", ";", "}", ")", ")", "continue", ";", "if", "(", "!", "match", "(", "Op", ",", "m_Shuffle", "(", "m_InsertElt", "(", "m_Undef", "(", ")", ",", "m_Value", "(", ")", ",", "m_ZeroInt", "(", ")", ")", ",", "m_Undef", "(", ")", ",", "m_ZeroMask", "(", ")", ")", ")", ")", "continue", ";", "for", "(", "Use", "&", "U", ":", "Op", "->", "uses", "(", ")", ")", "{", "Instruction", "*", "Insn", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "if", "(", "!", "IsSinker", "(", "Insn", ",", "U", ".", "getOperandNo", "(", ")", ")", ")", "return", "false", ";", "}", "Ops", ".", "push_back", "(", "&", "Op", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "OpIdx", ".", "value", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

[ "RISCV", "RISCV", "1", "Intrinsic::fma", "0", "1", "0" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR32RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR32RegClass", ")", "Opc", "=", "SystemZ", "::", "MOV32mr", ";", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64RegClass", "||", "RC", "==", "&", "SystemZ", "::", "ADDR64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP32RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV32mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "FP64RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "FMOV64mr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR64PRegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV64Pmr", ";", "}", "else", "if", "(", "RC", "==", "&", "SystemZ", "::", "GR128RegClass", ")", "{", "Opc", "=", "SystemZ", "::", "MOV128mr", ";", "}", "else", "llvm_unreachable", "(", "\"Unsupported regclass to store\"", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "SystemZ::GR32RegClass", "SystemZ::ADDR32RegClass", "SystemZ::MOV32mr", "SystemZ::GR64RegClass", "SystemZ::ADDR64RegClass", "SystemZ::MOV64mr", "SystemZ::FP32RegClass", "SystemZ::FMOV32mr", "SystemZ::FP64RegClass", "SystemZ::FMOV64mr", "SystemZ::GR64PRegClass", "SystemZ::MOV64Pmr", "SystemZ::GR128RegClass", "SystemZ::MOV128mr", "\"Unsupported regclass to store\"" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_custom_builtin", "(", "tree", "exp", ",", "unsigned", "int", "index", ",", "rtx", "target", ")", "{", "bool", "has_target_p", "=", "(", "TREE_TYPE", "(", "exp", ")", "!=", "void_type_node", ")", ";", "machine_mode", "tmode", "=", "VOIDmode", ";", "int", "nargs", ",", "argno", ";", "rtx", "value", ",", "insn", ",", "unspec_args", "[", "3", "]", ";", "tree", "arg", ";", "if", "(", "has_target_p", ")", "{", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "REG_P", "(", "target", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "nargs", "=", "call_expr_nargs", "(", "exp", ")", ";", "for", "(", "argno", "=", "0", ";", "argno", "<", "nargs", ";", "argno", "++", ")", "{", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "argno", ")", ";", "value", "=", "expand_normal", "(", "arg", ")", ";", "unspec_args", "[", "argno", "]", "=", "value", ";", "if", "(", "argno", "==", "0", ")", "{", "if", "(", "!", "custom_insn_opcode", "(", "value", ",", "VOIDmode", ")", ")", "error", "(", "\"custom instruction opcode must be compile time \"", "\"constant in the range 0-255 for __builtin_custom_%s\"", ",", "custom_builtin_name", "[", "index", "]", ")", ";", "}", "else", "unspec_args", "[", "argno", "]", "=", "force_reg", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg", ")", ")", ",", "unspec_args", "[", "argno", "]", ")", ";", "}", "for", "(", ";", "argno", "<", "3", ";", "argno", "++", ")", "unspec_args", "[", "argno", "]", "=", "const0_rtx", ";", "insn", "=", "(", "has_target_p", "?", "gen_rtx_SET", "(", "target", ",", "gen_rtx_UNSPEC_VOLATILE", "(", "tmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_XNXX", ")", ")", ":", "gen_rtx_UNSPEC_VOLATILE", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "3", ",", "unspec_args", ")", ",", "UNSPECV_CUSTOM_NXX", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "has_target_p", "?", "target", ":", "const0_rtx", ";", "}", "</s>" ]

[ "Helper", "function", "for", "expanding", "custom", "builtins", "." ]

[ "nios2", "3", "0", "0", "\"custom instruction opcode must be compile time \"", "\"constant in the range 0-255 for __builtin_custom_%s\"", "3", "3", "3" ]

[]

[ "<s>", "bool", "LM32RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "\"no-realign-stack\"", ")", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "LM32", "LM32", "\"no-realign-stack\"" ]

[]

[ "<s>", "static", "bool", "expand_vec_perm_even_odd", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "i", ",", "odd", ",", "nelt", "=", "d", "->", "nelt", ";", "odd", "=", "d", "->", "perm", "[", "0", "]", ";", "if", "(", "odd", "!=", "0", "&&", "odd", "!=", "1", ")", "return", "false", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nelt", ";", "++", "i", ")", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "2", "*", "i", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "vmode", "==", "E_V32HImode", "&&", "d", "->", "testing_p", "&&", "!", "TARGET_AVX512BW", ")", "return", "false", ";", "return", "expand_vec_perm_even_odd_1", "(", "d", ",", "odd", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_vec_perm_builtin_1", ".", "Pattern", "match", "extract-even", "and", "extract-odd", "permutations", "." ]

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

[]

[ "<s>", "void", "ARMAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "RelaxedOp", "=", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ",", "STI", ")", ";", "if", "(", "RelaxedOp", "==", "Inst", ".", "getOpcode", "(", ")", ")", "{", "SmallString", "<", "256", ">", "Tmp", ";", "raw_svector_ostream", "OS", "(", "Tmp", ")", ";", "Inst", ".", "dump_pretty", "(", "OS", ")", ";", "OS", "<<", "\"\\n\"", ";", "report_fatal_error", "(", "\"unexpected instruction to relax: \"", "+", "OS", ".", "str", "(", ")", ")", ";", "}", "if", "(", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBZ", "||", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tCBNZ", ")", "&&", "RelaxedOp", "==", "ARM", "::", "tHINT", ")", "{", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "14", ")", ")", ";", "Res", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "0", ")", ")", ";", "return", ";", "}", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "RelaxedOp", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "256", "\"\\n\"", "\"unexpected instruction to relax: \"", "ARM::tCBZ", "ARM::tCBNZ", "ARM::tHINT", "0", "14", "0" ]

[]

[ "<s>", "rtx", "arm_gen_compare_reg", "(", "enum", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "enum", "machine_mode", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "rtx", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "X", "and", "Y", "are", "two", "things", "to", "compare", "using", "CODE", ".", "Emit", "the", "compare", "insn", "and", "return", "the", "rtx", "for", "register", "0", "in", "the", "proper", "mode", ".", "FP", "means", "this", "is", "a", "floating", "point", "compare", ":", "I", "do", "n't", "think", "that", "it", "is", "needed", "on", "the", "arm", "." ]

[ "arm" ]

[]

[ "<s>", "InstructionCost", "getIntImmCostInst", "(", "unsigned", "Opc", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", "=", "nullptr", ")", "{", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "Lanai" ]

[]

[ "<s>", "static", "tree", "xtensa_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_stk", ",", "f_reg", ",", "f_ndx", ",", "record", ",", "type_decl", ";", "record", "=", "(", "*", "lang_hooks", ".", "types", ".", "make_type", ")", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_stk", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_stk\"", ")", ",", "ptr_type_node", ")", ";", "f_reg", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_reg\"", ")", ",", "ptr_type_node", ")", ";", "f_ndx", "=", "build_decl", "(", "FIELD_DECL", ",", "get_identifier", "(", "\"__va_ndx\"", ")", ",", "integer_type_node", ")", ";", "DECL_FIELD_CONTEXT", "(", "f_stk", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_reg", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ndx", ")", "=", "record", ";", "TREE_CHAIN", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_stk", ";", "TREE_CHAIN", "(", "f_stk", ")", "=", "f_reg", ";", "TREE_CHAIN", "(", "f_reg", ")", "=", "f_ndx", ";", "layout_type", "(", "record", ")", ";", "return", "record", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", ".", "This", "structure", "is", "set", "up", "by", "__builtin_saveregs", ".", "The", "__va_reg", "field", "points", "to", "a", "stack-allocated", "region", "holding", "the", "contents", "of", "the", "incoming", "argument", "registers", ".", "The", "__va_ndx", "field", "is", "an", "index", "initialized", "to", "the", "position", "of", "the", "first", "unnamed", "(", "variable", ")", "argument", ".", "This", "same", "index", "is", "also", "used", "to", "address", "the", "arguments", "passed", "in", "memory", ".", "Thus", ",", "the", "__va_stk", "field", "is", "initialized", "to", "point", "to", "the", "position", "of", "the", "first", "argument", "in", "memory", "offset", "to", "account", "for", "the", "arguments", "passed", "in", "registers", "and", "to", "account", "for", "the", "size", "of", "the", "argument", "registers", "not", "being", "16-byte", "aligned", ".", "E.G.", ",", "there", "are", "6", "argument", "registers", "of", "4", "bytes", "each", ",", "but", "we", "want", "the", "__va_ndx", "for", "the", "first", "stack", "argument", "to", "have", "the", "maximal", "alignment", "of", "16", "bytes", ",", "so", "we", "offset", "the", "__va_stk", "address", "by", "32", "bytes", "so", "that", "__va_stk", "[", "32", "]", "references", "the", "first", "argument", "on", "the", "stack", "." ]

[ "xtensa", "\"__va_list_tag\"", "\"__va_stk\"", "\"__va_reg\"", "\"__va_ndx\"" ]

[]

[ "<s>", "static", "void", "frv_split_iacc_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "enum", "machine_mode", "inner", ";", "int", "i", ";", "inner", "=", "GET_MODE", "(", "dest", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "GET_MODE_SIZE", "(", "inner", ")", ";", "i", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "emit_move_insn", "(", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "inner", ",", "i", ")", ",", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "inner", ",", "i", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "from", "SRC", "to", "DEST", "in", "SImode", "chunks", ".", "This", "can", "be", "used", "to", "move", "DImode", "values", "into", "and", "out", "of", "IACC0", "." ]

[ "frv", "0" ]

[]

[ "<s>", "static", "tree", "aarch64_simd_builtin_type", "(", "machine_mode", "mode", ",", "bool", "unsigned_p", ",", "bool", "poly_p", ")", "{", "if", "(", "poly_p", ")", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_poly", ")", ";", "else", "if", "(", "unsigned_p", ")", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_unsigned", ")", ";", "else", "return", "aarch64_lookup_simd_builtin_type", "(", "mode", ",", "qualifier_none", ")", ";", "}", "</s>" ]

[ "Return", "a", "type", "for", "an", "operand", "with", "specified", "mode", "and", "qualifiers", "." ]

[ "aarch64" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Nullify DBG_VALUE_LISTs\"" ]

[]

[ "<s>", "void", "LC2200InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200" ]

[]

[ "<s>", "void", "SPUHazardRecognizer", "::", "EmitNoop", "(", ")", "{", "AdvanceCycle", "(", ")", ";", "}", "</s>" ]

[ "EmitNoop", "-", "This", "callback", "is", "invoked", "when", "a", "noop", "was", "added", "to", "the", "instruction", "stream", "." ]

[ "CellSPU", "SPU" ]

[]

[ "<s>", "void", "CustomListScheduler", "::", "StartBlock", "(", "MachineBasicBlock", "*", "BB", ")", "{", "TheBase", "::", "StartBlock", "(", "BB", ")", ";", "HazardRec", "->", "Reset", "(", ")", ";", "if", "(", "AntiDepBreak", "!=", "NULL", ")", "AntiDepBreak", "->", "StartBlock", "(", "BB", ")", ";", "}", "</s>" ]

[ "Initialize", "anti-dep", "breaking", "for", "a", "new", "basic", "block", "." ]

[ "TMS320C64X" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "bool", "arm_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "unsigned", "long", "func_type", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_blocked", ")", "return", "false", ";", "if", "(", "TARGET_THUMB1", ")", "return", "false", ";", "if", "(", "TARGET_VXWORKS_RTP", "&&", "flag_pic", "&&", "!", "targetm", ".", "binds_local_p", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TARGET_INTERWORK", "&&", "decl", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", ")", "return", "false", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "return", "false", ";", "if", "(", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", "{", "rtx", "a", ",", "b", ";", "a", "=", "arm_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "decl", ",", "false", ")", ";", "b", "=", "arm_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "if", "(", "IS_STACKALIGN", "(", "func_type", ")", ")", "return", "false", ";", "if", "(", "TARGET_AAPCS_BASED", "&&", "arm_abi", "==", "ARM_ABI_AAPCS", "&&", "decl", "&&", "DECL_WEAK", "(", "decl", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "." ]

[ "arm" ]

[]

[ "<s>", "rtx", "mmix_function_outgoing_value", "(", "tree", "valtype", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "enum", "machine_mode", "cmode", ";", "int", "first_val_regnum", "=", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ";", "rtx", "vec", "[", "MMIX_MAX_REGS_FOR_VALUE", "]", ";", "int", "i", ";", "int", "nregs", ";", "if", "(", "TARGET_ABI_GNU", "||", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "BITS_PER_WORD", ")", "return", "gen_rtx_REG", "(", "mode", ",", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "cmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "valtype", ")", ")", ";", "else", "{", "if", "(", "mode", "!=", "TImode", ")", "sorry", "(", "\"support for mode %qs\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "cmode", "=", "DImode", ";", "}", "nregs", "=", "(", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "+", "BITS_PER_WORD", "-", "1", ")", "/", "BITS_PER_WORD", ")", ";", "if", "(", "nregs", ">", "MMIX_MAX_REGS_FOR_VALUE", ")", "internal_error", "(", "\"too large function value type, needs %d registers,\\ have only %d registers for this\"", ",", "nregs", ",", "MMIX_MAX_REGS_FOR_VALUE", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", "-", "1", ";", "i", "++", ")", "vec", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "first_val_regnum", "+", "i", ")", ",", "GEN_INT", "(", "(", "i", "+", "1", ")", "*", "BITS_PER_UNIT", ")", ")", ";", "vec", "[", "nregs", "-", "1", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "first_val_regnum", "+", "nregs", "-", "1", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec_v", "(", "nregs", ",", "vec", ")", ")", ";", "}", "</s>" ]

[ "FUNCTION_OUTGOING_VALUE", "." ]

[ "mmix", "\"support for mode %qs\"", "1", "\"too large function value type, needs %d registers,\\ have only %d registers for this\"", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "output_probe_stack_range", "(", "rtx", "reg1", ",", "rtx", "reg2", ")", "{", "static", "int", "labelno", "=", "0", ";", "char", "loop_lab", "[", "32", "]", ",", "end_lab", "[", "32", "]", ";", "rtx", "xops", "[", "3", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "loop_lab", ",", "\"LPSRL\"", ",", "labelno", ")", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "end_lab", ",", "\"LPSRE\"", ",", "labelno", "++", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "loop_lab", ")", ";", "xops", "[", "0", "]", "=", "reg1", ";", "xops", "[", "1", "]", "=", "reg2", ";", "xops", "[", "2", "]", "=", "gen_rtx_REG", "(", "BImode", ",", "PR_REG", "(", "6", ")", ")", ";", "output_asm_insn", "(", "\"cmp.eq %2, %I2 = %0, %1\"", ",", "xops", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t(%s) br.cond.dpnt \"", ",", "reg_names", "[", "REGNO", "(", "xops", "[", "2", "]", ")", "]", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "end_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "xops", "[", "1", "]", "=", "GEN_INT", "(", "-", "PROBE_INTERVAL", ")", ";", "output_asm_insn", "(", "\"addl %0 = %1, %0\"", ",", "xops", ")", ";", "fputs", "(", "\"\\t;;\\n\"", ",", "asm_out_file", ")", ";", "output_asm_insn", "(", "\"probe.w.fault %0, 0\"", ",", "xops", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\tbr \"", ")", ";", "assemble_name_raw", "(", "asm_out_file", ",", "loop_lab", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "end_lab", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Wrapper", "around", "the", "output_probe_stack_range", "routines", "." ]

[ "ia64", "0", "32", "32", "3", "\"LPSRL\"", "\"LPSRE\"", "0", "1", "2", "6", "\"cmp.eq %2, %I2 = %0, %1\"", "\"\\t(%s) br.cond.dpnt \"", "2", "1", "\"addl %0 = %1, %0\"", "\"\\t;;\\n\"", "\"probe.w.fault %0, 0\"", "\"\\tbr \"", "\"\"" ]

[]

[ "<s>", "DecodeStatus", "AAPDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "2", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "{", "Size", "=", "0", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "Insn", "=", "(", "Bytes", "[", "3", "]", "<<", "24", ")", "|", "(", "Bytes", "[", "2", "]", "<<", "16", ")", "|", "(", "Bytes", "[", "1", "]", "<<", "8", ")", "|", "(", "Bytes", "[", "0", "]", "<<", "0", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "Size", "=", "2", ";", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "AAP", "AAP", "2", "0", "1", "8", "0", "0", "2", "4", "0", "3", "24", "2", "16", "1", "8", "0", "0", "4", "2" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSIWithSVE", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "CSI", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSIWithSVE", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MFI", "->", "getStackRegionToHandleCSR", "(", "CSIWithSVE", "[", "i", "]", ".", "getReg", "(", ")", ")", "!=", "nullptr", ")", "continue", ";", "CSI", ".", "push_back", "(", "CSIWithSVE", "[", "i", "]", ")", ";", "}", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "rbegin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "rend", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "StrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPXi", ":", "AArch64", "::", "STRXui", ";", "else", "StrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "STPDi", ":", "AArch64", "::", "STRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR spill: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "StrOpc", ")", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg2", ")", ";", "MIB", ".", "addReg", "(", "Reg2", ",", "getPrologueDeath", "(", "MF", ",", "Reg2", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getPrologueDeath", "(", "MF", ",", "Reg1", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "8", "AArch64::STPXi", "AArch64::STRXui", "AArch64::STPDi", "AArch64::STRDui", "\"CSR spill: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "void", "mmix_asm_output_aligned_local", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ")", "{", "switch_to_section", "(", "data_section", ")", ";", "ASM_OUTPUT_ALIGN", "(", "stream", ",", "exact_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\tLOC @+%d\\n\"", ",", "size", ")", ";", "}", "</s>" ]

[ "ASM_OUTPUT_ALIGNED_LOCAL", "." ]

[ "mmix", "\"\\tLOC @+%d\\n\"" ]

[]

[ "<s>", "bool", "X86IntelAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "TargetData", "*", "TD", "=", "TM", ".", "getTargetData", "(", ")", ";", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isDeclaration", "(", ")", ")", "continue", ";", "if", "(", "EmitSpecialLLVMGlobal", "(", "I", ")", ")", "continue", ";", "std", "::", "string", "name", "=", "Mang", "->", "getValueName", "(", "I", ")", ";", "Constant", "*", "C", "=", "I", "->", "getInitializer", "(", ")", ";", "unsigned", "Align", "=", "TD", "->", "getPreferredAlignmentLog", "(", "I", ")", ";", "bool", "bCustomSegment", "=", "false", ";", "switch", "(", "I", "->", "getLinkage", "(", ")", ")", "{", "case", "GlobalValue", "::", "CommonLinkage", ":", "case", "GlobalValue", "::", "LinkOnceAnyLinkage", ":", "case", "GlobalValue", "::", "LinkOnceODRLinkage", ":", "case", "GlobalValue", "::", "WeakAnyLinkage", ":", "case", "GlobalValue", "::", "WeakODRLinkage", ":", "SwitchToDataSection", "(", "\"\"", ")", ";", "O", "<<", "name", "<<", "\"?\\tsegment common 'COMMON'\\n\"", ";", "bCustomSegment", "=", "true", ";", "break", ";", "case", "GlobalValue", "::", "AppendingLinkage", ":", "SwitchToDataSection", "(", "\"\"", ")", ";", "O", "<<", "name", "<<", "\"?\\tsegment public 'DATA'\\n\"", ";", "bCustomSegment", "=", "true", ";", "break", ";", "case", "GlobalValue", "::", "DLLExportLinkage", ":", "DLLExportedGVs", ".", "insert", "(", "name", ")", ";", "case", "GlobalValue", "::", "ExternalLinkage", ":", "O", "<<", "\"\\tpublic \"", "<<", "name", "<<", "\"\\n\"", ";", "case", "GlobalValue", "::", "InternalLinkage", ":", "SwitchToSection", "(", "TAI", "->", "getDataSection", "(", ")", ")", ";", "break", ";", "default", ":", "assert", "(", "0", "&&", "\"Unknown linkage type!\"", ")", ";", "}", "if", "(", "!", "bCustomSegment", ")", "EmitAlignment", "(", "Align", ",", "I", ")", ";", "O", "<<", "name", "<<", "\":\"", ";", "if", "(", "VerboseAsm", ")", "O", "<<", "name", "<<", "\"\\t\\t\\t\\t\"", "<<", "TAI", "->", "getCommentString", "(", ")", "<<", "\" \"", "<<", "I", "->", "getName", "(", ")", ";", "O", "<<", "'\\n'", ";", "EmitGlobalConstant", "(", "C", ")", ";", "if", "(", "bCustomSegment", ")", "O", "<<", "name", "<<", "\"?\\tends\\n\"", ";", "}", "if", "(", "!", "DLLExportedGVs", ".", "empty", "(", ")", "||", "!", "DLLExportedFns", ".", "empty", "(", ")", ")", "{", "SwitchToDataSection", "(", "\"\"", ")", ";", "O", "<<", "\"; WARNING: The following code is valid only with MASM v8.x\"", "<<", "\"and (possible) higher\\n\"", "<<", "\"; This version of MASM is usually shipped with Microsoft \"", "<<", "\"Visual Studio 2005\\n\"", "<<", "\"; or (possible) further versions. Unfortunately, there is no \"", "<<", "\"way to support\\n\"", "<<", "\"; dllexported symbols in the earlier versions of MASM in fully \"", "<<", "\"automatic way\\n\\n\"", ";", "O", "<<", "\"_drectve\\t segment info alias('.drectve')\\n\"", ";", "}", "for", "(", "StringSet", "<", ">", "::", "iterator", "i", "=", "DLLExportedGVs", ".", "begin", "(", ")", ",", "e", "=", "DLLExportedGVs", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "O", "<<", "\"\\t db ' /EXPORT:\"", "<<", "i", "->", "getKeyData", "(", ")", "<<", "\",data'\\n\"", ";", "for", "(", "StringSet", "<", ">", "::", "iterator", "i", "=", "DLLExportedFns", ".", "begin", "(", ")", ",", "e", "=", "DLLExportedFns", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "O", "<<", "\"\\t db ' /EXPORT:\"", "<<", "i", "->", "getKeyData", "(", ")", "<<", "\"'\\n\"", ";", "if", "(", "!", "DLLExportedGVs", ".", "empty", "(", ")", "||", "!", "DLLExportedFns", ".", "empty", "(", ")", ")", "O", "<<", "\"_drectve\\t ends\\n\"", ";", "bool", "Result", "=", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "SwitchToDataSection", "(", "\"\"", ")", ";", "O", "<<", "\"\\tend\\n\"", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\"", "\"?\\tsegment common 'COMMON'\\n\"", "\"\"", "\"?\\tsegment public 'DATA'\\n\"", "\"\\tpublic \"", "\"\\n\"", "0", "\"Unknown linkage type!\"", "\":\"", "\"\\t\\t\\t\\t\"", "\" \"", "\"?\\tends\\n\"", "\"\"", "\"; WARNING: The following code is valid only with MASM v8.x\"", "\"and (possible) higher\\n\"", "\"; This version of MASM is usually shipped with Microsoft \"", "\"Visual Studio 2005\\n\"", "\"; or (possible) further versions. Unfortunately, there is no \"", "\"way to support\\n\"", "\"; dllexported symbols in the earlier versions of MASM in fully \"", "\"automatic way\\n\\n\"", "\"_drectve\\t segment info alias('.drectve')\\n\"", "\"\\t db ' /EXPORT:\"", "\",data'\\n\"", "\"\\t db ' /EXPORT:\"", "\"'\\n\"", "\"_drectve\\t ends\\n\"", "\"\"", "\"\\tend\\n\"" ]

[]

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

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "AMDGPUUseNativeCalls", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", "||", "UseNative", ".", "empty", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ";", "++", "I", ";", "if", "(", "!", "CI", ")", "continue", ";", "Function", "*", "Callee", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "Callee", "==", "nullptr", ")", "continue", ";", "if", "(", "Simplifier", ".", "useNative", "(", "CI", ")", ")", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "Op", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unimplemented operation lowering\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "return", "LowerFrameIndex", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "case", "ISD", "::", "BRIND", ":", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented computed gotos\"", ")", ";", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CopyToReg", ":", "return", "LowerCopyToReg", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerAccessVectorElement", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerIntrinsic", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerShift", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT_SAT", ":", "case", "ISD", "::", "FP_TO_UINT_SAT", ":", "return", "LowerFP_TO_INT_SAT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLoad", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerStore", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTPOP", ":", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTTZ", ":", "return", "DAG", ".", "UnrollVectorOp", "(", "Op", ".", "getNode", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"unimplemented operation lowering\"", "ISD::FrameIndex", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::ExternalSymbol", "ISD::JumpTable", "ISD::BR_JT", "ISD::VASTART", "ISD::BlockAddress", "ISD::BRIND", "\"WebAssembly hasn't implemented computed gotos\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::CopyToReg", "ISD::EXTRACT_VECTOR_ELT", "ISD::INSERT_VECTOR_ELT", "ISD::INTRINSIC_VOID", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "ISD::SIGN_EXTEND_INREG", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SETCC", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::FP_TO_SINT_SAT", "ISD::FP_TO_UINT_SAT", "ISD::LOAD", "ISD::STORE", "ISD::CTPOP", "ISD::CTLZ", "ISD::CTTZ" ]

[]

[ "<s>", "const", "char", "*", "HexagonRegisterInfo", "::", "getRegPressureSetName", "(", "unsigned", "Idx", ")", "const", "{", "static", "const", "char", "*", "const", "RegPressureSetName", "[", "]", "=", "{", "\"IntRegsRegSet\"", ",", "\"CRRegsRegSet\"", ",", "\"PredRegsRegSet\"", ",", "\"DoubleRegsRegSet\"", "}", ";", "assert", "(", "(", "Idx", "<", "4", ")", "&&", "\"Index out of bounds\"", ")", ";", "return", "RegPressureSetName", "[", "Idx", "]", ";", "}", "</s>" ]

[ "Get", "the", "name", "of", "this", "register", "unit", "pressure", "set", "." ]

[ "Hexagon", "Hexagon", "\"IntRegsRegSet\"", "\"CRRegsRegSet\"", "\"PredRegsRegSet\"", "\"DoubleRegsRegSet\"", "4", "\"Index out of bounds\"" ]

[]

[ "<s>", "static", "unsigned", "loongarch_pass_aggregate_num_fpr", "(", "const_tree", "type", ",", "loongarch_aggregate_field", "fields", "[", "2", "]", ")", "{", "int", "n", "=", "loongarch_flatten_aggregate_argument", "(", "type", ",", "fields", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "!", "SCALAR_FLOAT_TYPE_P", "(", "fields", "[", "i", "]", ".", "type", ")", ")", "return", "0", ";", "return", "n", ">", "0", "?", "n", ":", "0", ";", "}", "</s>" ]

[ "See", "whether", "TYPE", "is", "a", "record", "whose", "fields", "should", "be", "returned", "in", "one", "or", "two", "floating-point", "registers", ".", "If", "so", ",", "populate", "FIELDS", "accordingly", "." ]

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

[]

[ "<s>", "int", "mmix_use_simple_return", "(", "void", ")", "{", "int", "regno", ";", "int", "stack_space_to_allocate", "=", "(", "crtl", "->", "outgoing_args_size", "+", "crtl", "->", "args", ".", "pretend_args_size", "+", "get_frame_size", "(", ")", "+", "7", ")", "&", "~", "7", ";", "if", "(", "!", "TARGET_USE_RETURN_INSN", "||", "!", "reload_completed", ")", "return", "0", ";", "for", "(", "regno", "=", "255", ";", "regno", ">=", "MMIX_FIRST_GLOBAL_REGNUM", ";", "regno", "--", ")", "if", "(", "(", "(", "(", "regno", "!=", "MMIX_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", ")", ")", "||", "IS_MMIX_EH_RETURN_DATA_REG", "(", "regno", ")", ")", "return", "0", ";", "if", "(", "frame_pointer_needed", ")", "stack_space_to_allocate", "+=", "8", ";", "if", "(", "MMIX_CFUN_HAS_LANDING_PAD", ")", "stack_space_to_allocate", "+=", "16", ";", "else", "if", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", ")", "stack_space_to_allocate", "+=", "8", ";", "return", "stack_space_to_allocate", "==", "0", ";", "}", "</s>" ]

[ "Nonzero", "when", "the", "function", "epilogue", "is", "simple", "enough", "that", "a", "single", "``", "POP", "%", "d,0", "''", "should", "be", "used", "even", "within", "the", "function", "." ]

[ "mmix", "7", "7", "0", "255", "0", "8", "16", "8", "0" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "if", "(", "Count", "%", "4", "!=", "0", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "0x01000000", ",", "Endian", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Sparc", "4", "0", "4", "0", "support::endian", "0x01000000" ]

[]

[ "<s>", "int", "AArch64InstrInfo", "::", "getMemScale", "(", "unsigned", "Opc", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Opcode has unknown scale!\"", ")", ";", "case", "AArch64", "::", "LDRBBui", ":", "case", "AArch64", "::", "LDURBBi", ":", "case", "AArch64", "::", "LDRSBWui", ":", "case", "AArch64", "::", "LDURSBWi", ":", "case", "AArch64", "::", "STRBBui", ":", "case", "AArch64", "::", "STURBBi", ":", "return", "1", ";", "case", "AArch64", "::", "LDRHHui", ":", "case", "AArch64", "::", "LDURHHi", ":", "case", "AArch64", "::", "LDRSHWui", ":", "case", "AArch64", "::", "LDURSHWi", ":", "case", "AArch64", "::", "STRHHui", ":", "case", "AArch64", "::", "STURHHi", ":", "return", "2", ";", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDRSpre", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "LDURSWi", ":", "case", "AArch64", "::", "LDRWpre", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STRSpre", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "STRWpre", ":", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPWi", ":", "return", "4", ";", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDRDpre", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "LDRXpre", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STRDpre", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "STRXpre", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPXi", ":", "return", "8", ";", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "STRQpre", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "LDRQpre", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "STGOffset", ":", "case", "AArch64", "::", "STZGOffset", ":", "case", "AArch64", "::", "ST2GOffset", ":", "case", "AArch64", "::", "STZ2GOffset", ":", "case", "AArch64", "::", "STGPi", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Scaling", "factor", "for", "(", "scaled", "or", "unscaled", ")", "load", "or", "store", "." ]

[ "AArch64", "AArch64", "\"Opcode has unknown scale!\"", "AArch64::LDRBBui", "AArch64::LDURBBi", "AArch64::LDRSBWui", "AArch64::LDURSBWi", "AArch64::STRBBui", "AArch64::STURBBi", "1", "AArch64::LDRHHui", "AArch64::LDURHHi", "AArch64::LDRSHWui", "AArch64::LDURSHWi", "AArch64::STRHHui", "AArch64::STURHHi", "2", "AArch64::LDRSui", "AArch64::LDURSi", "AArch64::LDRSpre", "AArch64::LDRSWui", "AArch64::LDURSWi", "AArch64::LDRWpre", "AArch64::LDRWui", "AArch64::LDURWi", "AArch64::STRSui", "AArch64::STURSi", "AArch64::STRSpre", "AArch64::STRWui", "AArch64::STURWi", "AArch64::STRWpre", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPWi", "AArch64::STPSi", "AArch64::STPWi", "4", "AArch64::LDRDui", "AArch64::LDURDi", "AArch64::LDRDpre", "AArch64::LDRXui", "AArch64::LDURXi", "AArch64::LDRXpre", "AArch64::STRDui", "AArch64::STURDi", "AArch64::STRDpre", "AArch64::STRXui", "AArch64::STURXi", "AArch64::STRXpre", "AArch64::LDPDi", "AArch64::LDPXi", "AArch64::STPDi", "AArch64::STPXi", "8", "AArch64::LDRQui", "AArch64::LDURQi", "AArch64::STRQui", "AArch64::STURQi", "AArch64::STRQpre", "AArch64::LDPQi", "AArch64::LDRQpre", "AArch64::STPQi", "AArch64::STGOffset", "AArch64::STZGOffset", "AArch64::ST2GOffset", "AArch64::STZ2GOffset", "AArch64::STGPi", "16" ]

[]

[ "<s>", "bool", "RISCVMakeCompressibleOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", "||", "!", "Fn", ".", "getFunction", "(", ")", ".", "hasMinSize", "(", ")", ")", "return", "false", ";", "const", "RISCVSubtarget", "&", "STI", "=", "Fn", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "const", "RISCVInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "STI", ".", "hasStdExtC", "(", ")", ")", "return", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB: \"", "<<", "MBB", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "RegImmPair", "RegImm", "=", "getRegImmPairPreventingCompression", "(", "MI", ")", ";", "if", "(", "!", "RegImm", ".", "Reg", "&&", "RegImm", ".", "Imm", "==", "0", ")", "continue", ";", "SmallVector", "<", "MachineInstr", "*", ",", "8", ">", "MIs", ";", "Register", "NewReg", "=", "analyzeCompressibleUses", "(", "MI", ",", "RegImm", ",", "MIs", ")", ";", "if", "(", "!", "NewReg", ")", "continue", ";", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "RegImm", ".", "Reg", ")", ")", "{", "assert", "(", "isInt", "<", "12", ">", "(", "RegImm", ".", "Imm", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "RISCV", "::", "ADDI", ")", ",", "NewReg", ")", ".", "addReg", "(", "RegImm", ".", "Reg", ")", ".", "addImm", "(", "RegImm", ".", "Imm", ")", ";", "}", "else", "{", "assert", "(", "RegImm", ".", "Imm", "==", "0", ")", ";", "unsigned", "Opcode", "=", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "RegImm", ".", "Reg", ")", "?", "RISCV", "::", "FSGNJ_S", ":", "RISCV", "::", "FSGNJ_D", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "NewReg", ")", ".", "addReg", "(", "RegImm", ".", "Reg", ")", ".", "addReg", "(", "RegImm", ".", "Reg", ")", ";", "}", "for", "(", "MachineInstr", "*", "UpdateMI", ":", "MIs", ")", "updateOperands", "(", "*", "UpdateMI", ",", "RegImm", ",", "NewReg", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "\"MBB: \"", "\"\\n\"", "0", "8", "RISCV::GPRRegClass", "12", "RISCV::ADDI", "0", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FSGNJ_D" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Control Flow Finalizer Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Control Flow Finalizer Pass\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "hasHighOperandLatency", "(", "const", "TargetSchedModel", "&", "SchedModel", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "unsigned", "DDomain", "=", "DefMI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "unsigned", "UDomain", "=", "UseMI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "Subtarget", ".", "nonpipelinedVFP", "(", ")", "&&", "(", "DDomain", "==", "ARMII", "::", "DomainVFP", "||", "UDomain", "==", "ARMII", "::", "DomainVFP", ")", ")", "return", "true", ";", "unsigned", "Latency", "=", "SchedModel", ".", "computeOperandLatency", "(", "&", "DefMI", ",", "DefIdx", ",", "&", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "Latency", "<=", "3", ")", "return", "false", ";", "return", "DDomain", "==", "ARMII", "::", "DomainVFP", "||", "DDomain", "==", "ARMII", "::", "DomainNEON", "||", "UDomain", "==", "ARMII", "::", "DomainVFP", "||", "UDomain", "==", "ARMII", "::", "DomainNEON", ";", "}", "</s>" ]

[ "Compute", "operand", "latency", "between", "a", "def", "of", "'Reg", "'", "and", "a", "use", "in", "the", "current", "loop", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainMask", "ARMII::DomainVFP", "ARMII::DomainVFP", "3", "ARMII::DomainVFP", "ARMII::DomainNEON", "ARMII::DomainVFP", "ARMII::DomainNEON" ]

[]

[ "<s>", "int", "ARMFrameInfo", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "return", "ResolveFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ",", "0", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "xtensa_asan_shadow_offset", "(", "void", ")", "{", "return", "HOST_WIDE_INT_UC", "(", "0x10000000", ")", ";", "}", "</s>" ]

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

[ "xtensa", "0x10000000" ]

[]

[ "<s>", "static", "rtx", "get_free_reg", "(", "HARD_REG_SET", "regs_live", ")", "{", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "regs_live", ",", "1", ")", ")", "return", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "gcc_assert", "(", "!", "TEST_HARD_REG_BIT", "(", "regs_live", ",", "7", ")", ")", ";", "return", "gen_rtx_REG", "(", "Pmode", ",", "7", ")", ";", "}", "</s>" ]

[ "REGS_LIVE", "is", "the", "liveness", "information", "for", "the", "point", "for", "which", "we", "need", "this", "allocation", ".", "In", "some", "bare-bones", "exit", "blocks", ",", "r1", "is", "live", "at", "the", "start", ".", "We", "can", "even", "have", "all", "of", "r0", "..", "r3", "being", "live", ":", "__complex__", "long", "long", "f", "(", "double", "d", ")", "{", "if", "(", "d", "==", "0", ")", "return", "2", ";", "else", "return", "3", ";", "}", "INSN", "before", "which", "new", "insns", "are", "placed", "with", "will", "clobber", "the", "register", "we", "return", ".", "If", "a", "basic", "block", "consists", "only", "of", "setting", "the", "return", "value", "register", "to", "a", "pseudo", "and", "using", "that", "register", ",", "the", "return", "value", "is", "not", "live", "before", "or", "after", "this", "block", ",", "yet", "we", "we", "'ll", "insert", "our", "insns", "right", "in", "the", "middle", "." ]

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

[]

[ "<s>", "TargetPassConfig", "*", "WDC65816TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "WDC65816PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "WDC65816", "WDC", "WDC" ]

[]

[ "<s>", "Optional", "<", "RegImmPair", ">", "AArch64InstrInfo", "::", "isAddImmediate", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "const", "{", "int", "Sign", "=", "1", ";", "int64_t", "Offset", "=", "0", ";", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "!", "Op0", ".", "isReg", "(", ")", "||", "Reg", "!=", "Op0", ".", "getReg", "(", ")", ")", "return", "None", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "None", ";", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "Sign", "*=", "-", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "ADDSXri", ":", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "Offset", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "*", "Sign", ";", "int", "Shift", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "assert", "(", "(", "Shift", "==", "0", "||", "Shift", "==", "12", ")", "&&", "\"Shift can be either 0 or 12\"", ")", ";", "Offset", "=", "Offset", "<<", "Shift", ";", "}", "}", "return", "RegImmPair", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "Offset", "}", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "an", "instruction", "that", "adds", "an", "immediate", "value", "and", "a", "register", ",", "and", "stores", "the", "result", "in", "the", "given", "register", "Reg", ",", "return", "a", "pair", "of", "the", "source", "register", "and", "the", "offset", "which", "has", "been", "added", "." ]

[ "AArch64", "AArch64", "1", "0", "0", "AArch64::SUBWri", "AArch64::SUBXri", "AArch64::SUBSWri", "AArch64::SUBSXri", "1", "AArch64::ADDSWri", "AArch64::ADDSXri", "AArch64::ADDWri", "AArch64::ADDXri", "0", "1", "2", "2", "3", "0", "12", "\"Shift can be either 0 or 12\"", "1" ]

[]

[ "<s>", "bool", "isValid", "(", ")", "const", "{", "return", "isValue", "(", ")", "||", "!", "(", "OpN", "&", "Invalid", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "Hexagon" ]

[]

[ "<s>", "AArch64Subtarget", "&", "AArch64Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "FS", ",", "StringRef", "CPUString", ",", "StringRef", "TuneCPUString", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "if", "(", "TuneCPUString", ".", "empty", "(", ")", ")", "TuneCPUString", "=", "CPUString", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "TuneCPUString", ",", "FS", ")", ";", "initializeProperties", "(", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"generic\"" ]

[]

[ "<s>", "rtx", "nvptx_gen_shuffle", "(", "rtx", "dst", ",", "rtx", "src", ",", "rtx", "idx", ",", "nvptx_shuffle_kind", "kind", ")", "{", "rtx", "res", ";", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "SImode", ":", "res", "=", "gen_nvptx_shufflesi", "(", "dst", ",", "src", ",", "idx", ",", "GEN_INT", "(", "kind", ")", ")", ";", "break", ";", "case", "SFmode", ":", "res", "=", "gen_nvptx_shufflesf", "(", "dst", ",", "src", ",", "idx", ",", "GEN_INT", "(", "kind", ")", ")", ";", "break", ";", "case", "DImode", ":", "case", "DFmode", ":", "{", "rtx", "tmp0", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "nvptx_gen_unpack", "(", "tmp0", ",", "tmp1", ",", "src", ")", ")", ";", "emit_insn", "(", "nvptx_gen_shuffle", "(", "tmp0", ",", "tmp0", ",", "idx", ",", "kind", ")", ")", ";", "emit_insn", "(", "nvptx_gen_shuffle", "(", "tmp1", ",", "tmp1", ",", "idx", ",", "kind", ")", ")", ";", "emit_insn", "(", "nvptx_gen_pack", "(", "dst", ",", "tmp0", ",", "tmp1", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "break", ";", "case", "BImode", ":", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_sel_truesi", "(", "tmp", ",", "src", ",", "GEN_INT", "(", "1", ")", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "nvptx_gen_shuffle", "(", "tmp", ",", "tmp", ",", "idx", ",", "kind", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_NE", "(", "BImode", ",", "tmp", ",", "const0_rtx", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "break", ";", "case", "QImode", ":", "case", "HImode", ":", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmp", ",", "gen_rtx_fmt_e", "(", "ZERO_EXTEND", ",", "SImode", ",", "src", ")", ")", ")", ";", "emit_insn", "(", "nvptx_gen_shuffle", "(", "tmp", ",", "tmp", ",", "idx", ",", "kind", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dst", ",", "gen_rtx_fmt_e", "(", "TRUNCATE", ",", "GET_MODE", "(", "dst", ")", ",", "tmp", ")", ")", ")", ";", "res", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "an", "instruction", "or", "sequence", "to", "broadcast", "register", "REG", "across", "the", "vectors", "of", "a", "single", "warp", "." ]

[ "nvptx", "1" ]

[]

[ "<s>", "static", "rtx", "bfin_load_pic_reg", "(", "rtx", "dest", ")", "{", "struct", "cgraph_local_info", "*", "i", "=", "NULL", ";", "rtx", "addr", ";", "i", "=", "cgraph_node", "::", "local_info", "(", "current_function_decl", ")", ";", "if", "(", "i", "&&", "i", "->", "local", ")", "return", "pic_offset_table_rtx", ";", "if", "(", "global_options_set", ".", "x_bfin_library_id", ")", "addr", "=", "plus_constant", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "-", "4", "-", "bfin_library_id", "*", "4", ")", ";", "else", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_LIBRARY_OFFSET", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "dest", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Used", "while", "emitting", "the", "prologue", "to", "generate", "code", "to", "load", "the", "correct", "value", "into", "the", "PIC", "register", ",", "which", "is", "passed", "in", "DEST", "." ]

[ "bfin", "4", "4", "1" ]

[]

[ "<s>", "static", "rtx", "ix86_builtin_setjmp_frame_value", "(", "void", ")", "{", "return", "stack_realign_fp", "?", "hard_frame_pointer_rtx", ":", "virtual_stack_vars_rtx", ";", "}", "</s>" ]

[ "In", "a", "dynamically-aligned", "function", ",", "we", "ca", "n't", "know", "the", "offset", "from", "stack", "pointer", "to", "frame", "pointer", ",", "so", "we", "must", "ensure", "that", "setjmp", "eliminates", "fp", "against", "the", "hard", "fp", "(", "%", "ebp", ")", "rather", "than", "trying", "to", "index", "from", "%", "esp", "up", "to", "the", "top", "of", "the", "frame", "across", "a", "gap", "that", "is", "of", "unknown", "(", "at", "compile-time", ")", "size", "." ]

[ "i386" ]

[]

[ "<s>", "static", "rtx", "cpu_expand_builtin", "(", "enum", "rs6000_builtins", "fcode", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ",", "rtx", "target", ")", "{", "if", "(", "fcode", "==", "RS6000_BUILTIN_CPU_INIT", ")", "return", "const0_rtx", ";", "if", "(", "target", "==", "0", "||", "GET_MODE", "(", "target", ")", "!=", "SImode", ")", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "tree", "arg", "=", "TREE_OPERAND", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ",", "0", ")", ";", "if", "(", "TREE_CODE", "(", "arg", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"builtin %s only accepts a string argument\"", ",", "rs6000_builtin_info", "[", "(", "size_t", ")", "fcode", "]", ".", "name", ")", ";", "return", "const0_rtx", ";", "}", "if", "(", "fcode", "==", "RS6000_BUILTIN_CPU_IS", ")", "{", "const", "char", "*", "cpu", "=", "TREE_STRING_POINTER", "(", "arg", ")", ";", "rtx", "cpuid", "=", "NULL_RTX", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "cpu_is_info", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "cpu", ",", "cpu_is_info", "[", "i", "]", ".", "cpu", ")", "==", "0", ")", "{", "cpuid", "=", "GEN_INT", "(", "cpu_is_info", "[", "i", "]", ".", "cpuid", "+", "_DL_FIRST_PLATFORM", ")", ";", "break", ";", "}", "if", "(", "cpuid", "==", "NULL_RTX", ")", "{", "error", "(", "\"cpu %s is an invalid argument to builtin %s\"", ",", "cpu", ",", "rs6000_builtin_info", "[", "(", "size_t", ")", "fcode", "]", ".", "name", ")", ";", "return", "const0_rtx", ";", "}", "rtx", "platform", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tcbmem", "=", "gen_const_mem", "(", "SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "TLS_REGNUM", ")", ",", "GEN_INT", "(", "TCB_PLATFORM_OFFSET", ")", ")", ")", ";", "emit_move_insn", "(", "platform", ",", "tcbmem", ")", ";", "emit_insn", "(", "gen_eqsi3", "(", "target", ",", "platform", ",", "cpuid", ")", ")", ";", "}", "else", "if", "(", "fcode", "==", "RS6000_BUILTIN_CPU_SUPPORTS", ")", "{", "const", "char", "*", "hwcap", "=", "TREE_STRING_POINTER", "(", "arg", ")", ";", "rtx", "mask", "=", "NULL_RTX", ";", "int", "hwcap_offset", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "cpu_supports_info", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "hwcap", ",", "cpu_supports_info", "[", "i", "]", ".", "hwcap", ")", "==", "0", ")", "{", "mask", "=", "GEN_INT", "(", "cpu_supports_info", "[", "i", "]", ".", "mask", ")", ";", "hwcap_offset", "=", "TCB_HWCAP_OFFSET", "(", "cpu_supports_info", "[", "i", "]", ".", "id", ")", ";", "break", ";", "}", "if", "(", "mask", "==", "NULL_RTX", ")", "{", "error", "(", "\"hwcap %s is an invalid argument to builtin %s\"", ",", "hwcap", ",", "rs6000_builtin_info", "[", "(", "size_t", ")", "fcode", "]", ".", "name", ")", ";", "return", "const0_rtx", ";", "}", "rtx", "tcb_hwcap", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tcbmem", "=", "gen_const_mem", "(", "SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "TLS_REGNUM", ")", ",", "GEN_INT", "(", "hwcap_offset", ")", ")", ")", ";", "emit_move_insn", "(", "tcb_hwcap", ",", "tcbmem", ")", ";", "rtx", "scratch1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "scratch1", ",", "gen_rtx_AND", "(", "SImode", ",", "tcb_hwcap", ",", "mask", ")", ")", ")", ";", "rtx", "scratch2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_eqsi3", "(", "scratch2", ",", "scratch1", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "gen_rtx_XOR", "(", "SImode", ",", "scratch2", ",", "const1_rtx", ")", ")", ")", ";", "}", "cpu_builtin_p", "=", "true", ";", "emit_move_insn", "(", "target", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "the", "CPU", "builtin", "in", "FCODE", "and", "store", "the", "result", "in", "TARGET", "." ]

[ "powerpcspe", "0", "0", "0", "\"builtin %s only accepts a string argument\"", "0", "0", "\"cpu %s is an invalid argument to builtin %s\"", "0", "0", "\"hwcap %s is an invalid argument to builtin %s\"", "0" ]

[]

[ "<s>", "unsigned", "AMDGPUTTIImpl", "::", "getNumberOfRegisters", "(", "bool", "Vec", ")", "{", "if", "(", "Vec", ")", "return", "0", ";", "if", "(", "ST", "->", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "return", "256", ";", "return", "4", "*", "128", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "R600", "0", "256", "4", "128" ]

[]

[ "<s>", "static", "void", "unicosmk_output_module_name", "(", "FILE", "*", "file", ")", "{", "const", "char", "*", "name", "=", "lbasename", "(", "main_input_filename", ")", ";", "unsigned", "len", "=", "strlen", "(", "name", ")", ";", "char", "*", "clean_name", "=", "alloca", "(", "len", "+", "2", ")", ";", "char", "*", "ptr", "=", "clean_name", ";", "if", "(", "!", "ISALPHA", "(", "*", "name", ")", ")", "*", "ptr", "++", "=", "'$'", ";", "memcpy", "(", "ptr", ",", "name", ",", "len", "+", "1", ")", ";", "clean_symbol_name", "(", "clean_name", ")", ";", "fputs", "(", "clean_name", ",", "file", ")", ";", "}", "</s>" ]

[ "Output", "the", "module", "name", "for", ".ident", "and", ".end", "directives", ".", "We", "have", "to", "strip", "directories", "and", "add", "make", "sure", "that", "the", "module", "name", "starts", "with", "a", "letter", "or", "'", "$", "'", "." ]

[ "alpha", "2", "1" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "Options", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

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

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

[]

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

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Lanai" ]

[]

[ "<s>", "Optional", "<", "bool", ">", "isSyncScopeInclusion", "(", "SyncScope", "::", "ID", "A", ",", "SyncScope", "::", "ID", "B", ")", "const", "{", "const", "auto", "&", "AIO", "=", "getSyncScopeInclusionOrdering", "(", "A", ")", ";", "const", "auto", "&", "BIO", "=", "getSyncScopeInclusionOrdering", "(", "B", ")", ";", "if", "(", "!", "AIO", "||", "!", "BIO", ")", "return", "None", ";", "bool", "IsAOneAddressSpace", "=", "isOneAddressSpace", "(", "A", ")", ";", "bool", "IsBOneAddressSpace", "=", "isOneAddressSpace", "(", "B", ")", ";", "return", "AIO", ".", "getValue", "(", ")", ">=", "BIO", ".", "getValue", "(", ")", "&&", "(", "IsAOneAddressSpace", "==", "IsBOneAddressSpace", "||", "!", "IsAOneAddressSpace", ")", ";", "}", "</s>" ]

[ "In", "AMDGPU", "target", "synchronization", "scopes", "are", "inclusive", ",", "meaning", "a", "larger", "synchronization", "scope", "is", "inclusive", "of", "a", "smaller", "synchronization", "scope", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "PPCFastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "LI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "false", ";", "bool", "IsZExt", "=", "false", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "RLDICL", ":", "case", "PPC", "::", "RLDICL_32_64", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "56", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "48", ")", "||", "(", "VT", "==", "MVT", "::", "i32", "&&", "MB", "<=", "32", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "RLWINM", ":", "case", "PPC", "::", "RLWINM8", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "24", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "16", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "EXTSB", ":", "case", "PPC", "::", "EXTSB8", ":", "case", "PPC", "::", "EXTSB8_32_64", ":", "return", "false", ";", "case", "PPC", "::", "EXTSH", ":", "case", "PPC", "::", "EXTSH8", ":", "case", "PPC", "::", "EXTSH8_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "}", "Address", "Addr", ";", "if", "(", "!", "PPCComputeAddress", "(", "LI", "->", "getOperand", "(", "0", ")", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "PPCEmitLoad", "(", "VT", ",", "ResultReg", ",", "Addr", ",", "nullptr", ",", "IsZExt", ")", ")", "return", "false", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

[ "PowerPC", "PPC", "PPC::RLDICL", "PPC::RLDICL_32_64", "3", "MVT::i8", "56", "MVT::i16", "48", "MVT::i32", "32", "PPC::RLWINM", "PPC::RLWINM8", "3", "MVT::i8", "24", "MVT::i16", "16", "PPC::EXTSB", "PPC::EXTSB8", "PPC::EXTSB8_32_64", "PPC::EXTSH", "PPC::EXTSH8", "PPC::EXTSH8_32_64", "MVT::i16", "MVT::i8", "PPC::EXTSW", "PPC::EXTSW_32", "PPC::EXTSW_32_64", "MVT::i32", "MVT::i16", "MVT::i8", "PPC", "0", "0", "PPC" ]

[]

[ "<s>", "bool", "isValid", "(", ")", "{", "return", "isFIBase", "(", ")", "||", "(", "isRegBase", "(", ")", "&&", "getReg", "(", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "AArch64", "0" ]

[]

[ "<s>", "const", "AMDGPUCallLowering", "*", "getCallLowering", "(", ")", "const", "override", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "AArch64II", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_COFFSTUB", ",", "\"aarch64-coffstub\"", "}", ",", "{", "MO_GOT", ",", "\"aarch64-got\"", "}", ",", "{", "MO_NC", ",", "\"aarch64-nc\"", "}", ",", "{", "MO_S", ",", "\"aarch64-s\"", "}", ",", "{", "MO_TLS", ",", "\"aarch64-tls\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"aarch64-dllimport\"", "}", ",", "{", "MO_PREL", ",", "\"aarch64-prel\"", "}", ",", "{", "MO_TAGGED", ",", "\"aarch64-tagged\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"aarch64-coffstub\"", "\"aarch64-got\"", "\"aarch64-nc\"", "\"aarch64-s\"", "\"aarch64-tls\"", "\"aarch64-dllimport\"", "\"aarch64-prel\"", "\"aarch64-tagged\"" ]

[]

[ "<s>", "static", "void", "sparc_fpu_init_builtins", "(", "void", ")", "{", "tree", "ftype", "=", "build_function_type_list", "(", "void_type_node", ",", "build_pointer_type", "(", "unsigned_type_node", ")", ",", "0", ")", ";", "def_builtin", "(", "\"__builtin_load_fsr\"", ",", "CODE_FOR_ldfsr", ",", "SPARC_BUILTIN_LDFSR", ",", "ftype", ")", ";", "def_builtin", "(", "\"__builtin_store_fsr\"", ",", "CODE_FOR_stfsr", ",", "SPARC_BUILTIN_STFSR", ",", "ftype", ")", ";", "}", "</s>" ]

[ "Create", "builtin", "functions", "for", "FPU", "instructions", "." ]

[ "sparc", "0", "\"__builtin_load_fsr\"", "\"__builtin_store_fsr\"" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "Cpu0FunctionInfo", "*", "Cpu0FI", "=", "MF", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "Cpu0FI", "->", "setVarArgsFrameIndex", "(", "0", ")", ";", "std", "::", "vector", "<", "SDValue", ">", "OutChains", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_Cpu0", ")", ";", "Function", "::", "const_arg_iterator", "FuncArg", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "arg_begin", "(", ")", ";", "int", "LastFI", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ",", "++", "FuncArg", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "EVT", "ValVT", "=", "VA", ".", "getValVT", "(", ")", ";", "ISD", "::", "ArgFlagsTy", "Flags", "=", "Ins", "[", "i", "]", ".", "Flags", ";", "bool", "IsRegLoc", "=", "VA", ".", "isRegLoc", "(", ")", ";", "if", "(", "Flags", ".", "isByVal", "(", ")", ")", "{", "assert", "(", "Flags", ".", "getByValSize", "(", ")", "&&", "\"ByVal args of size 0 should have been ignored by front-end.\"", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "LastFI", "=", "MFI", "->", "CreateFixedObject", "(", "ValVT", ".", "getSizeInBits", "(", ")", "/", "8", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "true", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "LastFI", ",", "getPointerTy", "(", ")", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "ValVT", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "::", "getFixedStack", "(", "LastFI", ")", ",", "false", ",", "false", ",", "false", ",", "0", ")", ")", ";", "}", "Cpu0FI", "->", "setLastInArgFI", "(", "LastFI", ")", ";", "if", "(", "!", "OutChains", ".", "empty", "(", ")", ")", "{", "OutChains", ".", "push_back", "(", "Chain", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "dl", ",", "MVT", "::", "Other", ",", "&", "OutChains", "[", "0", "]", ",", "OutChains", ".", "size", "(", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "ISD::InputArg", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "0", "16", "Cpu0", "0", "0", "ISD::ArgFlagsTy", "\"ByVal args of size 0 should have been ignored by front-end.\"", "8", "0", "Cpu0", "ISD::TokenFactor", "MVT::Other", "0" ]

[]

[ "<s>", "static", "bool", "arm_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "TARGET_NEON", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode1", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode1", ")", ")", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode2", ")", "||", "VALID_NEON_STRUCT_MODE", "(", "mode2", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", "." ]

[ "arm" ]

[]

[ "<s>", "void", "aarch64_expand_epilogue", "(", "bool", "for_sibcall", ")", "{", "aarch64_layout_frame", "(", ")", ";", "poly_int64", "initial_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "initial_adjust", ";", "HOST_WIDE_INT", "callee_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_adjust", ";", "poly_int64", "final_adjust", "=", "cfun", "->", "machine", "->", "frame", ".", "final_adjust", ";", "poly_int64", "callee_offset", "=", "cfun", "->", "machine", "->", "frame", ".", "callee_offset", ";", "unsigned", "reg1", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate1", ";", "unsigned", "reg2", "=", "cfun", "->", "machine", "->", "frame", ".", "wb_candidate2", ";", "rtx", "cfi_ops", "=", "NULL", ";", "rtx_insn", "*", "insn", ";", "bool", "can_inherit_p", "=", "(", "initial_adjust", ".", "is_constant", "(", ")", "&&", "final_adjust", ".", "is_constant", "(", ")", "&&", "!", "flag_stack_clash_protection", ")", ";", "bool", "need_barrier_p", "=", "maybe_ne", "(", "get_frame_size", "(", ")", "+", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", ",", "0", ")", ";", "if", "(", "maybe_gt", "(", "final_adjust", ",", "crtl", "->", "outgoing_args_size", ")", "||", "cfun", "->", "calls_alloca", "||", "crtl", "->", "calls_eh_return", ")", "{", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "need_barrier_p", "=", "false", ";", "}", "rtx", "ip0_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP0_REGNUM", ")", ";", "rtx", "ip1_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IP1_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", "&&", "(", "maybe_ne", "(", "final_adjust", ",", "0", ")", "||", "cfun", "->", "calls_alloca", ")", ")", "aarch64_add_offset", "(", "Pmode", ",", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "-", "callee_offset", ",", "ip1_rtx", ",", "ip0_rtx", ",", "callee_adjust", "==", "0", ")", ";", "else", "aarch64_add_sp", "(", "ip1_rtx", ",", "ip0_rtx", ",", "final_adjust", ",", "!", "can_inherit_p", "||", "df_regs_ever_live_p", "(", "IP1_REGNUM", ")", ")", ";", "aarch64_restore_callee_saves", "(", "DImode", ",", "callee_offset", ",", "R0_REGNUM", ",", "R30_REGNUM", ",", "callee_adjust", "!=", "0", ",", "&", "cfi_ops", ")", ";", "aarch64_restore_callee_saves", "(", "DFmode", ",", "callee_offset", ",", "V0_REGNUM", ",", "V31_REGNUM", ",", "callee_adjust", "!=", "0", ",", "&", "cfi_ops", ")", ";", "if", "(", "need_barrier_p", ")", "emit_insn", "(", "gen_stack_tie", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "callee_adjust", "!=", "0", ")", "aarch64_pop_regs", "(", "reg1", ",", "reg2", ",", "callee_adjust", ",", "&", "cfi_ops", ")", ";", "if", "(", "callee_adjust", "!=", "0", "||", "maybe_gt", "(", "initial_adjust", ",", "65536", ")", ")", "{", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "new_cfa", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "initial_adjust", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "new_cfa", ",", "cfi_ops", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "cfi_ops", "=", "NULL", ";", "}", "aarch64_add_sp", "(", "ip0_rtx", ",", "ip1_rtx", ",", "initial_adjust", ",", "!", "can_inherit_p", "||", "df_regs_ever_live_p", "(", "IP0_REGNUM", ")", ")", ";", "if", "(", "cfi_ops", ")", "{", "insn", "=", "get_last_insn", "(", ")", ";", "cfi_ops", "=", "alloc_reg_note", "(", "REG_CFA_DEF_CFA", ",", "stack_pointer_rtx", ",", "cfi_ops", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "cfi_ops", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "aarch64_return_address_signing_enabled", "(", ")", "&&", "(", "for_sibcall", "||", "!", "TARGET_ARMV8_3", "||", "crtl", "->", "calls_eh_return", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_autisp", "(", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_TOGGLE_RA_MANGLE", ",", "const0_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "emit_insn", "(", "gen_add2_insn", "(", "stack_pointer_rtx", ",", "EH_RETURN_STACKADJ_RTX", ")", ")", ";", "}", "emit_use", "(", "gen_rtx_REG", "(", "DImode", ",", "LR_REGNUM", ")", ")", ";", "if", "(", "!", "for_sibcall", ")", "emit_jump_insn", "(", "ret_rtx", ")", ";", "}", "</s>" ]

[ "Generate", "the", "epilogue", "instructions", "for", "returning", "from", "a", "function", "." ]

[ "aarch64", "0", "0", "0", "0", "0", "0", "0", "65536", "1", "1", "1" ]

[]

[ "<s>", "int", "SystemZHazardRecognizer", "::", "resourcesCost", "(", "SUnit", "*", "SU", ")", "{", "int", "Cost", "=", "0", ";", "const", "MCSchedClassDesc", "*", "SC", "=", "getSchedClass", "(", "SU", ")", ";", "if", "(", "!", "SC", "->", "isValid", "(", ")", ")", "return", "0", ";", "if", "(", "SU", "->", "isUnbuffered", ")", "Cost", "=", "(", "isFPdOpPreferred_distance", "(", "SU", ")", "?", "INT_MIN", ":", "INT_MAX", ")", ";", "else", "if", "(", "CriticalResourceIdx", "!=", "UINT_MAX", ")", "{", "for", "(", "TargetSchedModel", "::", "ProcResIter", "PI", "=", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "PE", "=", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ";", "PI", "!=", "PE", ";", "++", "PI", ")", "if", "(", "PI", "->", "ProcResourceIdx", "==", "CriticalResourceIdx", ")", "Cost", "=", "PI", "->", "Cycles", ";", "}", "return", "Cost", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "SU", "in", "regards", "to", "processor", "resources", "usage", "." ]

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

[]

[ "<s>", "SUnit", "*", "ConvergingVLIWScheduler", "::", "pickNode", "(", "bool", "&", "IsTopNode", ")", "{", "if", "(", "DAG", "->", "top", "(", ")", "==", "DAG", "->", "bottom", "(", ")", ")", "{", "assert", "(", "Top", ".", "Available", ".", "empty", "(", ")", "&&", "Top", ".", "Pending", ".", "empty", "(", ")", "&&", "Bot", ".", "Available", ".", "empty", "(", ")", "&&", "Bot", ".", "Pending", ".", "empty", "(", ")", "&&", "\"ReadyQ garbage\"", ")", ";", "return", "NULL", ";", "}", "SUnit", "*", "SU", ";", "if", "(", "llvm", "::", "ForceTopDown", ")", "{", "SU", "=", "Top", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "TopCand", ";", "CandResult", "TopResult", "=", "pickNodeFromQueue", "(", "Top", ".", "Available", ",", "DAG", "->", "getTopRPTracker", "(", ")", ",", "TopCand", ")", ";", "assert", "(", "TopResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "TopResult", ";", "SU", "=", "TopCand", ".", "SU", ";", "}", "IsTopNode", "=", "true", ";", "}", "else", "if", "(", "llvm", "::", "ForceBottomUp", ")", "{", "SU", "=", "Bot", ".", "pickOnlyChoice", "(", ")", ";", "if", "(", "!", "SU", ")", "{", "SchedCandidate", "BotCand", ";", "CandResult", "BotResult", "=", "pickNodeFromQueue", "(", "Bot", ".", "Available", ",", "DAG", "->", "getBotRPTracker", "(", ")", ",", "BotCand", ")", ";", "assert", "(", "BotResult", "!=", "NoCand", "&&", "\"failed to find the first candidate\"", ")", ";", "(", "void", ")", "BotResult", ";", "SU", "=", "BotCand", ".", "SU", ";", "}", "IsTopNode", "=", "false", ";", "}", "else", "{", "SU", "=", "pickNodeBidrectional", "(", "IsTopNode", ")", ";", "}", "if", "(", "SU", "->", "isTopReady", "(", ")", ")", "Top", ".", "removeReady", "(", "SU", ")", ";", "if", "(", "SU", "->", "isBottomReady", "(", ")", ")", "Bot", ".", "removeReady", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "(", "IsTopNode", "?", "\"Top\"", ":", "\"Bottom\"", ")", "<<", "\" Scheduling Instruction in cycle \"", "<<", "(", "IsTopNode", "?", "Top", ".", "CurrCycle", ":", "Bot", ".", "CurrCycle", ")", "<<", "'\\n'", ";", "SU", "->", "dump", "(", "DAG", ")", ")", ";", "return", "SU", ";", "}", "</s>" ]

[ "Pick", "the", "next", "node", "to", "schedule", ",", "or", "return", "NULL", "." ]

[ "Hexagon", "\"ReadyQ garbage\"", "\"failed to find the first candidate\"", "\"failed to find the first candidate\"", "\"*** \"", "\"Top\"", "\"Bottom\"", "\" Scheduling Instruction in cycle \"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AArch64InstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "Candidate", "&", "C", ")", "const", "{", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "TCRETURNdi", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", "It", ";", "}", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerNoLRSave", "||", "C", ".", "CallConstructionID", "==", "MachineOutlinerThunk", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "return", "It", ";", "}", "MachineBasicBlock", "::", "iterator", "CallPt", ";", "MachineInstr", "*", "Save", ";", "MachineInstr", "*", "Restore", ";", "if", "(", "C", ".", "CallConstructionID", "==", "MachineOutlinerRegSave", ")", "{", "unsigned", "Reg", "=", "findRegisterToSaveLRTo", "(", "C", ")", ";", "assert", "(", "Reg", "!=", "0", "&&", "\"No callee-saved register available?\"", ")", ";", "Save", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "ORRXrs", ")", ",", "Reg", ")", ".", "addReg", "(", "AArch64", "::", "XZR", ")", ".", "addReg", "(", "AArch64", "::", "LR", ")", ".", "addImm", "(", "0", ")", ";", "Restore", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "ORRXrs", ")", ",", "AArch64", "::", "LR", ")", ".", "addReg", "(", "AArch64", "::", "XZR", ")", ".", "addReg", "(", "Reg", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "Save", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "STRXpre", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "-", "16", ")", ";", "Restore", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "LDRXpost", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "16", ")", ";", "}", "It", "=", "MBB", ".", "insert", "(", "It", ",", "Save", ")", ";", "It", "++", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "CallPt", "=", "It", ";", "It", "++", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "Restore", ")", ";", "return", "CallPt", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "AArch64", "AArch64", "AArch64::TCRETURNdi", "0", "AArch64::BL", "0", "\"No callee-saved register available?\"", "AArch64::ORRXrs", "AArch64::XZR", "AArch64::LR", "0", "AArch64::ORRXrs", "AArch64::LR", "AArch64::XZR", "0", "AArch64::STRXpre", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16", "AArch64::LDRXpost", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16", "AArch64::BL" ]

[]

[ "<s>", "bool", "ARMFastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "ARM", "ARM", "MVT::Other" ]

[]

[ "<s>", "rtx", "function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "result", "=", "0", ";", "int", "size", ",", "align", ";", "int", "nregs", "=", "2", ";", "if", "(", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "align", "=", "size", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "3", ")", "&", "~", "3", ";", "if", "(", "cum", "->", "nbytes", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "nregs", "*", "UNITS_PER_WORD", ")", "return", "0", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "0", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "break", ";", "case", "1", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "1", ")", ";", "break", ";", "default", ":", "result", "=", "0", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Return", "an", "RTL", "expression", "containing", "the", "register", "for", "the", "given", "mode", ",", "or", "0", "if", "the", "argument", "is", "to", "be", "passed", "on", "the", "stack", ".", "INCOMING_P", "is", "nonzero", "if", "this", "is", "an", "incoming", "argument", "to", "the", "current", "function", "." ]

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

[]

[ "<s>", "void", "arc_cpu_cpp_builtins", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_assert", "(", "\"cpu=arc\"", ")", ";", "builtin_assert", "(", "\"machine=arc\"", ")", ";", "builtin_define", "(", "\"__arc__\"", ")", ";", "def_or_undef_macro", "(", "pfile", ",", "NAME", ",", "CONDITION", ")", ";", "builtin_define_with_int_value", "(", "\"__ARC_TLS_REGNO__\"", ",", "arc_tp_regno", ")", ";", "builtin_define", "(", "TARGET_BIG_ENDIAN", "?", "\"__BIG_ENDIAN__\"", ":", "\"__LITTLE_ENDIAN__\"", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", ")", "builtin_define", "(", "\"__big_endian__\"", ")", ";", "}", "</s>" ]

[ "Helper", "for", "TARGET_CPU_CPP_BUILTINS", "hook", "." ]

[ "arc", "\"cpu=arc\"", "\"machine=arc\"", "\"__arc__\"", "\"__ARC_TLS_REGNO__\"", "\"__BIG_ENDIAN__\"", "\"__LITTLE_ENDIAN__\"", "\"__big_endian__\"" ]

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "hasStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k" ]

[]

[ "<s>", "static", "void", "preprocess_args", "(", "int", "argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-shared\"", ")", "==", "0", ")", "{", "share", "=", "1", ";", "break", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<", "argc", ";", "i", "++", ")", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-o\"", ")", "==", "0", ")", "{", "int", "len", ";", "i", "++", ";", "exefilename", "=", "lbasename", "(", "argv", "[", "i", "]", ")", ";", "exefullfilename", "=", "xstrdup", "(", "to_host_file_spec", "(", "argv", "[", "i", "]", ")", ")", ";", "if", "(", "share", ")", "addarg", "(", "\" /share=\"", ")", ";", "else", "addarg", "(", "\" /exe=\"", ")", ";", "addarg", "(", "exefullfilename", ")", ";", "if", "(", "share", ")", "{", "char", "*", "ptr", ";", "ptr", "=", "strchr", "(", "argv", "[", "i", "]", ",", "']'", ")", ";", "if", "(", "ptr", "==", "NULL", ")", "ptr", "=", "strchr", "(", "argv", "[", "i", "]", ",", "':'", ")", ";", "if", "(", "ptr", "==", "NULL", ")", "ptr", "=", "strchr", "(", "argv", "[", "i", "]", ",", "'/'", ")", ";", "if", "(", "ptr", "==", "NULL", ")", "sharebasename", "=", "xstrdup", "(", "argv", "[", "i", "]", ")", ";", "else", "sharebasename", "=", "xstrdup", "(", "ptr", "+", "1", ")", ";", "len", "=", "strlen", "(", "sharebasename", ")", ";", "if", "(", "strncasecmp", "(", "&", "sharebasename", "[", "len", "-", "4", "]", ",", "\".exe\"", ",", "4", ")", "==", "0", ")", "sharebasename", "[", "len", "-", "4", "]", "=", "0", ";", "for", "(", "ptr", "=", "sharebasename", ";", "*", "ptr", ";", "ptr", "++", ")", "*", "ptr", "=", "TOUPPER", "(", "*", "ptr", ")", ";", "}", "}", "if", "(", "exefullfilename", "==", "NULL", "&&", "!", "share", ")", "{", "exefilename", "=", "\"a_out.exe\"", ";", "exefullfilename", "=", "\"a_out.exe\"", ";", "addarg", "(", "xstrdup", "(", "\" /exe=a_out.exe\"", ")", ")", ";", "}", "}", "</s>" ]

[ "Preprocess", "the", "number", "of", "args", "P_ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "first", "." ]

[ "vms", "1", "\"-shared\"", "0", "1", "1", "\"-o\"", "0", "\" /share=\"", "\" /exe=\"", "1", "4", "\".exe\"", "4", "0", "4", "0", "\"a_out.exe\"", "\"a_out.exe\"", "\" /exe=a_out.exe\"" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_rGPRRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::t2LDRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_rGPRRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "HOST_WIDE_INT", "pa_function_arg_size", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "HOST_WIDE_INT", "size", ";", "size", "=", "mode", "!=", "BLKmode", "?", "GET_MODE_SIZE", "(", "mode", ")", ":", "int_size_in_bytes", "(", "type", ")", ";", "return", "CEIL", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Figure", "out", "the", "size", "in", "words", "of", "the", "function", "argument", "." ]

[ "pa" ]

[]

[ "<s>", "static", "rtx_insn", "*", "vax_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "inputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "machine_mode", ">", "&", "input_modes", "ATTRIBUTE_UNUSED", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ",", "location_t", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "CCmode", ",", "VAX_PSL_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "VAX_PSL_REGNUM", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Mark", "PSL", "as", "clobbered", "for", "compatibility", "with", "the", "CC0", "representation", "." ]

[ "vax" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "assert", "(", "(", "(", "Val", "&&", "!", "VRegs", ".", "empty", "(", ")", ")", "||", "(", "!", "Val", "&&", "VRegs", ".", "empty", "(", ")", ")", ")", "&&", "\"Return value without a vreg\"", ")", ";", "auto", "MIB", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "X86", "::", "RET", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "const", "X86TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "X86TargetLowering", ">", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "CurArgInfo", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildUnmerge", "(", "Regs", ",", "VRegs", "[", "i", "]", ")", ";", "}", ")", ")", "return", "false", ";", "}", "X86OutgoingValueHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "MIB", ",", "RetCC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "X86", "X86", "\"Return value without a vreg\"", "X86::RET", "0", "X86", "X86", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "0", "X86", "X86" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "Cpu0" ]

[]

[ "<s>", "static", "bool", "ix86_check_avx256_register", "(", "const_rtx", "exp", ")", "{", "if", "(", "GET_CODE", "(", "exp", ")", "==", "SUBREG", ")", "exp", "=", "SUBREG_REG", "(", "exp", ")", ";", "return", "(", "REG_P", "(", "exp", ")", "&&", "VALID_AVX256_REG_OR_OI_MODE", "(", "GET_MODE", "(", "exp", ")", ")", ")", ";", "}", "</s>" ]

[ "Check", "if", "a", "256bit", "AVX", "register", "is", "referenced", "inside", "of", "EXP", "." ]

[ "i386" ]

[]